The most promising languages of 2015 – Part 2

UPDATE: There is a new version of this article for 2016!

In the the previous post we have seen what are the general trends of the previous year with regard to the fascinating world of programming languages. To summarize, we can say the there are two strong trends: 1) more functional-inspired elements in programming languages 2) more statically strong typed languages that can be compiled in machine code.

Now, in the current article, I want to list all the languages which have attracted interests in the last years and that represent the implementation of these trends. Obviously, as I said in the previous article, these are not languages on which to bet their careers: these are new trendy languages but the real world does not work on “trends”, but on software, oil, commerce, health care and an hundred of categories in which the actual programming languages are doing great with an huge amount of per-existing codebase.

However, it is nice to explore the “future”, so, let’s take a look.


Gopher, the Go's friendly mascot.
Gopher, the Go’s friendly mascot.

The first step it easy. Go it is not really a new emerging language. Go was announced in late 2009 as an alternative to C. Go was focused on two main aspects: a super-easy way to handle massive concurrency and development tools. Go achieve these two objectives in two simple way: the goroutine, an amazing (and funny!) way to work with multiple threads leaves,  and the full set of default powerful tools such as a formatting helper, an unit test suite, a building and packaging system and so on, that are shipped with the default installation.

Now, many years are passed and Go is stronger than ever. However, not as C substitute, but as a solid languages for web application backends. Yes, a static typed machine compiled languages is attracting more interest than some dynamic scripting languages such as Python, PHP or NodeJS as backend.

Go is a solid language, and it is the more established one in my list. So, adopting Go is not a complete leap of faith. However, in my opinion, there are some drawback, there are no real functional inspired features, there are still no generics or meta-programming features and the syntax is a bit clumsy.

Takeaways: Go is the more established language among the “news”. It is stable (last version 1.4) and production ready. The way to go for the not-braves.


Julia Lang Logo

Julia is a language appeared in 2012. Also this language was born with a clear goal in mind: be the definitive tool for scientific computing and numeric calculation. In simple terms, we can consider Julia the fusion and evolution of the actual “state of the art” in scientific computing: Python (obviously referring to Scipy/Numpy) and Matlab.

Julia is a fully dynamic language (but with type inference and optional type annotations!) focused on high-performance. It simplifies the implementation of parallel computing algorithms and allows direct calling to C and Fortran libraries without glue code.

Personally, my knowledge on Julia is near to zero so I cannot say much more. However, I think it is an interesting language because it tackles a goal and does this very well. If you work with scientific programming and you often use Matlab or Numpy, you really should give Julia a shot. On the other hand, I don’t see this as a general purpose language: it is not its goal, it is not the goal of its community, it is not what the early adopter are doing, so…

Takeaways: Julia is a very interesting language for scientific computing. Not much for any other thing (yet?). However it is still very unstable (version 0.4 in preview), so it is a bit risky.


Why I cannot find a Rust logo bigger than 127px?
Why I cannot find a Rust logo bigger than 127px?

Ok. Rust, the new C competitor sponsored by Mozilla, is simply my way to go. Rust want to be a general purpose language and propose one big selling point: memory safety without garbage collector. This is achieved with complex checks at compile time with ensure that, unless you abuse of the unsafe keyword, you cannot mess up with the memory. But that’s not all! It also include a lot of functional-inspired features such as iterator based loops, map and filters, algebraic data types, pattern matching, the fact that is an expression-based language, and so on and so forth.

There is also another good news: it is just 6 weeks away from being stable. With the release of the 1.0-alpha version, a big part of the language is now stable and it is guaranteed that it doesn’t change overnight.

What are the problems? Well, mostly because it is so young. Some parts of the language are definitely rough, with unclear, sometime verbose syntax. Fortunately, because all this changes can be backward compatibles we can expect that they will be slowly fixed after the first stable release. Another “problem” is the difficulty in understanding the borrowing/ownership/lifetime mechanism that ensure the compile time memory safety. This is no a problem by its own but can scare some of the “newbies” approaching the language and this is something a newborn language doesn’t want.

Moreover, Rust benefits of an already strong community, an amazing package manager (Cargo) and of a general strong hype.

Anyway, this is the language I’m actually supporting so I might be biased. :)

Takeaways: This is the strongest new language in my opinion. Now that is (almost) stable you really have to give it a try.


Nim Logo
Ok, I give up…

This is the smallest entry, but I had to enter it. Nim is an high bet: the language is very young and unstable (version 0.10.2), the community is not so big and it is not clear if it will never survive its early stage. However, it contains an huge amount of interesting features. First it has a pythonic syntax. Second, it is compiled (it compile into C code, that can be then compiled to machine code, of course). Third, amazing support to compile time computation (you have just to use the cons keyword to compute a full function at compile time).  And a lot more. Your really have to look around in the tutorial page to have an idea!

Unfortunately, Nim is garbage collected but the authors promise a big control on when, how and how long the garbage collector is running. Let’s see.

The big problem for Nim is to be so damn young! I keep an eye on it for sure, but I do not bet so much on it, for now. I think in an year we will have some more information on how strong Nim is. For now, Nim is a good candidate but nothing more.

Takeaways: Nim is promising, in the real etymological meaning of the word. For now is too young to be used for anything, but I’ll keep an eye on it.

And now?

We have seen the most promising candidate for the “language of the year” prize. Obviously a new competitor can emerge from the GitHub dungeons at any time, but I think that the four languages I’ve briefly presented to you are the one on which you really have to keep an eye on and/or invest some of your spare time on.

3 Replies to “The most promising languages of 2015 – Part 2”

  1. Just a quick comment on Nim there, it really isn’t that young. The version number is kept low, but that is not reflecting the maturity nor age of the language. Also, yes, Nim is garbage collected and others may know more details but it should be mentioned that you can also use Nim without the garbage collector. Sure, a big part of the standard libraries depend on the GC, but its still an option.

    1. Thank you for your comment! Yes, I know that Nim is in development by a long time, it is technically even older than Rust! (2008 vs 2010). However when I say that a language is “young” I mean respect to the time it has got the “right amount of momentum” to not die. Maye I am wrong, but among the languages I’ve shown Nim has the smallest community and I started to see it taken seriously only a couple of years ago. Other than that I really encourage people to try it! :)

      About the GC. Well, I’ve read about that but I’m not fully convinced. I mean, it is just like saying “I can start my car without wheels but it doesn’t move”. De facto, Nim GC cannot be removed unless someone want to write their own GC-less standard library. It is possible but I find this case a bit… “extreme”. Let’s see how this will evolve. :)

      1. I agree, community is not that large, but not tiny either. Andreas now works with us at 3DICC and he works in and also on Nim, full time. We are writing our next version of our product partly in Nim. Further, on the GC, I agree – but as I said, its at least still an option. The GC implementation itself is also pluggable. And… there is also cool new work in the pipeline, but for more on that I suggest joining on #IRC. :)

Comments are closed.