Two Languages Back-End Developers Should Take A Close Look At In 2017

2016 has been an exciting year for server-side languages. We’ve seen several newer languages rise to greater prominence, all of which learn from the mistakes of the past and provide tools developers can use to efficiently build reliable applications and services of any complexity. I’d like to take a closer look at two such languages.

If you want to learn a language that will guarantee you a job, these aren’t the languages you’re looking for. For that, you won’t go far wrong with PHP, JavaScript (Node), and Java, but there’s nothing wrong with looking to the future, and I’ve chosen to look at interesting languages that I think are at the beginning of an adoption curve that will accelerate rapidly over the next few years.

Elixir

Functional programming languages have attracted serious attention recently, and none more so than Elixir. Elixir is a dynamically typed functional language based on Erlang’s Beam VM.

Erlang is a wonderful language with an incredibly rich and mature ecosystem. But Erlang’s syntax is not especially friendly, and developers used to object-oriented languages like Java have a doubly difficult task when faced with learning a new paradigm and a prickly syntax.

Elixir is a Ruby-influenced language built on top of Beam, the Erlang runtime. One shouldn’t take the comparison with Ruby too far, Elixir is functional through and through, but the syntax is friendly enough that most developers won’t have much trouble.

Elixir’s ecosystem has many interesting features, but I’d like to focus on two major reasons every back-end developer should give Elixir serious consideration: OTP and Phoenix.

OTP is the Open Telecom Platform, an unfortunate name that can mislead. It really doesn’t have anything to do with Telecoms, except that Ericsson has been running most of its high-availability concurrent telecoms applications on it for many years.

Rather, OTP is a library for building concurrent applications with almost none of the performance and cognitive overhead that concurrency usually implies. Based on the Actor Model, it’s not unusual for OTP applications to spin up hundreds of thousands of Beam processes on moderate hardware, using code not much more complex than the synchronous equivalent. Check out this video to see what I’m talking about.

Phoenix is a web framework built on Elixir and OTP that takes full advantage of OTP’s capabilities. Anyone who has used Ruby on Rails will be able to transition to Phoenix with relative ease.

Rust

Rust is a five-year-old system programming language from Mozilla, which has attracted a lot of attention in 2016. Like Elixir, Rust is designed from the ground-up for building safe concurrent applications, but unlike Elixir, Rust is a multi-paradigm statically typed language without a runtime that bears comparison to C++ and Java, even though the semantics are quite different.

Rust’s type system is directly influenced by Haskell, and allows developers to avoid a significant categories of bugs related to memory management and concurrency. Rust is a memory safe language that’s intended to be used for everything from operating systems to games, and offers equivalent performance to other compiled languages like C++.

Rust is being used to build Servo, Mozilla’s experimental rendering engine, and has an active and friendly community.

Both of these languages are designed for a world where concurrency and fault-tolerance are both essential and problematic. They, in different ways, contribute to solving many of the problems associated with building high-performance distributed applications and making the most of the cloud infrastructure that supports them.