Why the Rust Hype?
Why Rust for Non-Programmers
If you are not a programmer, why should you care about Rust?
short answer: it doesn’t matter to you.
If you are a programmer, you should already be aware of the reasons, but if you’re not a programmer and curious, are you just out of luck?
No, for I have an Analogy
Programmers are Carpenters Now
Since we’re in the AI apocalypse right now (March 2026), this title seems engagement adjacent.
For the sake of analogy, think of programming in the following allegorical framing:
- Programming is like wood working: you shape the medium to some purpose (silicon hooked up to things like disks, the network, robots, whatever).
- Programmers are like carpenters, shaping the wood (your, or their, or someone’s computer).
- Programming languages are tools. So Programming languages are like chisels, knives, hammers, band saws, sanders, mills, drill presses etc.
Think of C++ programming like a table saw: Simple, straightforward, efficient, precise, ancient. Table saws are old, think 1770’s old good at what they do, and importantly dangerous. Table saws are one of the most dangerous wood working tools out there, and it’s not only that they can slice through the carpenter and cause more finger-related deaths than most other tools, there’s also Kickback, and the blade itself, and they’re loud and can cause hearing damage.
So don’t use table saws right?
wrong
If you’re making cabinets, joinery, or ripping stock, a table saw is the best tool.
But we can make table saws safer. The most recent popular innovation are saw stops. They apply a safety brake that prevents fingers from getting sliced. This is done by rapidly applying a brake to the saw blade, and dropping the blade into the table safely see this in action if you dare
This also destroys the table saw, but usually* not your finger.
This is a lot like Rust!
The analogy
C++ is like a table saw: it’s old, powerful and well designed, capable of making (any) silicon do what you tell it to. C++’s importance cannot be understated. It’s probably the second most important programming language invented so far (the first is C in my opinion).
But C++ is not perfect. C++ is dangerous, and C++ is old (1985).
One key danger of C++ is the memory leak: for C++ to work on the heap it needs to allocate and deallocate memory. When this happens it will “ask” for memory, and it can literally block out bytes in a RAM stick that belong to a variable. If a programmer doesn’t free that memory, it’s stuck. Now your computer has RAM - whatever allocation you didn’t free memory left. If this accretes to a critical point one of several bad outcomes happens:
- your computer stops working
- your program runs out of memory and crashes
- your program runs out of memory and doesn’t crash… but doesn’t work right.
Which of these is the “worst” depends on context, but any of the 3, can hurt property, people, or assets if hooked up to the wrong thing.
Rust is important because it’s new innovation on a well-known tool. Like the saw stop rust adds a layer of safety in some unique guarantees inherent in the tool. Rust’s memory safe design prevents this type of error. Like a Saw stop, Rust’s design acts as a safety measure to stop a programmer from allowing memory leaks. Like a carpenter with a finger on a board, if Rust sees you making a use-after-free error which would cause a memory leak, it rams the brake into the compiler disallowing the program from existing.
Unlike the saw stop, Rust’s compiler warnings are not catastrophic to the tool, and you can keep using it.
Just like the saw stop, however, it’s possible to bypass these safety measures:
Rust has an unsafe mode, which allows any program to be written. It’s also
important to note that it’s possible to write Rust programs that have errors or
dangerous bugs still.
Why not use Java
Java is memory safe, but doesn’t compile to machine code. For lots of software, this is fine or even doesn’t matter. For some software, this is not acceptable. Think most “realtime” systems, like planes, cars, robots, any embedded (arduino for example), and arguably operating systems.
These applications need a certain level of access to hardware: it’s not worth it to run another program just for memory management. Additionally, java adds garbage collection, which isn’t manually controlled; for real-time applications, this can be a deal-breaker.
If you’re not an embedded developer, and you don’t know if your application is real-time here’s a great heuristic in 2026: it’s not.
So for the set of programs that must be real-time, it’s like a high-precision, high-power, repeatable and well understood process. In woodworking, this is a finely tuned table saw, capable of making thou-level (that’s 25 μm) cuts over and over again. And you won’t lose your fingers!
The only thing that gets more precise than this are hand tools (chisels, hand sanding etc. this is like Assembly and hand-wiring components in my analogy). band saws allow more expressiveness and (typically) less power (like Scripting languages, like Python, Javascript etc.), or a full CNC or Pantorouter (this is like Java, or C# in my analogy). While it’s possible to squeeze micrometer-level precision out of some of these tools sometimes it’s either luck (bandsaw / JavaScript), a lot of extra work on setup (CNC & Pantorouter / Java), or you have to use the hand tools to finish your work (use C, Rust, or other binary code to do the part that’s hard fast).
So if you’re writing yet another SAAS CRM system for some businessman, Java is great. (seriously, why are there so many SASS CRM’s?)
If you’re writing code for a pacemaker, Java might not be great.
If you’re writing code for a car, plane, or CNC machine java is not great.
There are many low-level programming languages, whose key feature is that they have similar “power,” for ease-of-use.
If you’re a low-level programmer, your goal is to shape blocks of wood to do a very specific thing, ideally very quickly, and very efficiently. In contrast, Java is not a low-level programming language: it sits on top of another program (the JVM) which takes java code and runs it.
Just like a table saw, it’s not the best tool for every job: A table saw can’t make curvy cuts in the wood (a chisel and jigsaw can though).
So rewrite everything in rust - it’s better?
Rust is generally a better C++, just like a tablesaw with a sawstop from today is better than the saw from 1985. It’s not because C++ was badly designed, but Rust has the benefit of standing on top of giants (LLVM) and hindsight (seeing how C++ succeeded and failed, seeing where Ada failed).
Rust’s key feature is that it’s memory safe at machine-language speed, and massively expressive. C++ but safe by default.
Importantly, if you’re writing something that operates on human time, Rust isn’t a “better” choice.
Rust is hard (C++ is too, it just allows you to be more bad)
What is AI in my Perfect analogy?
I’m not an AI expert, but from what I can see, it’s like putting a robot in the shop.
AI right now, is either well-designed and can operate a table saw, sander, planer, and some chisels all at once and can convert your speech into whatever you wanted at the end. Especially if that thing is a box, a cabinet or a crate. Sometimes it’s really good at this, especially if you want 2x4’s of a specific length (and that length’s precision is in cm).
But when it goes wrong, it ruins your stock, or makes the wrong block. You can fix it, but then why did you use the automation in the first place? Even then… why are you making 1000 boxes?
What does this mean for Rust? AI can use it, but it’d be better if a human in the shop had to use it and it was there.
In the future, when these machines are reliable (or gone for certain tasks), they’ll be using chisels, or the Platonic ideal of the tool; think lasers rather than metal tools, and for computers it’s direct arcane Assembly or binary rather than an interpreted or compiled language.
What to say to the Rustacean
When you next hear “we should rewrite it in Rust” it’s like they’re saying they want a saw stop table saw.
If your program is written in Python (like a set of prefab blocks that you can assemble) and it’s working great, then you might not need it.
If you need a rewrite, and your Rust programmer is prodigious.. then why not?