Intermediate Rust Programming and Advanced Concepts Course

Lesson 1 • Ownership Rules and Move Semantics

Covers single-owner invariant, move vs. copy types, and drop order. Establishes the memory-safety foundation the entire course depends on.

Lesson 2 • Interior Mutability Patterns

Explains Cell, RefCell, and their runtime borrow checking for cases where compile-time rules are too restrictive. Bridges ownership fundamentals to advanced shared-state patterns.

Lesson 3 • Slices, References, and String Types

Distinguishes str, String, and slice types and their reference semantics. Reinforces borrowing concepts through practical string and array manipulation.

Lesson 4 • Borrowing and Reference Rules

Teaches shared and exclusive references, aliasing rules, and borrow-checker feedback. Directly prepares students for lifetime annotations in later sections.

Lesson 1 • Associated Types and Type Families

Distinguishes associated types from generic parameters and shows when each is appropriate. Prepares students to read and write iterator and operator traits correctly.

Lesson 2 • Generic Types and Monomorphization

Covers generic structs, enums, and functions alongside monomorphization cost trade-offs. Provides the vocabulary needed to understand trait bounds and specialization.

Lesson 3 • Trait Objects and Dynamic Dispatch

Explains dyn Trait, vtables, object safety rules, and performance implications. Equips students to choose between static and dynamic dispatch deliberately.

Lesson 4 • Trait Bounds and Where Clauses

Teaches inline bounds, where clauses, and higher-ranked trait bounds for flexible APIs. Directly enables the advanced trait patterns covered in subsequent sections.

Lesson 1 • Panic, Unwinding, and Recovery

Distinguishes recoverable errors from panics, explains unwinding vs. abort, and covers catch_unwind. Completes the error-handling picture with edge-case safety strategies.

Lesson 2 • Error Libraries and Ergonomics

Surveys thiserror for deriving error types and anyhow for application-level errors. Teaches when to use each approach based on library vs. application context.

Lesson 3 • The Question-Mark Operator

Explains how ? desugars, From conversions, and early-return semantics in detail. Enables students to write concise propagation code across multiple error types.

Lesson 4 • Result and Option Combinators

Covers map, and_then, unwrap_or, and related combinators for ergonomic error handling. Establishes idiomatic patterns before introducing the question-mark operator.

Lesson 1 • Iterator Trait and Lazy Evaluation

Implements the Iterator trait from scratch and explains lazy adapter chaining. Demonstrates how zero-cost abstractions eliminate intermediate allocations.

Lesson 2 • Closure Capture and Fn Traits

Explains Fn, FnMut, FnOnce, capture by reference vs. move, and closure sizing. Provides the trait knowledge needed to pass closures across API boundaries.

Lesson 3 • Custom Iterators and Adapters

Builds stateful custom iterators and adapter structs that wrap existing iterators. Reinforces ownership and lifetime skills while extending the iterator ecosystem.

Lesson 4 • Common Iterator Adapters

Covers map, filter, flat_map, zip, enumerate, and take in depth with real examples. Builds fluency with the adapter vocabulary used throughout idiomatic Rust code.

Lesson 1 • Combining Smart Pointers

Demonstrates Rc<RefCell<T>> and Arc<Mutex<T>> for shared mutable state. Connects interior mutability from Chapter 1 to multi-owner scenarios.

Lesson 2 • Implementing Custom Smart Pointers

Builds a custom smart pointer by implementing Deref, DerefMut, and Drop. Deepens understanding of how standard library pointers work under the hood.

Lesson 3 • Memory Layouts and Allocators

Examines struct layout, padding, alignment, and the global allocator interface. Equips students to optimize memory usage and integrate custom allocators.

Lesson 4 • Reference Counting with Rc and Arc

Compares Rc for single-threaded and Arc for multi-threaded shared ownership. Prepares students for concurrent programming by introducing thread-safety constraints.

Lesson 1 • Atomic Operations and Lock-Free Patterns

Explains atomic types, memory ordering, and compare-and-swap for lock-free algorithms. Prepares students to reason about hardware memory models in performance-critical code.

Lesson 2 • Parallel Iterators and Data Parallelism

Introduces data parallelism via parallel iterator patterns and work-stealing schedulers. Connects iterator skills from Chapter 4 to multi-core performance optimization.

Lesson 3 • Message Passing with Channels

Implements producer-consumer patterns using mpsc channels and explains backpressure. Provides a safe alternative to shared state for inter-thread communication.

Lesson 4 • Shared-State Synchronization Primitives

Covers Mutex, RwLock, Condvar, and Barrier for coordinating thread access to shared data. Builds on Arc from Chapter 5 to implement safe concurrent data structures.

Lesson 1 • Async and Await Syntax

Covers async fn, async blocks, .await, and how they compose into larger pipelines. Builds practical fluency before introducing executor and runtime details.

Lesson 2 • Async I/O and Networking

Implements async TCP clients and servers using non-blocking I/O and async streams. Applies executor knowledge to real network programming scenarios.

Lesson 3 • Async Patterns and Pitfalls

Addresses common async mistakes: blocking in async context, cancellation safety, and Send bounds. Equips students to debug and optimize async code in production.

Lesson 4 • Futures and the Future Trait

Explains the Future trait, Poll, Waker, and the state-machine transformation of async functions. Provides the conceptual foundation for all async patterns that follow.

Lesson 1 • The Unsafe Keyword and Superpowers

Defines the five unsafe operations, the unsafe contract, and the principle of minimal unsafe surface. Establishes the mental model for all subsequent unsafe topics.

Lesson 2 • Implementing Unsafe Abstractions

Builds safe abstractions over unsafe code, including a minimal Vec-like buffer. Demonstrates how to encapsulate invariants so callers never need unsafe.

Lesson 3 • Exposing Rust to C and Auditing Unsafe

Exports Rust functions for C consumption and introduces tools for auditing unsafe code. Completes the FFI picture and instills a safety-review discipline.

Lesson 4 • Raw Pointers and Pointer Arithmetic

Covers *const T and *mut T creation, dereferencing, and pointer arithmetic rules. Prepares students for manual memory management and FFI pointer handling.