Outline updated November 2026

Intermediate14 hours delivered over 2-4 daysLive, online or on-site

Request this course

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, and let chains.
  • 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
  • let chains
  • RPIT lifetime capture rules
  • Stricter unsafe syntax
  • 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 String vs. borrowed &str
  • Creating and manipulating string slices
  • Building and modifying owned strings
  • Converting between String and &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 values
  • Result<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! and Vec::new()
  • Pushing, popping, and inserting elements
  • Safe access with get() vs. indexing
  • iter(), iter_mut(), and into_iter()
  • Slicing, length, and capacity
  • Memory layout and reallocation
  • Borrowing vector elements

Pattern Matching

  • Pattern matching fundamentals
  • match and 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 where clauses
  • 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! and JoinSet
  • Send, Sync, and 'static in async code

AI-Assisted Rust Workflow

  • rust-analyzer and AI as a feedback loop
  • Prompts for ownership and lifetimes
  • Reviewing AI-generated unsafe and unwrap
  • Reflexive Arc<Mutex<T>> in AI code
  • When the compiler overrules the AI

Private team training

Bring this course to your team

Tell us about your team and we will tailor this outline to your tools, stack, and schedule. Courses can also be combined into a longer program.

  1. Tell us what you needYour tools, stack, team size, and timeline.
  2. We send a proposalA course or program, an outline adjusted to your team, and possible dates.
  3. Your team trains liveOnline or on-site, with courseware for every student.

Prefer to talk? Call +1 434-509-6890 or email help@cloudcontraptions.com.

We reply within 1 business day.

Training partner?