Rust — Introduction

What is Rust?

Rust is a systems programming language created at Mozilla (first stable release 2015). It is designed around one bold goal:

Give you C/C++ level performance AND prevent entire categories of bugs at compile time.

Most languages pick one or the other:

C / C++      → maximum speed, manual memory, crashes & leaks
Python / JS  → safe & easy, but slower + runtime overhead
Java / C#    → middle ground, but garbage collector pauses

Rust         → C-level speed with compile-time safety guarantees

How does it achieve both?

Traditional systems languages let you manage memory manually:

// C — this compiles fine and then explodes at runtime
char *name = malloc(64);
free(name);
printf("%s", name);   // use-after-free 💥 undefined behavior

Rust instead enforces ownership rules while compiling:

fn main() {
    let name = String::from("Ada");
    give_away(name);
    println!("{}", name);   // ❌ COMPILE ERROR — value was moved
}

fn give_away(s: String) {
    println!("given: {}", s);
}

The program never runs — the compiler refuses. The same bug class that becomes a 3 AM pager alert in C simply cannot exist in Rust.

No garbage collector scans memory in the background. Safety comes from rules checked ahead of time.

The famous learning curve — honest version

Rust is harder to learn than most languages because the compiler explains rules other languages hide from you:

Frustration	What it's actually teaching
"value moved here"	who is responsible for freeing data
"cannot borrow as mutable"	who is allowed to change data right now
lifetime errors	how long references remain valid

Every error is a real bug class caught before shipping. After a few weeks these messages start feeling like a very strict senior reviewer who is always right.

Where Rust is used today

• Firefox — core rendering engine components
• Linux kernel — first new language accepted in decades
• AWS / Cloudflare / Microsoft — performance-critical infrastructure
• Discord — rewrote a service from Go, cut latency spikes
• CLI tools — ripgrep, fd, exa are Rust staples of developer setups

Typical domains: operating systems, embedded devices, WebAssembly, blockchain, game engines, high-performance web services.

What Rust looks like

struct User {
    name: String,
    active: bool,
}

fn main() {
    let users = vec![
        User { name: String::from("Ada"), active: true },
        User { name: "Bo".to_string(), active: false },
    ];

    for user in users.iter().filter(|u| u.active) {
        println!("{} is active", user.name);
    }
}

Familiar pieces — structs, methods-ish functions, iterators with filters — plus ! on macros (println!) and the occasional type annotation.

Tooling preview: Cargo

Every Rust install includes Cargo, which handles what other languages need three tools for:

cargo new     → scaffold a project
cargo build   → compile
cargo run     → build + execute
cargo test    → run tests
cargo doc     → generate documentation
cargo publish → ship to crates.io registry

Is Rust right for you?

Great fit if you want: maximum performance, reliability guarantees, systems/embedded work, or to deeply understand how memory really works.

Maybe skip for now if you need: a quick weekend web app (Node/Python ship faster), or you're still learning your very first language (the ownership model assumes comfort with basics).

Mini Practice

1. Skim the Rust homepage — list three companies using it in production.
2. Compare the C use-after-free example with the Rust compile error until you can explain why Rust refuses.
3. Install rustup (next lesson covers it fully).
4. Write down one thing you've built that would benefit from "crash-proof" guarantees.

Next: get started →