Rust Application Development Course

Lesson 1 • Compound Types and Collections

Introduces tuples, arrays, structs, and enums as data containers. Prepares students to model real-world data before ownership is introduced.

Lesson 2 • Installing and Configuring the Toolchain

Set up Rust via rustup, manage toolchain versions, and configure editors. Establishes the development baseline required for all subsequent work.

Lesson 3 • Cargo and the Module System

Explains Cargo commands, Cargo.toml structure, and module visibility rules. Enables organised, multi-file projects from the start.

Lesson 4 • Core Syntax and Primitive Types

Covers variables, mutability, scalar types, and basic expressions. Provides the syntactic foundation every later chapter depends on.

Lesson 1 • Lifetime Annotations

Introduces lifetime syntax, elision rules, and struct lifetime parameters. Allows writing functions that return references safely.

Lesson 2 • Smart Pointers

Explores Box, Rc, Arc, RefCell, and their use cases. Extends ownership patterns to heap allocation and shared ownership scenarios.

Lesson 3 • Ownership Rules and Move Semantics

Defines the three ownership rules and explains move vs. copy semantics. Forms the conceptual core that all borrow-checker reasoning builds upon.

Lesson 1 • Standard Library Traits in Depth

Covers Iterator, From/Into, Display, and operator-overloading traits. Integrates custom types seamlessly with the standard library ecosystem.

Lesson 2 • Advanced Type System Features

Introduces associated types, const generics, and newtype patterns. Enables precise, expressive APIs that prevent misuse at compile time.

Lesson 3 • Defining and Implementing Traits

Covers trait definitions, default methods, and implementing traits on custom types. Enables polymorphic behaviour central to idiomatic Rust design.

Lesson 4 • Trait Objects and Dynamic Dispatch

Explains dyn Trait, object safety rules, and vtable overhead trade-offs. Enables runtime polymorphism when static dispatch is insufficient.

Lesson 1 • Custom Error Types

Explains implementing std::error::Error, enum-based errors, and error context. Produces descriptive, structured errors suitable for library and application code.

Lesson 2 • Panics, Unwinding, and Assertions

Covers panic!, assert!, catch_unwind, and abort vs. unwind strategies. Clarifies when panics are acceptable and how to contain them.

Lesson 3 • Combinators and the ? Operator

Teaches map, and_then, unwrap_or, and the ? propagation operator. Enables concise, readable error-propagation chains in real functions.

Lesson 1 • Collecting and Consuming Iterators

Covers collect, fold, reduce, sum, and partition. Converts lazy chains into concrete results and aggregated values.

Lesson 2 • Custom Iterators and Advanced Patterns

Implements Iterator on custom types and explores generator-style patterns. Extends iterator composition to domain-specific data structures.

Lesson 3 • Closures and Capture Modes

Explains closure syntax, Fn/FnMut/FnOnce traits, and capture-by-reference vs. move. Enables passing behaviour as values throughout the codebase.

Lesson 4 • Core Iterator Adapters

Teaches map, filter, flat_map, zip, enumerate, and take. Builds the adapter vocabulary needed for real data-processing pipelines.

Lesson 1 • Threads and Shared State

Covers thread::spawn, join handles, Send/Sync traits, and Mutex-guarded state. Establishes safe multi-threading patterns enforced by the compiler.

Lesson 2 • Concurrency Patterns and Pitfalls

Examines deadlocks, starvation, async cancellation, and structured concurrency. Builds judgement for choosing the right concurrency model per use case.

Lesson 3 • Message Passing with Channels

Teaches mpsc channels, multi-producer patterns, and channel-based actor design. Provides an alternative to shared state for inter-thread communication.

Lesson 4 • Tokio Runtime in Practice

Covers Tokio setup, task spawning, select!, and async I/O primitives. Connects async theory to the most widely used production runtime.

Lesson 1 • Raw Pointers and Unsafe Blocks

Covers *const T, *mut T, dereferencing rules, and unsafe block scoping. Establishes the minimal footprint principle for unsafe code.

Lesson 2 • Memory Layout and Allocation

Explains repr attributes, alignment, padding, and the global allocator API. Enables precise control over data layout for performance and FFI compatibility.

Lesson 3 • Inline Assembly and Intrinsics

Covers asm! macro syntax, register constraints, and SIMD intrinsics. Enables hardware-level optimisations where compiler output is insufficient.

Lesson 4 • Safe Abstractions over Unsafe Code

Demonstrates encapsulating unsafe internals behind safe public APIs. Produces reusable, auditable components that preserve Rust's safety guarantees externally.

Lesson 1 • Configuration, Logging, and Observability

Introduces config management, structured logging with tracing, and metrics emission. Provides runtime visibility essential for operating production services.

Lesson 2 • Performance Profiling and Optimisation

Covers criterion benchmarks, flamegraphs, allocation profiling, and compiler hints. Identifies and eliminates bottlenecks with data-driven techniques.

Lesson 3 • Packaging, Deployment, and Release

Covers cross-compilation, Docker containerisation, binary size reduction, and release profiles. Produces deployable artefacts optimised for target environments.

Lesson 4 • Testing Strategies and CI Integration

Teaches unit tests, integration tests, property-based testing, and CI pipelines. Ensures code correctness is verified automatically at every change.