Mastodon Icon GitHub Icon LinkedIn Icon RSS Icon

The most promising languages of 2015 - Part 2

Header image for 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.
Figure 1. 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 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?
Figure 3. 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.


Ok, I give up…
Figure 4. 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.
comments powered by Disqus