Read Rust. Then argue about it.

How this course works, why it is deliberately uncomfortable, and the frame that holds everything else together.

• 0.1Why you will feel stupid, and why that is the plan25mThis course is deliberately uncomfortable. Here is the evidence behind that choice, and the five rules that make it work.
• 0.2The three machines40mRust does not have one execution model, it has three. Almost every moment of confusion is running the wrong one — plus a pretest you are meant to fail.

What a Rust program actually does to memory. Places, moves, layout, fat pointers, and the exact moment a value dies.

• 1.1Values, places, and bindingsthreshold45mThe unlearning that everything else depends on. A Rust variable is not a label pointing at a value — it is a place that owns one.
• 1.2Stack, heap, and fat pointers40mSix ways to hold some bytes, and why three of them are two words wide. Once you see fat pointers you cannot unsee them.
• 1.3The four verbs: move, Copy, Clone, Drop40mEverything that can happen to a value when it changes hands. Three of these are free; the one people fear is the one they reach for most.
• 1.4Where values die40mDrop order, temporaries, and the two-line deadlock that catches every Rust programmer exactly once. This is the lesson that makes you sound experienced.
• 1.5Reading a stack frame45mAll of Part 1 applied to one real function, line by line — then a mixed set that refuses to tell you which idea it is testing.

Three threshold concepts live here, so this part is deliberately oversized. Expect to feel stuck. That is the mechanism.

• 2.1Aliasing XOR mutabilitythreshold45mRust has one rule about references. Everything the borrow checker ever says to you is a consequence of it — including the parts that feel unfair.
• 2.2`&mut` does not mean mutable35mThe keyword is misnamed, and the misnaming costs people months. Read it as "exclusive" and a whole category of confusion disappears.
• 2.3Lifetimes are regions of code, not durations of timethreshold60mThe single most damaging misconception in Rust. A lifetime is not how long a value lives — it is a set of places in your program, and it is inferred, not chosen.
• 2.4Reading lifetime annotations50mThe practical half. Elision rules, the anonymous lifetime, the two meanings of `static`, and enough variance to follow the conversation.
• 2.5The borrow checker's errors are the curriculum45mNine error codes cover almost everything the borrow checker will ever say to you. Each one reveals a specific piece of the model.
• 2.6The escape hatches50mOwnership is a tree. Your data might be a graph. Interior mutability does not break the rule — it moves the check from compile time to run time, and you pay for it.

The trait system is a second programming language that runs before yours does. This is where reading Rust is won.

• 3.1Enums are TypeScript discriminated unions, done right40mYour strongest advantage in this entire course. You already think in sum types — Rust just enforces what TypeScript asks you to remember.
• 3.2Traits are constraints, not typesthreshold45mA trait is not an interface and not a type. It is a predicate about types, and the difference explains coherence, the orphan rule, and why `impl` blocks are separate from `struct` definitions.
• 3.3Dispatch and monomorphisation45mWhere constraints become machine code. This lesson explains Rust build times, binary sizes, and `dyn` — which are all the same fact.
• 3.4Where does this method come from?45mAuto-ref, auto-deref, and coercion happen silently on every method call. This is the single most useful reading skill in Rust, and almost nobody teaches it.
• 3.5`Result`, `?`, and the error ecosystem45mErrors are values, panics are bugs, and the difference is a design decision you will be asked to defend. Plus the `thiserror` vs `anyhow` question, answered.
• 3.6Reading generic signatures in the wild50mThe capstone. A repeatable five-step procedure, applied to real signatures from serde, tokio and axum — the ones that look like noise until they suddenly do not.

Send, Sync, and the biggest trap a JavaScript developer walks into: futures do nothing until something polls them.

• 4.1`Send` and `Sync`40mTwo traits with no methods, derived automatically, that give Rust thread safety without a single new rule. Also: exactly what "fearless concurrency" does and does not promise.
• 4.2Threads, channels, and shared state40mWhat the concurrency primitives actually look like, how they compare to goroutines and `synchronized`, and why scoped threads changed the ergonomics.
• 4.3Futures are inertthreshold55mThe single biggest trap for a JavaScript developer. Calling an async function in Rust does not start anything — and two `.await`s in a row are not concurrent.
• 4.4The async ecosystem and its arguments35mThe live disagreements: runtime lock-in, function colouring, work-stealing versus thread-per-core, and whether you needed async at all.

What unsafe actually turns off (much less than you think), the idiom catalogue, and a guided read of a real crate.

• 5.1`unsafe` does not turn off the borrow checker40mIt unlocks exactly five abilities and disables nothing. The widespread belief that it is an escape hatch from the borrow checker is the fastest way to sound like you have only read about Rust.
• 5.2The idiom catalogue45mFourteen patterns that make up most of the Rust you will ever read. Each one is a beacon: see it, know it, stop decoding it.
• 5.3Reading a real crate60mA repeatable procedure for understanding code you have never seen, built on the one model of program comprehension that actually tells you what to look at.

The vocabulary, the live arguments, and scripts for the conversations a tech lead actually has about Rust.

• 6.1The lexicon and the discourse40mKnowing what dyn-compatible means and being able to say “that trait isn’t dyn-compatible” in a review are different skills. This is the second one.
• 6.2Explaining Rust to your team45mThe last lesson. Scripts for the seven conversations a tech lead actually has about Rust — including the one where the honest answer is no.