Rust: Zero to Hero

The systems language behind fast, memory-safe infrastructure — powering tools like ripgrep, the Deno runtime, parts of the Linux kernel, and increasingly cloud-native components. You'll learn Rust's defining idea (ownership), its fearless concurrency, error handling, and how to ship a small static binary. Practical and hands-on. Work top to bottom, or jump to a part.

The journey:

1. Why Rust — safety without a garbage collector
2. Setup with cargo and your first program
3. Ownership and borrowing — the core idea
4. Structs, enums, and pattern matching
5. Error handling with Result and Option
6. Traits, generics, and the ecosystem
7. Concurrency, fearlessly
8. Build a small static binary
9. Production practices

---

Prerequisites

Install with curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh, then confirm: rustc --version and cargo --version. Rust rewards patience — the compiler is strict but teaches you.

---

Part 1 — Why Rust — safety without a garbage collector

Rust's pitch: memory safety without a garbage collector, and data-race safety guaranteed at compile time. It achieves C/C++ performance while eliminating whole classes of bugs (use-after-free, null derefs, buffer overflows, data races) — not by a runtime, but by a compile-time ownership system.

For infrastructure that means: predictable low latency (no GC pauses), tiny static binaries, and confidence that concurrent code is sound. That's why it's showing up in performance-critical CLIs, network proxies, WebAssembly, and systems software.

---

Part 2 — Setup with cargo and your first program

Cargo is Rust's build tool, package manager, and test runner in one.

cargo new hello        # scaffolds a project with git + a hello world
cd hello
cargo run              # compile + run

// src/main.rs
fn main() {
    let name = "Rust";
    println!("Hello from {name}");   // ! means it's a macro
}

cargo new creates Cargo.toml (your manifest + dependencies) and src/main.rs. cargo run builds and runs; cargo build --release produces an optimized binary. Dependencies ("crates") come from crates.io.

---

Part 3 — Ownership and borrowing — the core idea

This is what makes Rust different. Every value has a single owner; when the owner goes out of scope, the value is freed — no GC, no manual free. You borrow references instead of copying:

fn main() {
    let s = String::from("config");
    let len = length(&s);      // borrow s immutably (&)
    println!("{s} is {len} chars");   // s still usable — we only borrowed it
}

fn length(text: &String) -> usize {
    text.len()
}                              // the borrow ends here; nothing is freed

The rules the compiler enforces: one owner at a time; you can have many immutable borrows (&) OR one mutable borrow (&mut), never both at once. This prevents data races and dangling pointers at compile time. Fighting the "borrow checker" is the Rust learning curve — but once it clicks, whole bug categories vanish.

---

Part 4 — Structs, enums, and pattern matching

Model data with structs and enums (far more powerful than in most languages), then destructure with match:

struct Server { name: String, port: u16 }

enum Health {
    Up,
    Degraded(String),   // enums can carry data
    Down,
}

fn describe(h: &Health) -> String {
    match h {                          // exhaustive — must cover every case
        Health::Up => "healthy".to_string(),
        Health::Degraded(reason) => format!("degraded: {reason}"),
        Health::Down => "down".to_string(),
    }
}

match is exhaustive: the compiler forces you to handle every variant, so you can't forget a case. Enums-with-data model states precisely (this is how Option and Result work, next).

---

Part 5 — Error handling with Result and Option

Rust has no null and no exceptions. Absence is Option<T> (Some/None); fallible operations return Result<T, E> (Ok/Err):

use std::fs;

fn read_config(path: &str) -> Result<String, std::io::Error> {
    let contents = fs::read_to_string(path)?;   // ? returns early on Err
    Ok(contents)
}

fn main() {
    match read_config("app.toml") {
        Ok(text) => println!("{} bytes", text.len()),
        Err(e) => eprintln!("failed: {e}"),
    }
}

The ? operator propagates errors concisely — if the call is an Err, it returns it immediately. Because errors are values in the type signature, you literally cannot forget to handle them. Option does the same for "might be missing," eliminating null-pointer bugs.

---

Part 6 — Traits, generics, and the ecosystem

Traits are Rust's interfaces; generics make code reusable with zero runtime cost:

trait Check {
    fn check(&self) -> bool;
}

impl Check for Server {
    fn check(&self) -> bool { self.port > 0 }
}

// Generic over anything that implements Check
fn all_healthy<T: Check>(items: &[T]) -> bool {
    items.iter().all(|i| i.check())
}

Add dependencies with cargo and lean on the ecosystem: serde for JSON/YAML, tokio for async, clap for CLIs, reqwest for HTTP, anyhow/thiserror for ergonomic errors.

cargo add serde_json clap reqwest

---

Part 7 — Concurrency, fearlessly

The ownership rules that prevent memory bugs also prevent data races — the compiler rejects code that shares mutable state unsafely. For async network work, tokio is the standard runtime:

use std::thread;

fn main() {
    let handles: Vec<_> = (0..4).map(|i| {
        thread::spawn(move || {         // move ownership into the thread
            println!("worker {i}");
        })
    }).collect();

    for h in handles { h.join().unwrap(); }   // wait for all
}

Because the borrow checker enforces that shared data is either immutable or exclusively owned, concurrency bugs that plague other languages simply don't compile. For high-concurrency I/O, async/await on tokio scales to many thousands of tasks.

---

Part 8 — Build a small static binary

Rust binaries are self-contained and fast. Build an optimized release, then ship it in a minimal image:

cargo build --release        # target/release/<name>, optimized

# ---- build ----
FROM rust:1.79 AS build
WORKDIR /src
COPY . .
RUN cargo build --release

# ---- runtime (tiny) ----
FROM gcr.io/distroless/cc
COPY --from=build /src/target/release/app /app
USER nonroot:nonroot
ENTRYPOINT ["/app"]

For a fully static binary (runs in scratch), target musl: rustup target add x86_64-unknown-linux-musl then cargo build --release --target x86_64-unknown-linux-musl. The result is a small, dependency-free container — like Go, but with even tighter control.

---

Part 9 — Production practices

• Let the compiler help — heed its errors; they prevent real bugs. Warnings-as-errors in CI (-D warnings).
• Result + ? everywhere; use anyhow for apps, thiserror for libraries.
• cargo clippy (the linter) and cargo fmt in CI — clippy catches idiom and correctness issues.
• cargo test — tests live alongside code; run them in CI.
• --release builds for anything shipped (debug builds are much slower).
• Static (musl) or distroless images, run as non-root.
• Pin dependencies with the committed Cargo.lock (for binaries).
• Prefer safe Rust; isolate any unsafe and document why.

---

Common mistakes to avoid

• Fighting the borrow checker instead of listening. Its errors point at real aliasing/lifetime issues — restructure rather than clone() everything.
• .unwrap() in production paths. It panics on Err/None. Handle with match/? and reserve unwrap for tests/prototypes.
• clone() to silence the compiler. Sometimes right, often a sign you should borrow — understand why first.
• Shipping debug builds. Use --release; debug is far slower.
• Reaching for unsafe early. You rarely need it; it opts out of the guarantees that make Rust worth it.
• Skipping clippy. It teaches idiomatic Rust and catches subtle bugs.
• Dynamic-link surprises in containers. Target musl or use distroless/cc.

---

Practice: try it yourself

1. First project. cargo new, edit, cargo run, then cargo build --release and run the optimized binary.
2. Borrow it. Write a function that borrows a &str and returns a computed value; confirm the caller can still use the original.
3. Model states. Define a Health enum with a data-carrying variant and a match that handles every case.
4. Handle errors. Write a function returning Result, use ? to propagate, and handle it with match in main.
5. Small image. Release-build and package into distroless (or musl + scratch); compare the image size.

Self-check:

• What does Rust guarantee at compile time, and how (no GC)?
• State the borrowing rules (many & OR one &mut).
• Why no null and no exceptions — what replaces them?
• Why prefer ?/match over .unwrap() in real code?

---

Where to go next

• Package it — the Docker tutorial for the tiny static images Rust excels at.
• Compare compiled languages — the Go tutorial; Go trades some control for simplicity, Rust trades some simplicity for guarantees.
• Practice with systems/backend interview questions in the question bank.

You now have the loop: cargo → ownership → enums/match → Result → traits → fearless concurrency → static binary. That's Rust for safe, fast infrastructure.