A language people keep falling for
You've probably heard programmers raving about Rust. Maybe a coworker switched to it for a side project and won't shut up. Maybe you saw the Stack Overflow survey, where Rust has been "most loved" for nearly a decade running. Maybe you saw a screenshot of a tweet from someone at Microsoft saying about 70% of their security bugs would have been impossible in Rust.
The natural reaction, if you've been writing Python or JavaScript or even C++, is suspicion. New language, big claims, lots of evangelists. Why this one?
The honest answer is that Rust hits a combination of properties that no other mainstream language quite achieves. It's fast like C. It catches bugs at compile time that C and C++ can only catch with extra tools (or never). It has a package manager and module system that don't make you cry. And it does this without a runtime garbage collector, so it works in places where Java or Go won't fit: kernels, embedded chips, browsers, game engines.
This article is for someone who's done a year or two of Python or JavaScript, has heard "Rust" a lot, and wants the actual pitch in plain terms. What is the language? What's special about it? And what's it like to learn?
Where Rust sits in the landscape
Programming languages roughly cluster by how they manage memory.
Languages with a garbage collector (Python, JavaScript, Java, Go, Ruby) handle memory automatically. You allocate things; the runtime occasionally walks your data, finds what's no longer reachable, and frees it. This is convenient. It costs you a runtime, occasional pauses, and some performance overhead. For a web backend or scripting tool, the trade is well worth it.
Languages without a garbage collector (C, C++, Zig) make you handle memory yourself. You write malloc/free or new/delete. This is fast and gives you precise control. It also produces a steady stream of bugs: use-after-free, double-free, buffer overflows, data races. These bugs are responsible for the vast majority of high-severity security holes in deployed software.
Rust is the third path. The compiler enforces a set of rules (the "ownership" and "borrowing" rules) that statically prevent the entire class of memory bugs C and C++ are notorious for. There's no garbage collector. The compiler decides when each value should be freed and inserts the call automatically. The result is C-like performance with strong safety guarantees, paid for by spending more time arguing with the compiler when you're learning.
What "memory safe" actually buys you
A small example. Here's a snippet of C-shaped pseudocode:
char* greet(char* name) {
char buf[64];
sprintf(buf, "Hello, %s", name);
return buf; // returning pointer to local stack memory!
}
In C, this compiles. The function returns a pointer to a stack buffer that gets reused immediately. Your caller reads garbage. Maybe they get lucky and it looks correct. Maybe they get unlucky, and it's an exploitable security hole.
In Rust, the equivalent doesn't compile:
// This function returns a string slice. The lifetime says "tied to my locals."
// The compiler will refuse, because those locals are about to die.
fn greet(name: &str) -> &str {
let buf = format!("Hello, {}", name);
&buf // error: cannot return reference to local variable `buf`
}
The compiler refuses. You either return an owned String (which lives on the heap and is freed automatically when the caller is done with it) or restructure. Either way, you ship code that doesn't have the bug.
Multiply that by every line of code in a real codebase, and you start to see why Microsoft and Google have been very publicly betting on Rust for security-critical work.
What "no garbage collector" actually buys you
Without a GC, Rust runs in places GC languages can't: bare-metal microcontrollers, operating system kernels, the audio thread of a real-time DAW. Memory cleanup is deterministic. Performance is predictable. You can run Rust on a chip with eight kilobytes of RAM if you want, because there's no large runtime to ship.
It also makes Rust attractive for high-performance servers. Tail latency on a Java service can spike when the GC decides to do major work. Rust services don't have that pause. For an ad bidder or a database engine where p99 latency matters, that's the whole game.
A taste of the language
Here's a small program. Read past the syntax; it'll feel familiar from any C-family language.
// A simple struct describing a person.
struct Person {
name: String,
age: u32,
}
impl Person {
// Constructor by convention; not a special keyword.
fn new(name: &str, age: u32) -> Self {
Self { name: name.to_string(), age }
}
// Method. &self means "borrow the person, don't take ownership."
fn greet(&self) -> String {
format!("Hi, I'm {} and I'm {} years old", self.name, self.age)
}
}
fn main() {
let alice = Person::new("Alice", 30);
// We pass alice by reference. After the call, we still own alice.
println!("{}", alice.greet());
// Pattern matching on enums is a daily tool in Rust.
let n: Option<u32> = Some(5);
match n {
Some(x) => println!("got {}", x),
None => println!("nothing"),
}
}
The shape will feel like Python or JavaScript: there are functions, structs, methods. The differences hide in &self (borrow), String::to_string (heap allocation), match (exhaustive pattern matching), and a much stricter type system.
What's in it for you
A short, honest list of why people pick Rust:
Performance. Rust binaries are typically as fast as C. If you've been writing Python and you rewrite a hot path in Rust, expect 10x to 100x speedups, depending on the workload. PyO3 lets you call Rust from Python directly.
Reliability. The compiler catches whole categories of bugs. Once it builds, a non-trivial slice of bugs you'd hit in other languages just don't happen. People say "if it compiles, it works," which is overstating it, but only a little.
Tooling. cargo is the package manager, build system, test runner, doc generator, and benchmarker, all in one binary that comes with the language. Compared to the patchwork of pip, setuptools, tox, pytest, sphinx, this is a quality-of-life upgrade.
Ecosystem. crates.io has high-quality libraries for HTTP servers (axum, actix), serialization (serde), async runtimes (tokio), CLI tools (clap), and almost everything else you'd reach for daily.
Career. Demand for Rust engineers in systems software, databases, cloud infrastructure, blockchain, and some game studios is strong. It's not the volume of JavaScript or Python jobs, but the salaries are typically higher and the projects more interesting if that's your taste.
What's hard about learning it
The honest counter-pitch: Rust has a steeper learning curve than Python or Go. The borrow checker forces you to think about memory in ways high-level languages let you ignore. Lifetime annotations look strange. Async Rust adds another layer of complexity on top.
Most people describe a few weeks of "fighting the compiler" early on, followed by a moment where the rules click and it stops feeling like a fight. From then on, the compiler is a sharp tool that catches bugs you didn't know you had. It's worth the upfront cost. But pretending the cost doesn't exist would be a disservice.
Getting started in five minutes
# Install the toolchain. rustup manages compiler versions and components.
curl --proto '=https' --tlsv1.2 https://sh.rustup.rs -sSf | sh
# Make a new project. cargo creates the directory and a "hello world" main.rs.
cargo new hello
cd hello
# Build and run.
cargo run
That's it. From here, The Rust Programming Language (free online) is the canonical introduction. You'll spend some time on chapters 4 and 10 (ownership and lifetimes); they're the chapters that earn Rust its reputation.