The Rust Ownership Model

You have the Course 1 vocabulary — every value has an owner, moves transfer ownership, & borrows without taking it. This lesson is the Intermediate deep-dive on why Rust is built this way at all. You compare the three dominant memory models in production (manual, garbage collection, pervasive reference counting), name the specific failure mode each produces at runtime, see the four memory-safety guarantees Rust's ownership and borrowing rules deliver (no use-after-free, no double-free, no data races in safe code, no null-pointer deref), and finish by reading a short Rust program line-by-line and naming the specific bug each line prevents.

By the end of this lesson you will be able to compare the three memory models and name the failure mode of each, explain how Rust's rules deliver each of the four safety guarantees, evaluate when Rust is the right tool for a given project profile versus when a GC-based language fits better, and trace a short Rust program to say what bug each line prevents.

Go from Course 1's gentle "a moves to b" story to full fluency with Rust's move semantics and the Copy trait. You will see what the compiler actually does on let b = a for each type category, learn which standard-library types are Copy and why, and build the decision rule for picking between Copy, Clone, and borrowing when you design a function parameter. By the end of this lesson you will be able to predict for any let b = a whether the original binding is still valid, name which fields make a struct Copy or not, and pick between pass-by-value, pass-by-reference, and explicit .clone() for any function signature without guessing.

Go beyond Course 1's operational "&self vs &mut self vs self" story and internalize how references really work in Rust. You'll study the shared-borrow / exclusive-borrow rule that the compiler enforces, the data-race prevention guarantee that rule gives you, non-lexical lifetimes (borrows end at last use, not at scope end), reborrowing (how &mut T can be passed into a function and still used after), and borrow splitting across struct fields.

By the end of this lesson you will be able to describe the aliasing rules Rust enforces between &T and &mut T and name the specific class of bugs those rules prevent, trace a non-lexical lifetime through a short program and explain exactly where each borrow ends, and apply reborrowing to pass &mut T into a function and keep working with the parent reference after the call returns.

Read any rustc borrow-checker error output with precision — title line, source span, note blocks, help suggestions — and group the top 8 error codes (E0382, E0384, E0499, E0502, E0505, E0507, E0596, E0597) into three families (move, mutability, lifetime). You walk away able to look at a novel error, extract which safety guarantee is at stake from the shape of the message, and choose a minimal fix. This is the Intermediate skill that turns rustc from an obstacle into the most patient teacher you have.

By the end of this lesson you will be able to identify each region of a rustc error output in a novel message, identify which family a given error belongs to from the code snippet alone, explain the memory-safety guarantee each family prevents, and choose a minimal fix strategy for each family.

Fluency with Rust's slice types — &[T] for sequences and &str for text. A slice is a borrowed window into contiguous data: no ownership, no allocation, just a pointer plus a length that lets a function work with Vec, array, or sub-slice through one signature. You will learn the memory layout a slice compiles to, the handful of methods you reach for daily (.get, .first, .last, iteration, range syntax), and the UTF-8 byte-boundary rules that keep &str slicing safe. You finish by rewriting function signatures from the restrictive &Vec<T> to the idiomatic &[T] and from &String to &str.

By the end of this lesson you will be able to describe a slice as a borrowed view and relate &[T] to its owning Vec<T>, apply &str slicing without triggering char-boundary panics, and evaluate function parameter choices between slice-of-T and reference-to-container.

Lifetimes are the single hardest Intermediate concept in Rust — and the one that most students decide they'll "just add &'a everywhere and hope." This lesson replaces that habit with a precise model. You'll see what 'a actually represents (a region of code, not a duration), apply the three elision rules the compiler uses to infer most lifetimes automatically, pick the right annotation when elision fails, and attach lifetimes to structs that hold references.

By the end of this lesson you will be able to read any Rust fn signature and name the lifetime relationships at play, apply the three elision rules in your head to any signature, identify when 'static is required (and when it's merely convenient), and declare a struct that holds references with the correct lifetime parameters.

Understand Rust's three "ownership on the heap" tools — Box<T> for single-owner heap allocation, Rc<T> for shared single-threaded immutable ownership, and Arc<T> for shared ownership across threads. You learn when to reach for each one, when a plain borrow is enough, and why Arc pays an atomic-op cost that Rc avoids.

By the end of this lesson you will be able to pick the right smart pointer for a given data-sharing pattern, explain why recursive enum types need Box<T>, trace Rc's clone-and-drop ref-count mechanics, and articulate the Send + Sync reason the compiler forces Arc<T> whenever you cross a thread boundary.

Learn when the compile-time borrow checker is too conservative for a correct program, and how Cell, RefCell, and the Rc<RefCell<T>> composition pattern move the same borrow rules from compile time to runtime. You pick the right tool for shared counters, cache-and-memoize patterns, graph structures, and the small handful of situations where Rust's single-mutable-owner rule produces unnecessary friction.

By the end of this lesson you will be able to explain why interior mutability exists in Rust, choose between Cell and RefCell based on whether the inner type is Copy, recognise and avoid the common BorrowMutError runtime panic, apply the Rc<RefCell<T>> pattern for shared mutable state in single-threaded code, and preview where Mutex / RwLock take over for thread-safe equivalents in Course 5.

Prerequisite: Course 2 Lessons 1-7. Follows the current Rust 2024 edition on stable Rust 1.99.