Rust Is a Great Language — But It's Not a Religion

Pope Kim Oct 22, 2025

Ten years ago, when no one cared, I was already saying it: "Rust is a great language."

Back then, I had no data to back it up. It was just my gut feeling and experience. Rust was designed in a way that naturally prevents programmers from making common mistakes.

And now, the data proves it. Microsoft, Google, and Android have all confirmed that over half of security vulnerabilities come from memory safety issues. But with Rust, such mistakes are impossible by design. In real-world Rust code, those vulnerabilities have dramatically decreased.

The Fatigue of the Rust Religion

But honestly, I'm getting tired of the way people talk about Rust these days. You hear things like, "Rust will kill every other language," or "C++ is dead."

That's not a technical discussion — that's religion. There's no logic, no data. It's just people with little skill trying to sound relevant by jumping on the "innovation" bandwagon. And ironically, this kind of hype actually hurts Rust's progress.

Why C++ Is Still Alive

People often say Rust will replace C++. So let me ask — why isn't C++ dead yet?

  1. There's simply too much legacy code. Game engines, operating systems, native libraries, embedded systems — decades of C++ code power the world. Rewriting all of that in Rust overnight is impossible.

  2. The tools and ecosystem are incredibly strong. Just look at Visual Studio. Back in the day, even Sony and Nintendo had their own IDEs. But as codebases grew and development efficiency became critical, both ended up supporting Visual Studio. The result? The entire industry moved under the C++ ecosystem. Instead of dying, C++ actually became stronger.

  3. The learning curve and talent pool. Rust enforces strict safety guarantees, but that also means fewer developers can handle it well. Meanwhile, C++ still has a massive developer base and a deeply established presence in both academia and industry. It's not something Rust can replace overnight.

  4. Other languages can adopt Rust's innovations. Memory safety, concurrency models — those can (and will) be borrowed. The "unique innovation" that once defined Rust won't stay exclusive forever.

Safety Alone Won't Make You a Better Developer

Lastly, there's a limit to developers who have only used "safe" languages. If you've never wrestled with a wild language like C and felt its pain firsthand, you might still write weird, unsafe logic even inside a safe language like Rust.

This isn't new. We saw the same thing years ago with Java and C# — managed languages that made developers comfortable, but not necessarily competent.

History Repeats Itself

Remember when Java once declared, "C++ is over! Java will rule the world"?

And what happened? C++ is still alive and well, while Java is now worried about losing its market share. Rust could fall into the same trap if it's not careful. Rust is a great language, but turning it into a religion will destroy it.

Conclusion: A Language Is Just a Tool

When evaluating a language, you must separate objectivity from subjectivity. Objectivity is about whether the language actually reduces human error — and whether that's proven by data. By that measure, Rust is an excellent language.

But saying "I like using it" is purely subjective. And once you start presenting that as objective truth, technology disappears and religion takes its place.

Programming languages are not religions. They are tools. And tools should always be used according to data and reality.