Don’t we have enough already? Aren’t the existing tools getting the job done? And then there are those tireless seekers who jump at the opportunity of trying new things and stumbling upon gems. Learning is an end in itself, and they don’t need much convincing to burn away their weekends building a console-based card game in that obscure, new language. No matter which camp you belong to, there is something beyond debate: we all want to spend time on something that will have a bright future. For the people in the legacy camp, their favorite existing language already has tons of momentum and will continue to have a bright future. To them, I must remind them that their now-mature preferred development toolchain was once “kool-aid” that many refused to drink. And so it is today; new technologies are added to solve new problems or to ease the pain of development. If something does this radically enough, chances are it will continue to snatch mindshare and reach the top. When that happens, you don’t want to be left behind. 🙂 And to those who like to run with the shiny stuff, a warning: having fun is essential as a programmer, but we must be careful not to waste our energies aimlessly. Sure, Brainfuck is an incredibly twisted, puzzle-like, fun little language, but you’re unlikely to benefit by pursuing it seriously. You want something that is new, sensible, and has a solid foundation.
How these languages were selected
Language selection is an intimidating job, especially when new languages are being considered for future benefits in employment and satisfaction. Every language author is firmly convinced they’ve built the perfect language possible and solved all the problems there are to answer. How, then, do you cut? For this post, I focused on a few parameters to keep my search within reasonable boundaries.
Release Date
I specifically avoided languages that are very, very new. New, I mean languages less than 5-6 years old as of writing, and especially those that haven’t reached stability (1.0 release, that is). This, unfortunately, rules out some real gems like Crystal, But I do hope to come back to this and write about its success someday. 🙂 For me, 5-12 years is the sweet spot, which is when a language has stabilized, and more refinements are being worked out. Now, of course, there are exceptions to this rule, and these will be considered where applicable.
Strong Community Interest
This one is a no-brainer but often gets ignored when we get excited about something new. Now, for many people, the backing of a large company is enough precedent for success, but it’s not always true. Yes, Apple’s Objective-C and now Swift thrived because these were the only options in a highly controlled ecosystem, but Facebook’s D and Hack (an ugly take on an already ugly language, in my opinion) remain little more than experiments. The ideal combination would be a language backed by a large, stable company and exploding in popularity (like React). But the meat of the matter is still the community. If a language is not creating a buzz, and there are not enough devs to educate and popularize, it’s not going to climb out of its GitHub grave. For me, this rules out mature, fascinating languages like Racket and Erlang, as they’ve remained flat on the growth curve.
Focused, Well-Defined USP
The third thing I’m looking for is a clear-cut goal for the language. For example, a better version of PHP that fixes naming issues and compiles to native PHP doesn’t work for me. The benefits are just too small to justify the cracks if everyone tries to move to it. By this yardstick, I cannot help but dismiss attempts like CoffeeScript, and many other similar compiles-to-JavaScript languages. Honestly, I’m bound to dismiss syntax-only improvements immediately. History has shown that usefulness trumps friendliness when it comes to languages, so if all new languages focus on is a more pleasant experience, I’m afraid it won’t make this list.
Clear, Consistent Syntax
Yes, I know. I just said that syntax doesn’t matter. Well, to be precise, I said that “syntax-only improvements” don’t matter. But that said, syntax remains one of the significant factors in programmer productivity and maintainability, so it’s something that’s bound to feature in my calculations here. Along with syntax comes the idea of consistency. Function naming, module structuring, etc., are key things a language can’t afford to get wrong. It’s 2018, for God’s sake, and another PHP-like language design would be a shame for all of us. So, without further ado, let’s get started with our top five recommendations.
Julia
To the folks at the MIT, the languages available for data science were a compromise at best. Python, for all its clarity and popularity, lacked native constructs for dealing with data objects. Also, being an interpreted language, Python was slow for them (not the libraries, mind you, as they are mostly written in C). But perhaps the biggest turn-off was the clunky concurrency model, and the lack of a parallel computing model, the latter of which is a staple in super-computing. As a result, Julia was born. Julia reached its stable release on 29 September 2018, barely a few days before this article was written (talk about timing!). Here’s what the official website has to say about its capabilities: Syntax-wise, Julia can be seen as a combination of Python and C. Yes, it’s probably the first time a language has aimed at both these qualities and succeeded. To keep matters simple, Julia is blazing fast and doesn’t enforce strict typing. Here are some benchmarks: As you can see, Julia is slightly worse than C but blows Java and Python out of the water. And what sort of eye-candy does Julia offer? Well, here’s the implementation of a function for calculating the hypotenuse of a right triangle: Finally, while most of the Julia ecosystem is heavily tilted towards mathematical work, I believe it has a bright general-purpose future. It’s the first language, to my knowledge, that has first-class support for parallel computing, so it will be no surprise to see it gaining more popularity in the Web and IoT domains.
Rust
If you’ve tried the new Firefox browser releases, you know that finally, after years of working, it’s looking like they might be able to take away some market share from Chrome. If the browser feels light and snappy and renders quickly, it’s all thanks to the language Mozilla specially developed: Rust. To say that Rust has a bright future will be a lie; the language is already a massive success, and if you’ve not heard of it yet, it’s because its area of application is specialized, and its goal scary: replacing C++! Yes, we finally have a language that not only is capable of doing this but is already doing it. For people frustrated with C++’s over-burdened design and memory management challenges, Rust comes as a breath of fresh air. Here’s what a Rust program looks like: Concise and elegant, in my opinion. Rust follows the functional programming approach, which makes your code more composable, and there are no object-oriented hierarchies to wrestle with. So, what gives Rust the courage to go after C++? It’s the new memory model. Rather than relying on the old new()/delete() dance, Rust introduces the idea of Ownership. Rather than allocating and accessing memory directly, Rust variables “borrow” from each other, with strict restrictions placed by the compiler. The overall concept is too complicated to explain in a few words, so feel free to check out the official docs to learn more. The point is, that this results in 100% memory safety without the need of a garbage collector, which is a big deal. Rust has taken the system programming world by storm. It’s already supported on some platforms, powers browsers and rendering engines are quickly replacing C/C++ code on production systems, and is being used to write operating systems. Sure, it’s not everyone’s cup of tea to create another browser or device driver, but Rust is already spreading itself to other domains. We already have several fully functional, ridiculously fast Web frameworks in Rust, and more and more application libraries are being developed. Honestly, if you’re interested in an exciting future, Rust is the perfect language, and now is a perfect time. Rust is a plane that has taken off, but there’s still time to get on board as it heads for the stars! Learn Rust from Dmitri Nesteruk.
Elixir
Among languages that focus on developer happiness, the first place has been permanently reserved for Ruby. It’s a language that reads like poetry and has enough shortcuts to reduce mental friction by order of magnitude. No wonder, then, that the Rails framework continues to dominate full stack development for serious developers and startups. But not everyone was happy with Rails, especially one of its core developers – José Valim. I think the creator himself best explains the genesis of this language in an interview: And behold, Elixir was born! I started using Erlang more and more and, with experience, I noticed that I was missing some constructs available in many other languages, including functional ones. That’s when I decided to create Elixir, as an attempt to bring different constructs and excellent tooling on top of the Erlang VM. Just like Scala improves upon the Java language but targets the same virtual machine underneath (the JVM), Elixir to takes advantage of the decades-old, battle-proven Erlang virtual machine. Now, a discussion on Erlang is beyond the scope of this article, but the minimum you should know is that it’s the telecom industry’s best-kept secret: if our phone networks are much more reliable than our Web-based systems, it’s all thanks to Erlang. In even simpler terms, what it means is this. If you’re building a real-time system like chat, Elixir is much less RAM hungry and stable than Ruby (or PHP, Python, and Java, for that matter). A machine that runs Ruby and maxes out at 10,000 concurrent connections can easily handle 200,000 when using Elixir and still have enough RAM to run 2D games! Syntax-wise, Elixir shamelessly copies Ruby, and its dominant Web framework, Phoenix, shamelessly copies Rails. I’d say that’s a good thing, too, because along with Laravel, Grails, Masonite, etc., we are reaching a point where all languages have Rails-like frameworks which can ease the transition. Some might scoff at the “lack of originality,” but at least I’m not complaining. Finally, Elixir is one of those technologies that are refreshing, pleasant, and damned practical. Several Ruby (and even non-Ruby) shops are moving to Elixir, and big companies like Pinterest are using it in production with extremely satisfying results. Many people think that Node.js was a makeshift attempt at concurrency and would soon be replaced by Elixir. I have to say I agree with them. 🙂
Kotlin
In 2017 I/O, Google unleashed a bomb upon the unsuspecting crowd. The company formally announced Kotlin as the primary language for Android development, sending shock waves through the industry. Now, that Google has been actively looking to replace Java comes as no surprise after being bitten by an Oracle lawsuit; however, the adoption of Kotlin was somewhat unexpected, and there’s still a good chance Google will come out with its virtual machine soon. For the time being, though, Kotlin is enjoying a surge. Kotlin was developed by JetBrains, a company better known for its suite of insanely good code editors. One of them, IntelliJ IDEA, forms the bedrock of the Android Studio. The design goals of Kotlin are safety, conciseness, and 100% interoperability with Java. More than anything else, the Kotlin compiler works extra hard to eliminate any null-pointer exceptions that are so common in the Java world. It also takes down the proverbial Java verbosity quite a bit, which will come as a relief to many. Here’s a wonderful code comparison between Java and Kotlin: The Kotlin code is significantly shorter and has much less cognitive overload to plow through. But let’s get one thing clear: Kotlin is extremely unlikely to replace Java, though it is rapidly becoming a quick favorite. I believe that ten years down the road, small- to medium-sized teams will look no further than Kotlin, while large groups will continue using Java purely because of legacy reasons. That said, Kotlin has an extremely bright future as it does everything that Java does, can merge with Java code without anyone noticing, and is much more pleasant!
TypeScript
God knows I had to restrain myself for this spot! Everything inside me was screaming “Elm! Elm!”, but no matter how revolutionary its ideas are or how divine the syntax, Elm is yet to be seen as a mainstream alternative for front-end work. 🙁 Anyway, let’s move on to what is mainstream: TypeScript. JavaScript is like wild berries: ugly and distasteful, but you have to stomach it if you wish to survive the jungle of front-end development. Many attempts were made at replacing it (and most likely, the new WebAssembly standard will succeed), but what truly caught everyone’s attention was the superset developed by Microsoft. There are excellent chances that you’ve heard of TypeScript: Angular was the first framework to embrace it from version 2 onward, and people were quick to take note. That’s because TypeScript adds some much-needed and fantastic superpowers to the most famous programming language in the world. Yes, it’s finally possible to write native JavaScript code without suffering and cursing one’s birth! Here are the enhancements that TypeScript brings to the table: ✓ Strong typing: Finally, a string is not a number, and a number is not an object, which is not an empty array! ✓ Compile-time type checking: If your code compiles correctly, it is more or less guaranteed to be free from the warts of the JavaScript runtime. ✓ Classes and Modules: Yes, classes are standard in ES6, but they’re included in TypeScript as well, besides a neat module system. ✓ Type inference: For complex types, the type can be figured out easily by the compiler, saving you some headache. ✓ Async/await: The async/await keywords and patterns are fundamental, so no more messing around with Promises and Callbacks! Namespaces, generics, tuples . . . I could go on and on, but it should be sufficient to say that TypeScript converts one of the worst development experiences into one of the best. The impact of TypeScript cannot be denied. It pushed similar attempts like Google’s Dart out of the field (though it’s attempting a comeback through Flutter, a mobile development framework), and opened the eyes of JS developers to the benefits of stronger types. As a result, significant libraries like React, D3, Vue (even jQuery!) now have a TypeScript version, and in the best software shops around the world, all JavaScript code is being written as TypeScript code. TypeScript headers are now available for Node.js as well (honestly, if a node can improve its concurrency story and patch its lousy memory management, it will last forever). You might be surprised to know that the creator of Node.js, after publicly regretting his creation, is working on a new runtime (there’s no official website at this time; just the GitHub repo) that has TypeScript as its primary language. The best news? TypeScript is a small language to learn with considerable benefits in the future. If you’re an intermediate JavaScript developer, you’ll pick up enough TypeScript within two days to port over all your existing code!
Elm
Elm is as quick as its name can be pronounced and is used for front-end applications, graphics, and games. It is a functional programming language created by Evan Czaplicki in 2012. Elm is said to have no runtime exceptions – that’s where it shines. As a statically typed language, the compiler validates all the errors at compile-time (wow!) with friendly messages (the messages are full texts and not weirdly thrown codes). What a sigh of relief for developers (de-buggers)! You’d be able to learn to code in Elm as you keep getting more errors – the compiler tells you what’s wrong and suggests what you should do to correct it! Elm boasts of being speedier than React and more strongly typed than even TypeScript. Elm code is very organized and neat and will make you a better developer. Since Elm is module based, you can easily create reusable components. Elm compiles to JavaScript that you can run on the browser. So, all you need for Elm to work is node and npm, and you can simply get Elm by using the command: You can put the version you want to install, for example, 0.19.1. You can then check if Elm is adequately installed by using the –version command. If you don’t wish to do all the installation and setup yet – just go to their official website and use the online editor to play around. So, let’s play around a little bit, then! If you are not using the online compiler, you will have to install all the dependencies for the program we’ll be writing now (it’s pretty easy, though). Let’s ask a user to type his name inside a text box and print the same on the page with a hello. Here is the initial screen when you build the program: Type a name, and this is what you get on the screen: Although this program might seem overkill for its purpose, as the program complexity increases, you will appreciate how easy it becomes to debug and maintain. You can see a clear separation between the model, view, and controller (update). Similar to how we use HTML tags, we can create forms in Elm using the model div tags. On the ‘on input’ event (i.e., the user enters a text), the program calls’ Change’, and the program prints the user name along with ‘Hello’ using the String.append function.
Pony
Pony is compiled and follows an actor model of computation designed for asynchronous behavior – i.e., highly concurrent applications. Traditional programming languages provide a ‘lock’ feature to handle concurrency, which impacts performance. Pony doesn’t have a lock, thereby avoiding any blocking operations or deadlock scenarios. Each actor is single-threaded. Pony also provides capability-based security, where users must use a ‘reference capability’ to access a particular object, ensuring safe data handling. For example, the capabilities describe what other aliases are denied rather than what they are allowed. Notions like mutability and isolation are based on these capabilities. This ‘deny’ capability feature makes Pony free from the data race. Pony is safe, fast, and accurate and saves development time, making it a good choice for banking and finance applications. Pony ensures type safety for data handling. It doesn’t have any exceptions – only errors need to be handled to compile the code. The main reason for this is that Pony is statically typed. You need to explicitly specify the type (like Java, and unlike Python) of a variable before using it Similar to Java, you can create constructors. Suppose you have an employee class with name and age: Java developers might note that there are subtle differences in the syntax (no curly braces, wow!). There is also a ‘’’ at the end of the class attributes. You can also create functions: Fun to write functions, eh? Now, the main part – of actors and promises. Pony actors have Behaviours – similar to functions – but only asynchronous – they are executed at some time in the near future but not necessarily immediately when called. But they ‘promise’ that the behaviours will be executed for sure. Well, promises can be rejected, too – if the actor cannot fulfill the asynchronous request being sent. You can create a promise: And invoke the actor’s behaviour by passing the promise to be fulfilled (in our case, getting the employee’s name). Do you think this code will compile? Another great feature of Pony is that it is memory safe – no NULL or buffer overruns. Any code that might return null will never compile unless fixed. Well, we haven’t yet told the program what ’employee’ (our actor) is: Unlike any other programming language, Pony allows division by zero, and the result is zero. There are mathematical proofs for all the features in Pony. To write Pony programs, you need to install the Pony compiler. Since Pony is a compiled language, you must compile the program using ‘ponyc’ before running it. Once you install the compiler, try the hello world program.
Vyper
Vyper is a smart contract programming language based on Python. Like Python, it is human-readable, easy to code, and secure. Vyper compiles down to the Ethereum Virtual Machine (EVM) bytecode. EVM identifies the state of Ethereum for each block on the blockchain. To understand why Vyper is special, let’s understand smart contracts. Smart contracts are programs stored in a blockchain that define and execute an agreement between the seller and buyer when the contract requirements are met. These are self-executing automated contracts that do not need human intervention. However, smart contracts are prone to vulnerabilities. For example, smart contracts might be made to release ether to arbitrary addresses or killed by arbitrary addresses, or they may not be able to release ether. These vulnerabilities are usually introduced via the code – unintentionally or intentionally. Vyper eliminates this issue by providing secure code, making it difficult to introduce vulnerable or misleading code. Although Vyper is based on Python, it doesn’t follow many OOP paradigms, like inheritance, overloading, recursion, etc. This avoids code complexity (having multiple files, making it difficult for auditing purposes). Vyper also doesn’t support inline assembly, which means programs cannot perform any actions directly on the EVM, thus avoiding attacks. These features make Vyper quite secure for writing code for smart contracts used in blockchains. To practice writing programs in Vyper, you can use the remix online compiler. You can also install Vyper using docker or pip (if you have Python) by following the instructions on the Vyper documentation page.
R
R is one of the most popular programming languages for data analysis and machine learning. It has APIs for all the complex mathematics, statistics and scientific calculations, machine learning algorithms, and visual representations. R is open source and widely popular for its rich graphical user interface. It has a vibrant and stable community and can easily integrate with other languages like C, C++, etc. We get all the above features through CRAN (Comprehensive R Archive Network), which contains more than 10000 packages for statistics, probability, data analysis, computing, graphics, and many more. To see the magic of R, let’s try a simple program to find the average (mean) of 11 numbers. To find the mean, we take the sum of the numbers and divide it by the total number of values (11 in our case). R has a function called ‘mean’ that does all this calculation for us. The output is: We can plot these using the plot method:
There are many advanced packages, like ggplot2, dplyr, and many more, to display rich graphics in R. We can also view a quick histogram with the above values to see the range where the values fit.
Note that we have given a break of 10; we can change this to any number depending on the divisions we want. The above variable, mynum was a vector that contained a list of numbers. Similar to Python, we create a data frame in R to work with more dimensions. This is most useful for analytics. For example, we can combine multiple vectors, create a data frame, and manipulate the same depending on the number of variables and the type of analysis we need. Let us say we have employee name, skill, and age vectors. We can create a dataframe and display the data together: Another interesting feature of R is the ease of matrix manipulation using arrays. R will blow you away by performing complex matrix calculations with a breeze. All you have to do is create the matrix and give it to the R program.
Conclusion and Disclaimer
Well, we all have different favorites, but the above languages are worth trying as they come with all new features and solve many of the problems left by earlier languages. Elm is great for neater code separation and modular programming. Pony is one of the best for asynchronous programming. While Vyper is quite new in the smart-contract language world, it provides a promising alternative to Solidity. Vyper particularly scores well when it comes to contract definition and error handling. R, on the other hand, is considered one of the best languages for analytics and has a great community already in place. Specific languages are gaining as much popularity as the ones in this article but have not been included in the list for various reasons. Here’s a quick look:
Golang: Already established as a mainstream, if not very popular, language. I do believe at this point, Golang has several competitors that will keep its market share low. Swift: Apple has an iron grip on its ecosystem, and Swift is the only language available there. Earlier, Objective C was the rage, as Swift is now. I consider it cheating and so refuse to include it here. 😀
The future is always uncertain, and one way to go about your career is to stick to what’s already working and refuse to get “distracted.” If you do that, Java, PHP, Python, Ruby, etc., are all excellent languages to stick with. However, for some of us, the norm isn’t enough. They want to go out and explore and bet big on the future. If you fall in the latter camp, one of these five languages should be on the top of your to-do list. Finally, when trying to assess a language, don’t let the effort overwhelm you because it’s not that much. If you already know a few programming languages, you can learn any of these within two months max, spending 5-6 hours a week. Whereas the happiness and monetary returns that can be generated in the future will be several times more. Next, you can check out programming languages to use in data science.
