A twelve-episode path from your first cargo new to async Rust. Every episode pairs the video with a companion guide, the exact book chapter, and the Rustlings drills that build the same muscles.
The on-ramp: install & toolchain, cargo new vs init, hello world, a deep look at fn main, variables & mutability, scalar & compound types, functions, comments, and control flow.
The series' “aha” moment: stack vs heap, the three ownership rules, move semantics, Clone vs Copy, references & borrowing, the borrow checker's rules, slices, and a first glimpse of lifetimes.
Model your data: structs (all flavors), impl blocks & methods, &self vs &mut self vs self, enums with data-carrying variants, Option<T> as the answer to null, match exhaustiveness, if let / while let, and a derive teaser.
Vec<T> (push, pop, iterate, capacity), String deeper (bytes vs chars vs graphemes, and why s[0] won't compile), HashMap<K,V> and the entry API, plus common pitfalls like borrow-while-iterating.
panic! vs recoverable errors, a full Result<T, E> walkthrough, the ? operator & propagation, unwrap vs expect (and when each fits), and custom error types with a light thiserror mention. “Errors are values.”
Generic functions, structs & enums, traits as interfaces, default impls, trait bounds, lifetime annotations (the full mechanics promised in Ep02), elision rules, 'static, and a dyn Trait teaser.
Closure syntax & capture modes (move, &, &mut), the Fn / FnMut / FnOnce mental model, iterators as the killer feature, adapter chains (map, filter, collect, fold), laziness, and the performance story.
The module tree (package → crate → module), mod / pub / use & paths, file-based modules, a live single-file refactor, Cargo.toml profiles, workspaces, features, fmt & clippy, and publishing to crates.io.
#[test] & cargo test, the assertion macros, #[should_panic], returning Result from tests, unit tests in mod tests vs integration tests in tests/, and running or ignoring specific tests.
Why smart pointers exist, Box<T> (heap, recursive types, trait objects), Rc<T> (shared ownership), RefCell<T> (interior mutability), Rc<RefCell<T>> for graphs & lists, and a quick Deref & Drop mention.
thread::spawn, move closures & ownership across threads, channels (mpsc) and message passing, shared state with Mutex<T> & Arc<T>, what Send and Sync really mean, and a parallel work example.
The finale: async fn & .await and what they desugar to, Futures and laziness, runtimes & why Tokio, Tokio basics, concurrent tasks, a parallel-HTTP demo, streams, common gotchas, and a Series 2 tease.
Bookmark these once, they apply across the whole series.