Mastering Rust

Class Duration

35 hours of live training delivered over 5-10 days to accommodate your scheduling needs.

Student Prerequisites

• Professional software development experience
• Comfort with the command line and a strong interest in systems programming
• Prior Rust exposure is helpful but not required; the course starts with foundations and ramps quickly

Target Audience

Engineers who want production fluency in Rust on the 2024 edition: writing libraries and services other people depend on, navigating async and concurrency, integrating with C through FFI, building procedural macros, and using AI coding tools effectively without letting them write unsafe or unwrap you wouldn't ship. This course assumes the fundamentals from Rust Essentials.

Training Materials

All students receive comprehensive courseware covering all topics in the course. Courseware is distributed via GitHub in the form of documentation and extensive code samples.

Software Requirements

A free GitHub account, the latest stable Rust toolchain installed via rustup (Rust 1.96+ on the 2024 edition), Visual Studio Code or another supported editor with the rust-analyzer extension, Docker for the FFI lab, and an AI coding assistant of choice (GitHub Copilot, Cursor, or Claude Code). A cloud-based environment can be provided if local installation is restricted.

Modern Rust and the 2024 Edition

• Why Rust, why now: the 2026 state of the language
• Rust 2024 edition highlights: let-chains, async closures, RPIT capture rules, naked functions
• Compiler and toolchain improvements: LLD default linker, native workspace publishing, faster sorts
• Editions, MSRV, and managing toolchains with rustup

Toolchain and Editor Setup

• cargo, rustc, rustfmt, and clippy in depth
• VS Code, JetBrains RustRover, and Zed with rust-analyzer
• Debugging with CodeLLDB and dbg!-driven workflows
• AI assistants for Rust: Copilot, Cursor, and Claude Code
• A senior engineer's daily Rust loop

Cargo and Crates

• Cargo.toml features, profiles, and target-specific dependencies
• Workspaces and cargo publish --workspace
• Build scripts (build.rs) and code generation
• Reproducible builds and dependency hygiene

Types, Ownership, and Lifetimes

• Move, copy, and clone semantics
• Borrowing rules and the borrow checker as a productivity tool
• Lifetime elision and explicit lifetime annotations
• Higher-ranked trait bounds and for<'a> lifetimes
• Common ownership patterns and how to read borrow-checker errors fluently

Idiomatic Error Handling

• Result<T, E> and the ? operator
• Designing error enums with thiserror
• Application-level error contexts with anyhow
• When to panic and when not to

Strings, Collections, and Iterators

• String vs. &str and slice semantics
• Vec, HashMap, HashSet, and BTreeMap/BTreeSet
• Iterator combinators: map, filter, fold, try_fold, zip, chain
• Custom iterators and the Iterator trait

Pattern Matching, In Depth

• match, if let, while let, and 2024 let-chains
• Destructuring nested data
• Guards, bindings, and @ patterns
• Refutable vs. irrefutable patterns

Traits and Generics

• Defining and implementing traits
• Default methods, supertraits, and trait objects
• impl Trait and return-position impl Trait in traits
• Bounds, where clauses, and associated types
• Static dispatch via monomorphization vs. dynamic dispatch with dyn Trait
• Designing trait hierarchies that age well

Async and Concurrency

• The async/await mental model
• async fn in traits and return-position impl Trait in traits
• 2024-edition async closures
• Tokio runtime fundamentals: tasks, executors, and the multi-threaded scheduler
• Structured concurrency with tokio::select!, JoinSet, and cancellation
• Streams and futures::Stream

Concurrent Programming

• Send, Sync, and the data race story
• Threads, Arc, Mutex, and RwLock
• Message passing with channels (std::sync::mpsc, crossbeam, tokio)
• Atomics and memory ordering at the level needed to read code
• When to reach for parallelism (rayon) vs. async

Unsafe Rust

• The unsafe superpowers and what they actually mean
• Raw pointers and dereferencing
• Calling unsafe functions and writing safe abstractions
• Auditing unsafe blocks: invariants, comments, and tests
• Reviewing AI-generated unsafe before accepting it

Foreign Function Interface

• extern "C" and ABI considerations
• Calling C from Rust and exposing Rust to C
• CString, CStr, and string ownership across the boundary
• Tooling: bindgen, cbindgen, and the libc crate
• Binding a small C library and shipping a safe Rust wrapper

Macros and Metaprogramming

• Declarative macros with macro_rules!
• Fragment specifiers, repetition, and hygiene
• Procedural macros: derive, attribute, and function-like
• Working with syn, quote, and proc-macro2
• Writing a custom derive macro end-to-end

Testing, Documentation, and Quality

• Unit tests, integration tests, and doctests
• Property-based testing with proptest
• Benchmarks with criterion
• Documentation with rustdoc and writing examples that compile
• Coverage and cargo-llvm-cov

AI-Assisted and Agentic Rust Development

• The 2026 AI-coding landscape for Rust: Copilot, Cursor, Claude Code, Codex
• Letting the compiler, clippy, and tests be the source of truth
• Prompts that work well for Rust ownership, lifetimes, and trait design
• Reviewing AI-generated unsafe, unwrap, and unbounded allocations
• An MCP-tool / custom-tool perspective on Rust workflows
• Cargo + AI: agent-driven refactors, AI-assisted code review, and CI integration
• Honest measurement: when AI helps a Rust team and when it doesn't