Rust — Cradle to Mastery

Rust was created by Graydon Hoare at Mozilla Research and reached 1.0 in 2015, aimed squarely at a problem C and C++ never solved: memory safety without a garbage collector. Understanding that goal explains the borrow checker before you ever meet it — it is not an obstacle bolted onto the language, it is the language.

rustup installs and manages the Rust toolchain, and Cargo — Rust's build tool and package manager — is used for nearly everything from the first day. Getting both installed correctly, plus rust-analyzer in your editor, is this lesson's entire job.

Every Rust variable is immutable unless you explicitly write `mut`. This is not a style preference — it is the first piece of a language-wide bias toward making mutation visible, which the borrow checker later builds on.

Rust's integers have explicit widths (i32, u64, and so on) and the compiler will not silently convert between them. Combined with tuples and fixed-size arrays, this lesson covers the building blocks every later type is made from.

if is an expression in Rust, so it can produce a value directly into a let binding — no ternary operator needed. `loop` is an intentional infinite loop that can also return a value via break, which for and while cannot.

Rust guarantees every String and &str is valid UTF-8, which is exactly why `s[0]` does not compile — a byte index could land in the middle of a multi-byte character. This lesson is where Rust's rules first feel stricter than most languages, for a genuine safety reason.

Structs are how Rust models data, in the same role classes play elsewhere but with no inheritance. This lesson covers named-field, tuple, and unit structs, plus the impl block where methods are attached separately from the data.

Rust enums can carry different data per variant — Option<T> and Result<T, E> are both ordinary enums defined this way. `match` forces you to handle every variant, which is how Rust eliminates an entire category of null-reference and unhandled-case bugs at compile time.

Every value in Rust has exactly one owner, and when that owner goes out of scope the value is dropped automatically — no garbage collector, no manual free, no double-free. Borrowing lets code use a value without taking ownership of it, and this single rule is the foundation everything else in this stage builds on.

A reference lets a function read or modify data it does not own, and a slice is a reference to a contiguous run of a collection — a string slice or an array slice — without owning or copying the underlying data.

A lifetime is not a runtime concept — it is the compiler's proof, checked entirely at compile time, that a reference never outlives the data it points to. Most of the time lifetimes are inferred silently; this lesson is about the cases where you must name them explicitly.

The borrow checker is the compiler pass that enforces ownership and borrowing rules, and its errors are usually pointing at a real bug in your reasoning, not an arbitrary restriction. This lesson works through the classic rejected patterns and the idiomatic ways to restructure code so they compile.

Ordinary references cover most cases, but some data needs to live on the heap (Box), be shared by multiple owners (Rc), or be mutated through a shared reference (RefCell). These smart pointer types are how Rust handles the remaining cases ownership alone cannot express.

Generics let one function or struct work over many types, and because Rust monomorphizes generics — generating a specialized copy per concrete type at compile time — there is no runtime overhead at all, unlike generics in many other languages.

A trait defines behavior a type can implement, similar to an interface, and trait bounds let generic code require that behavior at compile time. `dyn Trait` is the other option — trading that compile-time speed for the runtime flexibility of storing different types behind one pointer.

You have now met structs, enums, generics and traits separately. This lesson is the synthesis — seeing how they combine into Rust's actual answer to object-oriented design, without classes or inheritance anywhere in the picture.

Rust's standard collections cover most real programs: Vec<T> for growable lists, HashMap<K, V> for lookups, and HashSet<T> for uniqueness. Each interacts with ownership in a specific way worth seeing before you use them in real code.

A closure can capture variables from its surroundings, and Rust expresses exactly how — by reference, by mutable reference, or by move — through the Fn, FnMut and FnOnce traits. Getting this straight explains a class of closure-related compiler errors.

Iterator chains in Rust compile down to the same machine code as a hand-written loop — a textbook zero-cost abstraction. This lesson covers the Iterator trait itself and the adapters (map, filter, fold) you will reach for constantly in idiomatic Rust.

Result<T, E> replaces exceptions: a function that can fail returns Result instead of throwing. The ? operator then propagates an Err straight out of the current function, turning what would be several lines of error-checking into a single character at the call site.

Rust's marketing calls this "fearless concurrency" for a specific reason: the Send and Sync traits let the compiler reject a data race before the program ever runs, rather than catching it at runtime or not at all. This lesson covers spawning threads, message passing, and shared state.

Rust's async functions return a Future that does nothing until polled — unlike JavaScript's promises, which start running immediately. That laziness is why async Rust needs an executor such as Tokio to actually drive futures to completion.

This lesson is the synthesis for this stage: propagating a Result with ? through a function that also spawns threads and shares state behind Arc<Mutex<T>>, plus the panic/threading interaction — what happens to the rest of a program when one thread panics.

`unsafe` does not turn off the borrow checker; it unlocks exactly five capabilities the compiler cannot otherwise verify, such as dereferencing a raw pointer. Every unsafe block is a promise from you to the compiler, and idiomatic Rust wraps unsafe code in a safe API almost immediately.

Rust's high-level features — iterators, generics, closures — are designed to compile away entirely, so idiomatic Rust routinely matches hand-written C performance. This lesson is about why that promise holds, and the stack/heap model underneath it.

Rust macros run at compile time and can generate code, which is why vec![] can take any number of arguments when ordinary functions cannot. This lesson covers declarative macros (macro_rules!) and gives you enough to recognize derive macros like #[derive(Debug)] for what they are.

Rust items are private to their module by default; you opt in to visibility with `pub`, which is the inverse of many languages' public-by-default habit. This lesson covers the mod/use system and how a project is split across multiple files.

Cargo builds, tests, documents and publishes Rust code, and Cargo.lock gives every build reproducible dependency versions. This lesson covers adding dependencies from crates.io, workspaces, and Cargo's command surface beyond build and run.

Rust's std is deliberately smaller than Go's or Python's, pushing things like async runtimes and random number generation out to crates.io. This lesson maps what actually lives in std, so you know when to reach for it before adding a dependency.

Testing ships with Cargo — no separate framework required for the basics. This lesson covers unit tests in the same file as the code, integration tests in a separate tests/ directory, and the assert! family of macros that make a failing test point straight at the problem.