The new era is beginning, and the old era is ending. C and C++ as a lingua franca of systems programming are being displaced by Rust. Many will deny it, many will fight it. But I'm confident it is already happening and is inevitable to continue at accelerating pace.

Before you dismiss it as some rambling of a rando Rust fanboy with a weird last name, look: well known and reputable system software devs are so optimistic about Rust that they are building their startups with Rust as a core theme of the name, as they believe that the computers of the not so distant future will be powered by Rust at the lowest layers, like firmware.

With the recent Python cryptography getting oxidized drama, you might notice that the previous "Rust can't replace C" dismissal tone is changing into "Whoa, everyone, slow down with that Rust thing.

A good example of era changing is the newly born software industry: crypto-assets. It doesn't matter what you think about it, the industry is there, is booming, and is here to stay in one form or another. Disclosure: I am employed in it. Rust has already established itself as a core language of "crypto". Many cryptocurrency node software and other tooling are implemented in Rust, and even Bitcoin - the most conservative of all of the "cryptos" is investing heavily in Rust, with some push towards including Rust in the Bitcoin Core itself.

Many cryptographers (often working in the crypto space) are familiar with and fond of Rust. So the Python's cryptography library being one of the first big contention places is unsurprising.

With the recent announcement of the newly formed Rust Foundation backed by the industry giants, all signs are pointing to where are we heading: a world where C and C++ are considered legacy languages.

The most fundamental reason is economics. It is too costly to keep trying and failing to build reliable things with C and C++. These languages were built for a different era: where software was smaller, simpler, less important, and not as omnipresent. A world in which new CPU architectures were popping out every couple of years. And things weren't network-first, and trillions of dollars were transmitted through the wire every day purely with software. The industry has invested a lot of resources trying to make C and C++ work, with underwhelming results.

Rust has matured and proven itself to fix the biggest problems afflicting system software:

  • security
  • reliability
  • social and technical scalability

all that without compromising on the important economic value: runtime efficiency, which is a core distinction between system and application-level languages.

Money talks, and it is telling everyone that they are going to get outcompeted if they try to build the next thing with C or C++, while the competition will use Rust.

The cost: complexity. Yes, Rust itself is more complex than C. But thanks to that complexity, the software build using it can be simpler and scale better by composing well with other code. And as our applications need to fulfill more modern requirements: cryptographic security, scalability, better parallel processing utilization, network handling, and so on, the complexity of the language itself and its compiler matters less.

I'd like to point out that there are legitimate problems with Rust and I don't want to dismiss them, but my point is - they are dwarfed in terms of their economic value (or cost of fixing them) in comparison to the problems with C and C++. And because of that Rust problems will be eventually fixed, and Rust will be growing and will keep replacing C and C++ at an accelerating pace.

Still, unconvinced? Look... Competent software cryptographers are in a short supply. They always were, but now even more because of the crypto-assets software booming, promising riches to anyone that can understand zk-SNARKs. And as you can see in the Python cryptography drama, they would rather take the slower compilation time and get something reliable done in Rust benefiting 99% of people out there, than have to deal with C, just to support someone's 20-year toaster. And what are you going to do? Fork? Good luck with that.

Do you think Google or Amazon care about running Alpha architecture, which has been dead for 20 years in their datacenter? Linux/Mac/Windows + x86-64/arm64 work? We're good to go.

So, to get to my final point: like every transition, this one will be full of both opportunities and pain. And they key to good outcome in such time is the adaptability.

If you're a software developer that is already or would like to work in systems programming - you should learn Rust. It is waaaaay more pleasant and productive language to learn and work with than C or C++. And while strictly-Rust positions are not yet very common, they will inevitably be becoming more popular as time goes by, and you never know what interesting opportunities await you precisely because you know a trendy and growing language. It sure looks good on the resume. And in the meantime - if you're competent with Rust, you should have an easy time with C and C++. Or ... as easy as actually possible with them.

If you're in the leadership of a software company doing some system programming - you need to start using Rust. Even if just for non-core projects. You can't just "rewrite everything in Rust" on the spot, of course. So getting some collective experience, hiring, and educating developers will take years. But it's an investment. Plus there's a lot of talented and motivated people that would join your company precisely because they could use their most beloved programming language.

If there are technical problems that are preventing you from using Rust: now is the time to prioritize addressing them. Invest in adding Rust support for architectures and tooling you use, work on reproducible/trustless builds, tooling support, and whatever else that you might need. Go talk to your vendors, community, partners, etc. and ask them about Rust support.

... because if you don't the opportunity will miss you and inevitable shift will leave you behind.