This article is more than 1 year old

Rust is eating into our systems, and it's a good thing

Language wars, huh, what are they good for?

Opinion Rust is eating into our systems. The first Rusted drivers are being welded into Linux, while Microsoft's Azure CTO Mark Russinovich said C/C++ – until now, the systems languages of choice – should be dropped in favor of Rust henceforth. 

This is not universally applauded. No change in ecosystem ever is, and language wars have been a part of the tech landscape ever since there was more than one. This time, it's different: the stakes are far higher. 

C++ first appeared in commercial form in 1985, the year the Nintendo Entertainment System hit the US. A generation of systems programmers have gone from hip young codeslingers to senior management, and they can say truthfully that the fundamental underpinning of IT has been successfully built in the older way. Everything Rust can do, the current C++ can do too; it's even insulting to suggest that programmers  need the extra help. 

Yes, you can build new things out of old ideas. Many are useful enough to earn that persistence on merit. That's why any sufficiently old system contains fossils of the past. The legal and medical professions are replete  with Latin terminology, while religion can go back well into the Iron Age. Amen to that.

But as religion so ably attests, sooner or later the language of the past cannot fully support the needs of the now. People still have fun creating Latin terms for "internet router"' (ductor interretus, since you ask), but Christianity has largely recompiled itself for better compatibility with the present day.  

The sea change that breaks the C/C++ compatibility with the real world is the ubiquity of heterogeneous distributed computing. Everyone's mixing it up everywhere. Do an audit not of your own daily compute, but of the computing of your elderly mother or school-age niece. How many tasks are running on how many OS instances, and where does the code come from? All of them are in shared environments, relying on some low-level magic to sandbox or partition or isolate. 

A mistake that would have led to a bug fix in the next point release back in NES days can now impact millions of people's privacy at once, or leave a ransomware-sized hole in a nation's health system. Global consequences flow from what you type into your IDE, and fast.  Rust knows all about this, C/C++ expects you to do it yourself, more or less.  

"But we can do it ourselves," say some hardcore kernel kings. "Look, some of this has been going 30 years without a problem." Indeed. But because an expert surgeon can whip out a spleen safely doesn't mean you can sell scalpels on eBay  with "Instant Appendectomy" instruction leaflets. Rust reduces risk without compromising performance, which means more people can write better code faster. Who doesn't ache for this? 

No, Rust isn't magic. But it understands how data is vulnerable to programming oversights in a modern environment and it knows how to enforce safety at compile time in a way that doesn't damage performance. That's where you want to start by default, not a place to end up by skill. 

Successful languages react to the needs and set the direction of the times that produce them. C grew up with the minicomputer and bridged to the 8-bit micro, environments where efficiency and portability were all.  C++ addressed the rise in scope of software as personal computers became powerful enough to run complex tasks on complex data; it stabilized at the beginning of the 1990s. Rust came to adulthood in the mid 2010s – designed for security, reliability and concurrency, the leading issues of the distributed age. 

Transitions are never easy. Open source depends on large pools of skilled creators to build, and skilled eyeballs to check and fix code, and those pools of system-level skills in C/C++ is far bigger than for Rust. Yet a really good systems engineer, and they all should be really good, thinks in form and abstraction, much of which is common across programming languages. Much depends on culture and ego, rather than technical proficiency. No coding course teaches humility in the face of a good idea, but it's the great secret to making things better over time.

We are privileged to be a part of this. Since the 1970s, information technology has gone from a remote concept of interest mainly to banks, spies, and scientists, to a shimmering mirror world woven into everyone's lives. All this has taken place with only two generations of systems language. It's like having just two types of spanner between Kitty Hawk and Cape Canaveral, and a huge compliment to the Kernighans, Ritchies and Stroustrups who led the way. Few people outside IT can appreciate the commonplace magic of that. 

Rust has all the signs of being the third generation. It builds on what has gone before to solve the problems of now and release the talents of more people to make what comes next. It will be a cultural change as much as a technical one, and as a species we're good at making heavy weather of that. Still, by 2028 it will seem to have been inevitable. Enjoy living through history – and brush up on your Rust. ® 

More about

More about

More about


Send us news

Other stories you might like