Outline updated November 2026

Foundation21 hours delivered over 3-5 daysLive, online or on-site

Request this course

Rust Essentials

Class Duration

21 hours of live training delivered over 3-5 days to accommodate your scheduling needs.

Student Prerequisites

  • Professional software development experience in any modern language
  • Comfort with the command line
  • No prior Rust experience required

Target Audience

Software engineers adding Rust for systems programming, fast services, embedded work, or rewrites of C and C++ code. It also suits developers who use AI coding assistants and want to understand the Rust those tools produce. Python, JavaScript and TypeScript, and C# developers can start with a Rust course built around their language instead. For a longer course, the 35-hour Mastering Rust covers the same ground, then continues to traits, async, concurrency, and unsafe code. Teams continuing on after this course can move to Memory-Safe Programming with Rust.

Description

Rust Essentials is a hands-on introduction to Rust for developers new to the language. It covers ownership, borrowing, lifetimes, types, pattern matching, and error handling. Students set up rust-analyzer, an editor, and an AI coding assistant, then build small programs and library crates with Cargo. The course also shows how to check AI-generated Rust with the compiler and clippy.

Learning Outcomes

  • Write idiomatic Rust using ownership, borrowing, and lifetimes.
  • Build CLI applications and library crates with Cargo.
  • Model data with structs, enums, tuples, and vectors.
  • Write control flow with match, if let, and let chains.
  • Use AI assistants for Rust, with the compiler and clippy as the check.
  • Fix common borrow-checker errors without reaching for Rc, RefCell, or unsafe.

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 current stable Rust toolchain via rustup (2024 edition), Visual Studio Code or another supported editor with the rust-analyzer extension, 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

Introduction to Modern Rust

  • What Rust is and where it fits
  • What the current edition changed
  • Working with the borrow checker
  • The crates.io ecosystem
  • The Rust Playground

Toolchain and Editor Setup

  • Installing Rust with rustup
  • Managing toolchains
  • cargo, rustc, rustfmt, and clippy
  • rust-analyzer in VS Code, RustRover, and Zed
  • Debugging with CodeLLDB
  • AI assistants for Rust

Hello, Cargo

  • Creating a project with cargo new
  • main and println!
  • cargo run and cargo build
  • Release builds
  • Managing dependencies in Cargo.toml
  • Workspaces and cargo publish --workspace

Scalar Types and Variables

  • Integers, floats, booleans, and characters
  • Constants and statics
  • Immutability and mut
  • Shadowing and scope
  • Overflow in debug vs. release

Control Flow

  • Expressions vs. statements
  • if and else
  • loop, break, and labeled loops
  • while and for loops
  • let chains in if and while
  • Block expressions

Functions and Closures

  • Defining and calling functions
  • Parameter and return types
  • Closures and capture modes
  • Function pointers vs. closures
  • Spotting hallucinated signatures from AI

Modules and Crates

  • mod and use
  • The standard library
  • Third-party crates from crates.io
  • Re-exports and visibility

Built-In Macros

  • print!, println!, eprintln!, and format!
  • vec!, dbg!, and assert!
  • include_str! and include_bytes!
  • cfg!, env!, and panic!

Memory Management and Ownership

  • Manual memory management vs. garbage collection
  • Ownership, moves, and copies
  • Borrowing with &T and &mut T
  • Lifetimes and the borrow checker
  • Common ownership patterns

Strings and String Slices

  • String vs. &str
  • UTF-8 and character boundaries
  • Parsing, trimming, splitting, and joining
  • String formatting

Tuples, Enums, and Structs

  • Tuples and tuple structs
  • Enums with data
  • Option<T> and Result<T, E>
  • Structs and methods
  • Associated functions and constructors
  • The newtype pattern

Vectors and Collections

  • Creating and indexing Vec<T>
  • Slicing and iteration
  • iter, iter_mut, and into_iter
  • HashMap and HashSet
  • Borrowing rules for collections

Pattern Matching

  • match and exhaustiveness
  • if let and while let
  • Destructuring structs, tuples, and enums
  • Guards and bindings
  • Refutable vs. irrefutable patterns

Idiomatic Error Handling

  • Result<T, E> and the ? operator
  • Custom error enums
  • Choosing between anyhow and thiserror
  • Avoiding unwrap in library code

AI-Assisted Rust Development

  • rust-analyzer and AI as a feedback loop
  • The compiler and clippy as the check
  • Prompts for ownership and lifetime questions
  • Reviewing AI-generated unsafe and unwrap
  • A CLI feature from prompt to review

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?