Rust Fundamentals Course

Lesson 1 • Installing and Configuring the Toolchain

Walks through installing rustup, selecting toolchain versions, and configuring an editor. Ensures every student has a reproducible, working environment.

Lesson 2 • The Cargo Build System

Introduces Cargo as Rust's official build tool and package manager. Students create, build, and run their first project using Cargo commands.

Lesson 3 • Writing and Running Your First Programme

Guides students through a minimal Rust programme, explaining the main function, macros, and compilation output. Connects syntax to the broader language model.

Lesson 1 • Functions and Basic Error Handling

Defines functions with typed parameters and return values, and introduces panic vs. recoverable errors. Prepares students for the Result type covered in later chapters.

Lesson 2 • Control Flow Constructs

Teaches if, loop, while, and for constructs, including their expression forms. Students write branching and iterative logic that compiles without warnings.

Lesson 3 • Variables, Mutability, and Shadowing

Explains let bindings, the immutable-by-default rule, and shadowing semantics. Establishes Rust's strict approach to variable state early in the course.

Lesson 4 • Scalar and Compound Types

Covers integers, floats, booleans, chars, tuples, and arrays. Students learn type inference, explicit annotations, and the limits of each type.

Lesson 1 • Ownership Rules and Move Semantics

Defines the three ownership rules and demonstrates how values move between scopes. Students trace ownership transfers to predict when values are dropped.

Lesson 2 • The Slice Type

Covers string slices and array slices as reference types into contiguous data. Reinforces borrowing concepts with practical, commonly used data views.

Lesson 3 • Lifetime Annotations

Explains lifetime parameters as a way to express reference validity relationships. Students annotate functions and structs to satisfy the borrow checker in complex scenarios.

Lesson 4 • Common Ownership Patterns

Surveys idiomatic patterns such as cloning, returning owned values, and using Rc for shared ownership. Bridges theory to practical design decisions.

Lesson 1 • Methods and Associated Functions

Attaches behaviour to structs via impl blocks, distinguishing methods from associated functions. Establishes the foundation for trait implementations in the next chapter.

Lesson 2 • Defining and Using Structs

Covers named-field, tuple, and unit structs, plus struct update syntax. Students model real data and understand how ownership applies to struct fields.

Lesson 3 • Destructuring and Advanced Patterns

Extends pattern matching to let, function parameters, and if-let chains. Students write concise code that handles multiple data shapes without nested conditionals.

Lesson 4 • Pattern Matching with match

Teaches exhaustive match expressions, guards, and binding patterns. Students deconstruct complex data types safely and readably.

Lesson 1 • Dynamic Dispatch with Trait Objects

Contrasts static dispatch with dyn Trait for runtime polymorphism. Students choose between generics and trait objects based on performance and flexibility needs.

Lesson 2 • Generic Functions and Structs

Introduces type parameters on functions and structs, enabling code reuse across types. Students write generic data structures and understand monomorphisation.

Lesson 3 • Common Standard Library Traits

Covers Display, Debug, Clone, Copy, PartialEq, and Iterator as essential building blocks. Students derive or manually implement these traits to integrate with Rust's ecosystem.

Lesson 4 • Defining and Implementing Traits

Introduces traits as shared behaviour contracts and shows how to implement them for custom types. Connects to the standard library's most common traits.

Lesson 1 • Using Error-Handling Libraries

Introduces popular crates that reduce error-handling boilerplate and improve ergonomics. Students evaluate when a library adds value over manual implementations.

Lesson 2 • Result<T, E> in Depth

Examines Result's variants, combinators, and unwrap methods. Students understand when each method is appropriate and what it signals to callers.

Lesson 3 • Custom Error Types

Guides students through defining domain-specific error enums and implementing standard error traits. Produces APIs with informative, structured error information.

Lesson 4 • The ? Operator and Error Propagation

Shows how ? propagates errors up the call stack, reducing boilerplate. Students refactor verbose match blocks into concise, readable error-propagating functions.

Lesson 1 • Standard Collections Overview

Surveys Vec, HashMap, HashSet, BTreeMap, and VecDeque with their performance characteristics. Students select the right collection for each access and ordering requirement.

Lesson 2 • Closures and Captured Environments

Defines closures as anonymous functions that capture their environment by reference or value. Students use Fn, FnMut, and FnOnce to express closure capabilities.

Lesson 3 • Iterator Adapters and Consumers

Covers map, filter, flat_map, take, zip, and collect as the core adapter toolkit. Students compose lazy pipelines that execute only when consumed.

Lesson 4 • Performance and Allocation Awareness

Analyses iterator zero-cost abstraction claims and common allocation pitfalls. Students profile simple pipelines and choose between iterators and manual loops when justified.

Lesson 1 • Async/Await Fundamentals

Introduces the Future trait, async functions, and the await keyword for non-blocking I/O. Students understand how async differs from threads and when to prefer each.

Lesson 2 • Shared State with Mutex and Arc

Combines Arc for shared ownership and Mutex for interior mutability across threads. Students build a thread-safe counter and understand lock poisoning.

Lesson 3 • Async Runtimes and Practical Patterns

Surveys async runtimes, task spawning, and common async patterns like timeouts and select. Students run a complete async programme and handle concurrent tasks safely.

Lesson 4 • Threads and the Send and Sync Traits

Spawns OS threads with std::thread and explains how Send and Sync enforce thread safety. Students understand why Rust prevents data races at the type level.