Rust Deep Dive Roadmap

Install Rust with rustup (the official toolchain manager) — it manages multiple Rust versions (stable, beta, nightly) and cross-compilation targets. Understand Cargo (Rust's build system and package manager) — cargo new, cargo build, cargo run, cargo test, cargo fmt, cargo clippy (linter), cargo doc. The Cargo.toml is your project manifest — dependencies, features, workspace config. Crates.io is the package registry. Use rust-analyzer for IDE support. Know the difference between bin and lib crates.

Language Rust 3h

Rust is expression-oriented — almost everything returns a value. Learn variable bindings (let x = 5 — immutable by default, let mut for mutable), constants (const MAX: u32 = 100), shadowing (re-binding a name), scalar types (i8..i128, u8..u128, f32/f64, bool, char), compound types (tuples, arrays), if/else as expressions, loop/while/for, ranges (0..10, 0..=10), and match. Understand that Rust has no null — None is explicit through Option<T>. Semicolons matter — expressions with ; are statements, without ; return a value.

Language Rust 6h

Ownership is Rust's killer feature — it enables memory safety without a garbage collector. The three rules: each value has one owner, there can only be one owner at a time, the value is dropped when the owner goes out of scope. Learn moves vs copies (types implementing Copy are copied, others are moved), references (&T) for borrowing without taking ownership, mutable references (&mut T — only one at a time), and slices (&str, &[T]). The borrow checker enforces these rules at compile time. Most beginner frustration is fighting the borrow checker — understand why, not just how.

Language Rust 10h

Structs group related data — named fields, tuple structs, unit structs. Define methods with impl blocks (self, &self, &mut self). Enums are algebraic data types — each variant can hold different data (Option<T>, Result<T, E> are enums). Match is exhaustive pattern matching — must handle every variant, can destructure, can have guards (if x > 0). if let and while let for concise single-pattern matching. The power of Rust enums over C unions or Java enums: they carry data and the compiler forces you to handle all cases.

Language Rust 8h

Rust has no exceptions. Recoverable errors use Result<T, E> — Ok(value) or Err(error). The ? operator propagates errors — if Err, return early from the current function (the function must return Result). Unrecoverable errors use panic! (also triggered by out-of-bounds indexing, unwrap() on None/Err). Define custom error types with thiserror (derive macro for std::error::Error) or use anyhow for application-level error handling (context chaining with .context()). Know when to use which: thiserror for library crates, anyhow for binary crates.

Language Rust 6h

Rust's standard collections live on the heap. Vec<T> — growable array (push, pop, index, iter, retain, sort, dedup). HashMap<K, V> — entry API for conditional insert (entry().or_insert()), iteration in arbitrary order. String vs &str — String is owned heap-allocated UTF-8, &str is a borrowed slice. String methods (split, trim, contains, chars, bytes, parse). VecDeque for efficient front/back operations. HashSet for unique values. BTreeMap for sorted keys. Understand clone() cost and when to use it.

Language Rust 6h

Traits define shared behavior — like interfaces but more powerful. Define traits (trait Summary { fn summarize(&self) -> String; }), implement traits for types (impl Summary for Article), and use trait bounds (fn notify(item: &impl Summary) or fn notify<T: Summary>(item: &T)). Important standard traits: Display, Debug, Clone, Copy, Iterator, From/Into, Default, PartialEq/Eq, Hash. impl Trait in return position for closures. dyn Trait for dynamic dispatch (heap-allocated, runtime). Understand object safety rules for dyn Trait.

Language Rust 8h

Generics let you write code that works for multiple types (fn largest<T: PartialOrd>(list: &[T]) -> T). Structs and enums can be generic (struct Stack<T>). Rust monomorphizes generics at compile time — zero runtime cost. Lifetimes annotate how long references live — the borrow checker uses them to prevent dangling references. Syntax: fn longest<'a>(x: &'a str, y: &'a str) -> &'a str. The compiler can often infer lifetimes (elision rules). Lifetime annotations in structs holding references. 'static lifetime. Don't add lifetimes unless the compiler asks — understand the error first.

Language Rust 10h

Closures capture their environment — Fn (borrows), FnMut (borrows mutably), FnOnce (consumes). They're first-class: pass to functions, return from functions, store in structs. The Iterator trait is central to idiomatic Rust — map, filter, reduce/fold, take, skip, zip, enumerate, chain, collect (into Vec, HashMap, String). Iterators are lazy (no work until consumed). Prefer iterator chains over for loops for their composability. adapt iterators: iter() (borrows), iter_mut() (mut borrows), into_iter() (owns). Use rayon for parallel iterators.

Language Rust 7h

Smart pointers own memory and enforce rules at compile or runtime. Box<T> allocates on the heap (recursive types, large values, trait objects). Rc<T> — reference counting for single-threaded shared ownership (clone increments the count, drop decrements). RefCell<T> — interior mutability (runtime borrow checking, can mutate through shared reference). Arc<T> — atomic reference counting for multi-threaded shared ownership. Mutex<T> — mutual exclusion for safe mutation across threads. Common patterns: Arc<Mutex<T>> for shared mutable state, Rc<RefCell<T>> for single-threaded graphs.

Language Rust 8h

Rust's ownership model makes data races impossible at compile time — this is 'fearless concurrency'. Spawn OS threads with std::thread::spawn (takes an ownership-capturing closure), use thread::join() to await. Communicate via channels — std::sync::mpsc (multi-producer, single-consumer): Sender, Receiver, channel(). Share state with Arc<Mutex<T>>. The Send trait marks types safe to send across threads, Sync marks types safe to share references across threads — the compiler enforces this. Understand deadlocks (still possible) and how to avoid them with lock ordering.

Language Rust 7h

Testing is built into Rust — no external framework needed. Unit tests live in the same file in a #[cfg(test)] module, annotated with #[test]. Integration tests live in a tests/ directory and test the public API. Doc tests are examples in documentation comments (///) that are compiled and run — keep docs correct by example. Use assert!, assert_eq!, assert_ne!, should_panic. The criterion crate for benchmarks (cargo bench). mockall for mocking traits. proptest for property-based testing — generates random inputs to find edge cases.

Language Rust 6h

Rust macros generate code at compile time — they're invoked with a ! (println!, vec!, assert!). Two types: declarative macros (macro_rules! — pattern matching on token trees, great for reducing repetitive code) and procedural macros (operate on the AST — three subtypes: derive macros (#[derive(Debug, Clone, Serialize)] — most common), attribute macros (#[tokio::main], #[test]), and function-like macros (sql!, html!)). Derive macros are used constantly in Rust — serde's #[derive(Serialize, Deserialize)], the-error's #[derive(Error)], and Axum's extractors all use them. Write a simple macro_rules! before diving into proc macros (which require a separate crate). syn and quote are the essential proc macro libraries.

Language Rust 6h

unsafe blocks allow operations the borrow checker can't verify: dereferencing raw pointers (*const T, *mut T), calling unsafe functions, implementing unsafe traits, accessing mutable static variables, and reading union fields. Unsafe is necessary at system boundaries and for performance-critical code. Foreign Function Interface (FFI) calls C code from Rust (extern "C") or exposes Rust to C (pub extern "C" + #[no_mangle]). Use bindgen to auto-generate Rust bindings from C headers. cbindgen to generate C headers from Rust. Encapsulate unsafe in safe abstractions — the public API should always be safe.

Language Rust 6h