uvtc

My understanding is that battery capacity is the issue; it's usually above the max allowed on the plane. This company makes a snap-together battery https://ebikes.ca/product-info/grin-products/ligo10x-battery... where each individual module is below the limit and so the pack can be broken down and shipped individually and separately.

A rule I try to follow: don't waste your reader's time.

Happy thinkpenguin customer here. In the old days I researched hardware for GNU/Linux compat; now I just buy a system from them and everything just works.

I honestly don't get why Markdown became preferred in most projects over AsciiDoc.

I think the primary reason is because Markdown is prettier to read (and also secondarily because it's good enough).

There are lots of markup formats, but markdown is probably the easiest on the eyes.

I don't understand why they are not working in the open,

Fast compilation and nice, easy to read syntax with good default is exactly what I am looking for.

[re metaprogramming] ... but I also think this is a pandora box.

Sounds like you might also like [Hare](https://harelang.org/). (has some work-in-progress [SDL2 bindings](https://git.sr.ht/~sircmpwn/hare-sdl2))

{slow clap}

I have also used Fennel recently, and if Janet is anything as good,...

Fennel was created prior to Janet, by the same person. :)

It's nice that most of Janes the literals match Clojure

Two things:

* Janet doesn't have a built-in set data structure literal. Need to use a library for that.

* Janet has mutable and immutable versions of arrays and hashmaps (the literals for the mutable variety are prefixed with `@`)

I think it's partly due to: people like regular garden-variety arrays and hashmaps, and don't want to use car, cdr, cons. I like my array and hashmap literals.

killer feature: user provided examples

I agree. [Janet](https://janet-lang.org/) (which, coincidentally, has some superficial similarities to Clojure) has something similar at its [JanetDocs site](https://janetdocs.com/).

Looks like the name is "Xournal++", but the github repo name is "xournalpp".

The "pen display" is the type where it's a monitor with the transparent trackpad overlaid on it. That, I think, is what you want. I tried the other type, where you write on the tablet but you look at the screen elsewhere, and it was not fun.

The Wacom One is a fine choice (its their smallest and least expensive model). Maybe artists would need a larger one, but the Wacom One is, IMO, large enough to take notes on.

Haven't tried an iPad, but that Wacom is a really excellent writing/drawing experience.

How are your math skills? Do you know any calculus? Are you interested in learning more math to go with the physics?

Janet is small, simple, efficient, and practical. For me it has nice syntax and sensible semantics. Great little package manager too. Very happy with and excited about Janet so far.

Pandoc lets you write in Markdown but also include mathematics in LaTeX. For me this is a nice combination.

Would be nice if that tiny image on the top left of the homepage were clickable so I could see the screenshot full-size.

Well, it also has its very own [Hashlink, virtual machine](https://hashlink.haxe.org/).

And it can also compile down to various bytecodes (like JVM), not just to other languages.

Sounds like you'd like Haxe.

I'm not sure there's a catch, so much as there's just a number of comparable but corporate-backed alternatives that are seeing some popularity right now:

* TypeScript (Microsoft)

* Dart (Google)

* Kotlin (JetBrains, with Google too)

* Swift (Apple) (though not sure if it compiles to JS)

Haxe plus OpenFL or HaxeFlixel?

I believe with Haxe you can use OpenFL to get what you're looking for. FWIU, that provides a nice migration path from Flash.

If cross-compilation is important to you, and you like Nim's level of abstraction, you might have a look at Haxe, which can compile to [lots of different targets](https://haxe.org/documentation/introduction/compiler-targets...).

If you want Lua under the hood, but a more industrial-strength language on top, you might have a look at Haxe. It can compile to Lua (among other languages/platforms).

https://haxe.org/manual/target-lua-getting-started.html

Haxe feels much more promising than most alternatives. If I do web stuff again I'll be diving in here. There is some good library support. I am a little concerned by its relative youth, will it last?

Haxe has actually been around since 2005 or so. I'm really liking Haxe as a general-purpose compile-to-just-about-anything language.

Oh, same name as the Xfce image viewer: <https://docs.xfce.org/apps/ristretto/start>

There are many nice modern languages that compile to JavaScript. Personally, I like [Haxe](https://haxe.org/), which compiles to many other target platforms/languages as well.

Here's a [comparison of Haxe and TypeScript](https://blog.onthewings.net/2015/08/05/typescript-vs-haxe/).

Given that GitLab/GitHub/etc (and, often, online package repositories) automatically display markdown files as rendered html, a directory of markdown files is a fine way to document your project. The docs can, at any point, optionally be processed into html that goes into a separate website (lots of folks have written tools for this. My own is [Rippledoc](https://gitlab.com/uvtc/rippledoc)).

Also, if the project is a library or framework with a public interface, you need both API docs generated from source, and prose docs.

I think the one downside of Haxe (which is also is strength) is that it doesn’t only support compiling to C/C++, but to every major language possible (Java, C#, PHP, Javascript), so the language ends up being too complex.

I don't understand --- I would think it's quite the opposite. Implementing too many unique target-language -specific features in Haxe would mean lots more compilation acrobatics to make those features work across every target language, correct?

the main developer is working on Hashlink, which can run Haxe code on a virtual machine but can also transpile it to C for production builds

Yes, very excited about HashLink!

If you're already using JavaScript for the web, I think there's three main options for that domain:

* stick with JS,

* learn a language that's a superset of JS (like TypeScript), or

* learn another language which compiles to JS.

If you're looking for a language that can also replace Python for you, then maybe the 3rd option above is a good bet. Something which has its own VM (or other native target), but which also can be compiled to JS. For example, Haxe, Kotlin, Nim, Go, or Dart.

Nim appears to be quite similar to Haxe, though Haxe compiles to numerous additional targets. Aside from that, and the syntax, what are the main differences between Nim and Haxe?