In the mean time you might want to check out Nimrod or D. These are some other languages in a similar space - compiling to native binaries, but with the amenities of modern languages.

Nimrod looks quite interesting. Not so long ago I was discussing with a colleague how much I long for a statically typed Python with macros, sum types, optional garbage collection/ref-counting etc. Nimrod seems pretty close to that ideal programming language.

Thanks for sharing such nice little gem.

Nimord is a fantastic programming language, even tho the community is small it features a lot of interesting concepts and the guy behind it: Araq (Andreas Rumpf) is one of the smartest programmers I ever had the pleasure to chat with. I really wish a big corporate could sponsor a bit it, because unfortunately nowadays seems the way to go mainstream.

These are the exact two languages I want to see prosper.

Most important reason is that I want to keep believing that a (bunch of) genius(es) inventing their perfect language that can be practically and widely used without a big company backing is still a thing

Secondly because these languages have so many great ideas with high quality implementations.

I've been giving D a shot at making my usual learn new language project, making a JRPG styled game. So far it's been looking pretty good while porting an old engine someone wrote for their senior thesis from D1 to D2. The type system is fairly well featured and flexible to the point where lots of bugs while updating code and porting it to the new standard library and language features were caught by the compiler itself. It's at the point now where while it builds I'm having issues with the OpenGL code since there isn't a good binding that supports OpenGL 2.1 the way the engine was originally using it.

https://bitbucket.org/simcop2387/yage

The other side of that is that D has had a long time to percolate and hasn't found the success of Go, and soon Rust. So, we come back to the common startup ailment, which is having an awesome product but it just inexplicably doesn't get traction, while the inferior (depending on perspective) product does.

I know there are pockets of D throughout the industry. I know it's catching on at Facebook (and, because I know Facebook folks, I know what an uphill battle those folks are having too). I just don't hear about D nearly as much as I'd expect to over a decade in.

Nothing against D, mind.

In my opinion the fact that there were two competing standard libraries (Tango and Phobos) certainly brought confusion and needlessly fragmented the community.

IIRC, at the beginning the whole thing was not being developed in the open and the compiler was proprietary (although the front-end became open source at one point).

Those two things (especially the former) pretty much killed it for me.

D finally matured at a time where I was already more interested and invested in the Lisp/ML family of languages, thus I ended up never considering it for a project.

Those were definitely the two things that kept me from really considering it in the past. Both of those have now changed for the better and there's a more active community building up again. I think the facebook use of D has also brought some much needed attention to it to the point where the language itself is starting to accelerate changes to move forward. The DMD reference compiler still has some restrictions on the backend of it I think but because of the frontend being available there's now LDC and GDC that are LLVM and GCC versions of the compiler that do much better at optimizing and are fully open source anyway. It's also seemed to help find bugs in both the language spec and the DMD backend from what i've read on the news groups because they've got three very different implementations of the language now that are all mostly compatible (the DMD version is always a little ahead since the other two are essentially ports of it to LLVM/GCC).

The D front end was just relicensed from GPL to Boost. (The front end is shared by DMD, GDC, and LDC.)

I knew something had changed but was unsure of the details. Thanks for the correction.

In a non-systems environment (i.e. I'm fine with garbage collection and don't need perfect performance), assuming I already know OCaml and Haskell, does Nimrod or D have a lot to offer over those?

I have a few years of experiene with Haskell, and recently started Nimrod. It's an imperative language, so the differences are huge of course. I'm more productive in Nimrod. The syntax is great, similar to Python. Nimrod compiles to C without external dependencies, which makes it easy to deploy and easy to bind C libraries. Nimrod's metaprogramming is definitely worth checking out too.

Please be more explicit and specific. Are you saying that the Nimrod imperative style makes some problems easier to solve (can you give an example?), or does "productive" mean something else? What exactly is the metaprogramming good for?

I have also used Haskell in the past. Been using Nimrod for a couple of years now. I agree with defg: the differences are huge. But the great thing about Nimrod is how flexible it is. That's precisely where metaprogramming comes into play, while some features found in functional programming languages are missing from Nimrod they can be implemented fairly easily using Nimrod's macros. For example I have recently implemented syntax sugar for anonymous functions using macros (http://build.nimrod-lang.org/docs/future.html).

I do however find the imperative style of programming more efficient, when working with Haskell I always felt like I was fighting it. So perhaps Nimrod may not be for you, but it's still definitely worth checking out!

Same here, actually. I used to be a pretty strong proponent of Go until I used it in a mid-size project. Now I'm really hoping Rust can fill the gap, and by all indications it's looking like it will.