Chapter 1: Why Rust?

Welcome to Zero-to-Rust! This first chapter explains why Rust has become one of the most loved programming languages in the world, and why learning it—even as your first language—is a powerful choice for your programming journey.

1.1 The Memory Safety Revolution

For decades, systems programming meant choosing between performance and safety. Languages like C and C++ offered incredible speed and low-level control, but came with a dangerous tradeoff: memory bugs. Buffer overflows, use-after-free, null pointer dereferences, and data races have plagued software development since the beginning.

These aren't just annoying bugs—they're responsible for approximately 70% of security vulnerabilities in major software systems. Microsoft, Google, and Mozilla have all published studies confirming this statistic. The cost of these bugs runs into billions of dollars annually in security breaches, data loss, and developer time.

Rust changes this equation entirely. It guarantees memory safety at compile time—not through runtime garbage collection (which adds overhead), but through a unique ownership system that the compiler enforces. If your Rust code compiles, it is memory-safe. Period.

1.2 Performance Without Compromise

Rust compiles to native machine code and runs as fast as C or C++. There's no virtual machine, no interpreter, no runtime overhead. When you need every ounce of performance from your hardware, Rust delivers.

How Fast Is Rust?

This performance profile makes Rust perfect for demanding applications:

• Operating Systems: Linux kernel, Windows components, new OSes like Redox
• Web Browsers: Firefox (Servo engine), parts of Chrome
• Game Engines: Bevy, Amethyst, and game studio tools
• Blockchain: Solana, Polkadot, Near Protocol
• Embedded Systems: IoT devices, microcontrollers
• WebAssembly: High-performance web applications
• Cloud Infrastructure: AWS Firecracker, Cloudflare Workers

1.3 Zero-Cost Abstractions

In many languages, using high-level abstractions (like iterators, generics, or pattern matching) comes with a performance cost. In Rust, these abstractions compile away to the same efficient machine code you would write by hand. This is called "zero-cost abstraction."

let sum: i32 = numbers
    .iter()
    .filter(|x| **x > 0)
    .map(|x| x * 2)
    .sum();

let mut sum = 0;
for x in &numbers {
    if *x > 0 {
        sum += *x * 2;
    }
}

The expressive, readable code on the left produces identical machine code to the manual loop on the right. You don't have to choose between clarity and performance—Rust gives you both.

Examples of Zero-Cost Abstractions

// Generics - no runtime cost
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

// Works with any comparable type
let max_int = largest(&[1, 5, 3, 9, 2]);
let max_char = largest(&['a', 'z', 'm']);

The compiler generates specialized code for each type used—no virtual dispatch, no boxing, no overhead.

1.4 Modern Developer Experience

Rust comes with world-class developer tools that make programming a joy:

The Helpful Compiler

Rust's compiler doesn't just tell you there's an error—it explains exactly what's wrong and often suggests how to fix it:

error[E0382]: borrow of moved value: `s1`
 --> src/main.rs:5:20
  |
2 |     let s1 = String::from("hello");
  |         -- move occurs because `s1` has type `String`
3 |     let s2 = s1;
  |              -- value moved here
4 |
5 |     println!("{}", s1);
  |                    ^^ value borrowed here after move
  |
help: consider cloning the value if you want to use it
  |
3 |     let s2 = s1.clone();
  |                ++++++++

1.5 A Brief History of Rust

1.6 Who Uses Rust?

Rust isn't just for hobbyists—it's used in production by the world's largest technology companies:

1.7 Why Zero-to-Rust?

Many programming tutorials recommend starting with Python or JavaScript, then moving to "harder" languages later. We take a different approach. Here's why:

Rust First: The Advantages

What You'll Learn

This course covers everything you need to go from zero to productive Rust developer:

• Chapter 2: Setting up your development environment and writing your first program
• Chapter 3: Ownership—the heart of Rust's memory safety
• Chapter 4: Borrowing and lifetimes—sharing data safely
• Chapter 5: Structuring code with structs, enums, and modules
• Chapter 6: Advanced features—generics, traits, and smart pointers
• Chapter 7: Fearless concurrency—writing thread-safe code
• Chapter 8: Real projects—building CLI tools and web services

1.8 Chapter Summary

1.9 Review Questions

1.10 Looking Ahead