It’s 2020—the year of hindsight—but I’ve never done anything by the book, so today I’ll be looking forward to 2021 and beyond. Which languages are going to break big as time rolls on? Well, here are my predictions:
Somehow this came out nowhere despite having been visible for years. I’m not sure what combination of trends took Rust from a curiosity to the new hotness, but it has quickly taken over the world. Let’s start with the problems: it’s a complex low-level language like C++, and that means learning it is an absolute pain in the behind. I’ve seen worse (FORTRAN still gives me nightmares), but it’s going to be an uphill battle to get your head around it.
On the other hand, Rust is, well … it’s C++ but designed for a modern environment. It’s C++ that supports safe concurrency. It’s C++ without catastrophic memory leak issues.
It’s not really C++, but you’ll find yourself using it in similar contexts, and having a much smoother and safer time of things. I wouldn’t be surprised if Rust kills C++ entirely as the defacto systems programming language by 2025, because everything C++ can do, Rust can do better.
It’s not hard to see why Golang is popular. Some developers have issues with how opinionated it is, but the fact remains that—via goroutines—it handles concurrency and parallel processing better than almost any other language out there. It’s light, simple and easy to maintain, but doesn’t lack power. It’s not that the critics are totally wrong (its lack of generics still bugs me, implicit interfaces are a lot to wrap your head around, and if you like DRY code you’re going to find yourself screaming at your screen more than once) but it does its job very well and it’s not hard to see why it is slowly becoming more and more popular.
It gets all the usual ticks for language longevity too: lots of money behind it, highly experienced software engineers running it, a large and flourishing community.
You might be noticing a pattern here: the languages that have gotten popular in the last few years tend to be fairly opinionated and have solid linting and other tools for error-checking. It’s pure conjecture on my part, but I think that—as code gets exponentially more complicated—we’re starting to value safe, reliable languages over things that are powerful but error-prone. We’re trading out our rocket cars for reliable family vans, and I suspect that’s the direction tech as a whole is going: the whole “move fast break things” philosophy ended up breaking too many things, and developers seem to be tiring of it.
Kotlin and Swift
Very different languages, but I’m putting them together to make the same point: the mobile revolution happened. It’s not a revolution anymore, it’s just the way things are, and we’re going to be seeing more languages purpose-built for mobile development as time rolls on.
Whether that’ll be Kotlin and Swift remains to be seen. They’re popular languages and I like them both, but I suspect we might start seeing the birth of hybrid languages. Right now we’re just using frameworks like Cordova to bridge the gap, but if I were a betting man I’d put down good money on the emergence of a cross-platform mobile programming language before 2030. Speaking of that:
Dart has been around since 2011, but it was the late 2018 release of Dart 2 that got the attention of most of the developers in my circles—most pre-Dart-2 discussion is overwhelmingly negative, but it has had an absolutely amazing comeback year in 2019 and I think we’re going to be seeing more of it in future. It’s like Go, but for mobile developers; it’s a static typing language developed by Google that’s good at handling concurrency and lets you write lightning-fast.
It’s hard to make long-term predictions in tech, and it’s especially hard this decade—I find it difficult to tell you whether half the countries on earth will exist in five years, let alone Kotlin. Still, there are patterns you can recognise and trajectories you can follow. 2010–2019 was a period of intense boom: it was a party, and we all went wild. The 2020 hangover seems to be already kicking in, and the demand for safer and more reliable languages is on the rise.
Additionally, our industry is fragmenting a lot: the age of the monolith is over, and more and more developers are opting to freelance and work remotely or in coworking spaces. This fragmentation further cements the need for languages and tools that help enhance collaboration, and have less room for error. Our world is changing to be less secure, and we’re adopting safer systems to deal with it.
Whatever happens, I’m curious to see what the future brings.