Outline updated November 2026
Rust Refresher
Class Duration
14 hours of live training delivered over 2-4 days to accommodate your scheduling needs.
Student Prerequisites
- Professional software development experience
- Some prior Rust programming experience
Target Audience
Software engineers with some Rust experience who struggle with lifetimes, error handling, or data-structure design. New to Rust? Start with Rust Essentials or the longer Mastering Rust. Teams continuing on can move to Memory-Safe Programming with Rust and then Rust Parallel Programming.
Description
Rust Refresher is a hands-on review of Rust for developers who have used it before. It covers ownership, borrowing, lifetimes, data modeling, pattern matching, traits, and generics. It also covers what changed since students last wrote Rust: edition changes, async closures, async fn in traits, and new toolchain defaults. Students also practice using AI assistants alongside rust-analyzer and the compiler.
Learning Outcomes
- Explain ownership, borrowing, and lifetimes precisely.
- Model data with tuples, enums, structs, vectors, and hash maps.
- Decompose data with
match,if let,while let, andletchains. - Write generic code and choose static or dynamic dispatch.
- Apply async fn in traits and async closures where they fit.
- Check AI-generated Rust with the compiler, clippy, and tests.
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. Students practice the topics covered through challenging hands-on lab exercises.
Software Requirements
A free GitHub account, the current stable Rust toolchain via rustup (2024 edition), Visual Studio Code or another supported editor with the rust-analyzer extension, permission to install Rust crates and editor extensions, 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.
Training Topics
What's New Since You Last Wrote Rust
- What the current edition changed
letchains- RPIT lifetime capture rules
- Stricter
unsafesyntax - Features available on every edition
- Async fn in traits
- Async closures
- Naked functions
- Migrating with
cargo fix --edition - LLD by default on x86-64 Linux
cargo publish --workspace- rust-analyzer and AI assistants
Scalar Types and Variables
- Integers, floats, booleans, and characters
- Constants and static values
- Immutability by default
- Mutable bindings with
mut - Variable shadowing
- Scope and block expressions
Memory Management
- Pitfalls of manual memory management
- Overhead of garbage collection
- Rust's ownership model
- Move semantics
- Borrowing and references
- Lifetime annotations
- The borrow checker in practice
Strings and String Slices
- Owned
Stringvs. borrowed&str - Creating and manipulating string slices
- Building and modifying owned strings
- Converting between
Stringand&str - Parsing strings into numeric types
- Trimming, splitting, and joining
- String formatting and interpolation
Tuples
- Tuple fundamentals and use cases
- Storing heterogeneous types
- Indexing and accessing elements
- Destructuring into named bindings
- Unit tuples and empty returns
- Tuples as lightweight data containers
Enums
- Defining enums and variants
- Variants with associated data
- Implementing methods on enums
Option<T>for nullable valuesResult<T, E>for error handling- When to use enums vs. structs
Structs
- Defining named-field structs
- Creating and initializing instances
- Field init shorthand
- Struct update syntax
- Tuple structs for positional data
- Unit-like structs as markers
- Struct ownership and borrowed fields
- Implementing methods with
impl - Associated functions and constructors
Vectors
Vec<T>as a growable array- Creating vectors with
vec!andVec::new() - Pushing, popping, and inserting elements
- Safe access with
get()vs. indexing iter(),iter_mut(), andinto_iter()- Slicing, length, and capacity
- Memory layout and reallocation
- Borrowing vector elements
Pattern Matching
- Pattern matching fundamentals
matchand exhaustiveness- Concise matching with
if let - Looping with
while let - Destructuring structs, tuples, and enums
- Guards and bindings in patterns
- Ownership and borrowing in patterns
- Refutable vs. irrefutable patterns
Generics and Traits
- Generic functions and structs
- Defining and implementing traits
- Trait bounds and
whereclauses - Static dispatch via monomorphization
- Binary size costs of generics
- Trait objects with
dyn Trait - Choosing static or dynamic dispatch
- Async fn in traits
- When to box async trait futures
Async at a Glance
- Async/await and Tokio basics
- Async closures
tokio::select!andJoinSetSend,Sync, and'staticin async code
AI-Assisted Rust Workflow
- rust-analyzer and AI as a feedback loop
- Prompts for ownership and lifetimes
- Reviewing AI-generated
unsafeandunwrap - Reflexive
Arc<Mutex<T>>in AI code - When the compiler overrules the AI