Advanced Rust Programming and Real-World Applications Course

Lesson 1 • Borrowing and Reference Rules

Teaches shared and mutable references and the borrow checker's enforcement. Builds the mental model needed to write concurrent and safe APIs.

Lesson 2 • Core Syntax and Primitive Types

Covers scalar types, compound types, expressions, and control flow. Provides the syntactic vocabulary required before ownership concepts are introduced.

Lesson 3 • Ownership Rules and Move Semantics

Explains Rust's ownership rules and how values move between scopes. Directly enables safe memory management without a garbage collector.

Lesson 4 • Lifetimes and Annotation Syntax

Introduces lifetime parameters and how the compiler uses them to validate references. Prepares students for generic APIs and long-lived data structures.

Lesson 1 • Traits and Polymorphism

Defines traits as shared behavior contracts and implements them on custom types. Provides the foundation for generic programming and dynamic dispatch.

Lesson 2 • Standard Library Traits in Depth

Explores Display, Debug, From, Into, Iterator, and related standard traits. Connects custom types to idiomatic Rust ecosystem conventions.

Lesson 3 • Enums and Exhaustive Pattern Matching

Covers enum variants with data payloads and exhaustive match arms. Enables modeling of state machines and error conditions without null pointers.

Lesson 4 • Structs and Associated Methods

Defines named-field, tuple, and unit structs with impl blocks. Establishes the primary building block for domain modeling in Rust.

Lesson 1 • Panics, Unwinding, and Abort

Distinguishes recoverable errors from panics and explains unwinding vs. abort. Guides students in deciding when panic is appropriate versus returning errors.

Lesson 2 • Custom Error Types

Teaches defining domain-specific error enums and implementing the Error trait. Enables precise, machine-readable error reporting in library APIs.

Lesson 3 • Error Handling Crates

Introduces thiserror for library errors and anyhow for application errors. Reduces boilerplate while maintaining structured error information.

Lesson 1 • Custom Iterators and Adapters

Implements Iterator on custom types and builds reusable adapter structs. Deepens understanding of zero-cost abstraction and iterator composition.

Lesson 2 • String and Byte Processing

Covers String, str, byte slices, and Unicode-aware iteration. Prepares students for text parsing and protocol implementation tasks.

Lesson 3 • Standard Collections Overview

Surveys Vec, HashMap, HashSet, BTreeMap, VecDeque, and their trade-offs. Provides the vocabulary for choosing the right collection per use case.

Lesson 4 • Closures and Higher-Order Functions

Covers closure capture modes, Fn traits, and higher-order function patterns. Connects closures to iterator adapters and callback-based APIs.

Lesson 1 • Shared State with Mutex and RwLock

Uses Arc, Mutex, and RwLock to share mutable state across threads. Demonstrates lock acquisition patterns and deadlock avoidance strategies.

Lesson 2 • Rayon and Data Parallelism

Applies the Rayon crate to parallelize iterator pipelines with minimal code changes. Demonstrates work-stealing scheduling and parallel fold patterns.

Lesson 3 • Atomic Operations and Lock-Free Patterns

Covers atomic types, memory ordering, and compare-and-swap operations. Enables high-performance lock-free data structures and counters.

Lesson 4 • Threads and the Send and Sync Traits

Spawns OS threads and explains the Send and Sync marker traits. Establishes the compile-time guarantees that prevent data races.

Lesson 1 • Cancellation, Timeouts, and Error Handling

Implements task cancellation, timeouts, and structured concurrency patterns. Ensures async services degrade gracefully under failure conditions.

Lesson 2 • Tokio Runtime and Task Spawning

Configures the Tokio runtime and spawns concurrent tasks. Connects async fundamentals to a production-ready multi-threaded scheduler.

Lesson 3 • Async I/O and Networking

Uses Tokio's async TCP, UDP, and file I/O APIs for non-blocking operations. Builds the skills needed for network service implementation.

Lesson 4 • Async and Await Fundamentals

Explains futures, the async/await syntax, and the executor model. Provides the conceptual foundation before introducing any specific runtime.

Lesson 1 • Raw Pointers and Manual Memory

Covers raw pointer creation, dereferencing, and manual allocation with the allocator API. Prepares students for custom allocators and embedded targets.

Lesson 2 • Custom Smart Pointers

Implements Deref, Drop, and custom smart pointer types from scratch. Deepens understanding of how Box, Rc, and Arc work internally.

Lesson 3 • Embedded and No-Std Environments

Configures no_std crates, uses core and alloc, and targets bare-metal hardware. Demonstrates Rust's applicability beyond hosted operating systems.

Lesson 4 • Unsafe Rust and Its Invariants

Defines the five unsafe superpowers and the invariants that must be upheld. Establishes the discipline required before writing any unsafe block.

Lesson 1 • Containerization and Deployment

Packages Rust binaries into minimal container images and configures CI pipelines. Delivers a deployable artifact from a production Rust project.

Lesson 2 • Testing Strategies and Test Organization

Covers unit tests, integration tests, doc tests, and property-based testing. Ensures correctness across all layers of a production Rust application.

Lesson 3 • Project Architecture and Workspace Layout

Organizes multi-crate Cargo workspaces, feature flags, and dependency management. Establishes scalable project structure for team-based development.

Lesson 4 • Performance Profiling and Benchmarking

Uses Criterion for micro-benchmarks and perf or flamegraph for profiling. Identifies and eliminates bottlenecks in hot code paths.