Rust Programming Course

Lesson 1 • Rust Syntax and Basic Types

Covers variables, scalar types, and basic expressions. Provides the syntactic vocabulary needed to read and write any Rust program.

Lesson 2 • Installing and Configuring Rust

Set up rustup, cargo, and a code editor for Rust development. Establishes the toolchain foundation every subsequent chapter depends on.

Lesson 3 • Using Cargo and Crates

Explores Cargo commands, project layout, and adding external crates. Connects syntax knowledge to real project workflows used throughout the course.

Lesson 4 • Control Flow Fundamentals

Teaches if, loop, while, and for constructs in Rust. Enables students to write programs with branching and iteration logic.

Lesson 1 • Lifetime Annotations

Teaches explicit lifetime syntax for functions and structs. Enables students to resolve lifetime errors and design APIs with borrowed data.

Lesson 2 • References and Borrowing

Introduces shared and mutable references with borrow-checker rules. Students learn to pass data without transferring ownership.

Lesson 3 • Slices and String Types

Covers slice references for arrays and strings, and distinguishes str from String. Bridges ownership concepts to practical string and collection handling.

Lesson 4 • Ownership Patterns in Practice

Applies ownership and borrowing rules to realistic code scenarios. Solidifies understanding by resolving common borrow-checker conflicts.

Lesson 1 • Methods and Associated Functions

Adds behaviour to structs via impl blocks and associated functions. Connects data modelling to object-oriented-style encapsulation in Rust.

Lesson 2 • Enums and Variants

Defines enums with data-carrying variants and introduces Option. Enables modelling of values that can take one of several distinct forms.

Lesson 3 • Pattern Matching with match

Uses match expressions to destructure enums, tuples, and structs. Teaches exhaustive pattern handling central to idiomatic Rust control flow.

Lesson 4 • if let and Advanced Patterns

Introduces concise pattern matching with if let, while let, and nested patterns. Extends pattern skills to everyday conditional and loop scenarios.

Lesson 1 • Panics and Unrecoverable Errors

Explains when Rust panics, how to trigger and catch them, and when to use them. Sets the boundary between panic-worthy and recoverable error scenarios.

Lesson 2 • Custom Error Types

Defines custom error enums and implements the Error trait. Enables libraries and applications to expose meaningful, structured error information.

Lesson 3 • Error Handling Strategies

Compares boxed errors, custom types, and anyhow for application vs. library code. Guides students in choosing the right strategy for each context.

Lesson 4 • The ? Operator and Error Propagation

Uses the ? operator to propagate errors up the call stack concisely. Reduces boilerplate and makes error-handling code readable and idiomatic.

Lesson 1 • Consuming Iterators

Uses collect, fold, sum, and other consumers to produce results from iterators. Completes the iterator pipeline from source through transformation to output.

Lesson 2 • Iterator Trait and Adapters

Explores the Iterator trait, lazy evaluation, and adapter methods. Teaches the functional-style data transformation central to idiomatic Rust.

Lesson 3 • Custom Iterators

Implements the Iterator trait on custom types to produce sequences. Deepens understanding of how Rust's iterator machinery works under the hood.

Lesson 4 • Closures and Capturing Environment

Defines closures, their capture modes, and Fn trait bounds. Enables passing behaviour as values, which iterators and higher-order functions require.

Lesson 1 • Defining and Implementing Traits

Creates traits with required and default methods and implements them on types. Establishes the shared-behaviour mechanism that generics and polymorphism rely on.

Lesson 2 • Advanced Trait Techniques

Covers associated types, operator overloading, and the Newtype pattern. Extends trait knowledge to sophisticated API design scenarios.

Lesson 3 • Trait Objects and Dynamic Dispatch

Uses dyn Trait pointers for runtime polymorphism and explains vtable costs. Teaches when dynamic dispatch is appropriate versus static dispatch.

Lesson 4 • Trait Bounds and Where Clauses

Constrains generic types with trait bounds and where clauses. Allows generic code to call trait methods while keeping signatures readable.

Lesson 1 • Async/Await Fundamentals

Introduces futures, async functions, and the await keyword with a runtime. Prepares students for non-blocking I/O and high-concurrency application patterns.

Lesson 2 • Send and Sync Traits

Explains the Send and Sync marker traits and their role in thread safety. Enables students to reason about which types can cross thread boundaries.

Lesson 3 • Threads and Shared State

Spawns OS threads, shares data with Arc and Mutex, and avoids data races. Demonstrates how ownership rules enforce thread safety at compile time.

Lesson 4 • Async Patterns and Pitfalls

Covers concurrent futures, task spawning, and common async mistakes. Equips students to build correct, efficient async programs in production contexts.

Lesson 1 • Memory Layout and Raw Pointers

Examines how Rust lays out data in memory and introduces raw pointer syntax. Provides the low-level foundation required for unsafe operations.

Lesson 2 • Embedded and No-std Environments

Configures Rust for no_std targets and uses core and alloc crates. Extends Rust skills to microcontrollers and environments without an operating system.

Lesson 3 • Custom Allocators and Memory Management

Implements the Allocator trait and explores arena and pool allocation. Addresses performance-critical scenarios where default allocation is insufficient.

Lesson 4 • Foreign Function Interface

Calls C functions from Rust and exposes Rust functions to C using extern. Enables integration with existing native libraries and system APIs.