Just to be fair, and since you mentioned Julia yourself, it too has the expressivity of macros, the ergonomics of simple syntax and a GC as well as performance (often producing the exact same assembly as hand-optimized C/C++ ran through clang). It also has a full implementation of multiple dispatch, with all of the interesting design implications that follow.

That remark, however, is not to minimize the appeal of Nim, which has other interesting properties as well as native compilation, which is undeniably advantageous in some cases. I hope the tooling matures and the language continues to grow. It certainly deserves a chance.

Why don't you commit now? If you really love it, wouldn't now be the best time to get involved?

> speed (native compilation)

Native compilation is often stated as a speed benefit, and it definitely saves startup costs, but Java is still extraordinarily fast; the JIT is an impressive thing.

I think there are good reasons for native: deterministic runtimes; fast startup times; low memory overhead; and lower runtime costs. Some of those you give up by adding a GC back in though.

Speed isn't necessarily one of the reasons for native.

The biggest advantage of native compilation to me is dependency-free binaries. That is one of the reasons I began using Nim and one of the reasons I avoid JVM languages.

That is the major selling point of Go to me. Is Nim similar in terms of tooling quality?

jvm is an impressive thing but so is gcc and clang and they have time to crunch harder and are not constrained by lack of value types or lack of unsigned ints or lack of explicit SIMD instructions and on and on and on

> Speed isn't necessarily one of the reasons for native.

And how it is!

I don't understand why people consider Java "fast". The JVM may be fast on pure server applications. On clients however it is still unacceptably slow in comparison to native applications. Just consider Eclipse and compare it with Ada's GPS editor, or with native C++ IDE's. The startup time of Clojure applications is also still beyond acceptance for me.

I know a lot of programming languages. Nim is one of the most productive ever. It is like safe programming C with the clean syntax of Python and the nice macro features of Lisp.

I don't think it makes to learn the language before the API has stabilized. But that's just me - I'm not saying it doesn't in general make sense and I could come up with reasons why it does.

JVM's jit is indeed fast enough for my tastes but Java is grotesque. kotlin might be nice (been meaning to play around with it for a while).

I still like D the most because of stability and how many features at your disposal, but Nim is a close second and is looking really good to.