Rust Programming Basics Course

Lesson 1 • Writing Your First Rust Program

Guides students through a minimal Rust program, explaining entry points, macros, and compilation. Builds familiarity with syntax before deeper concepts are introduced.

Lesson 2 • Installing the Rust Toolchain

Walks through rustup installation, managing toolchain versions, and verifying the setup. Provides the foundation for all hands-on exercises in the course.

Lesson 3 • Why Rust Exists

Covers Rust's design goals: memory safety without garbage collection, zero-cost abstractions, and systems-level performance. Sets context for every concept introduced later.

Lesson 1 • Control Flow Constructs

Teaches if/else, loop, while, and for constructs including their expression-based nature. Prepares students for pattern matching introduced in later chapters.

Lesson 2 • Variable Binding and Mutability

Explains let bindings, immutability by default, and the mut keyword. Immutability is a core safety feature that recurs throughout ownership and concurrency topics.

Lesson 3 • Functions and Expressions

Explains function signatures, return types, and Rust's expression-oriented evaluation model. Establishes the distinction between statements and expressions used throughout the language.

Lesson 4 • Scalar and Compound Types

Covers integers, floats, booleans, characters, tuples, and arrays. Understanding these types is prerequisite to working with structs, enums, and collections.

Lesson 1 • Cloning and Copying

Distinguishes the Copy trait for stack types from explicit clone for heap types. Prevents confusion when values appear to be duplicated unexpectedly.

Lesson 2 • Lifetime Annotations Basics

Explains when the compiler requires explicit lifetime annotations and how to write them. Builds the minimum understanding needed before advanced generics are introduced.

Lesson 3 • Slices as Borrowed Views

Covers string slices and array slices as references into contiguous data. Slices appear in nearly every real-world Rust API and function signature.

Lesson 4 • References and Borrowing

Introduces shared and mutable references, enforcing the aliasing XOR mutability rule. Students write functions that access data without taking ownership.

Lesson 1 • Concise Patterns: if let and while let

Introduces if let and while let as ergonomic alternatives to full match expressions. Reduces boilerplate when only one variant needs handling.

Lesson 2 • Enums and Variants

Defines enums with data-carrying variants and explains their memory layout. Enums enable exhaustive modeling of states, replacing error-prone integer flags.

Lesson 3 • Defining and Using Structs

Covers named-field structs, tuple structs, and unit structs with instantiation syntax. Structs are the primary tool for grouping related data in Rust programs.

Lesson 4 • Methods and Associated Functions

Teaches impl blocks, self parameter variants, and associated constructor functions. Encapsulates behavior alongside data before traits are introduced.

Lesson 1 • Strings and String Slices

Explains the String type, UTF-8 encoding, concatenation, and slicing rules. Clears up the common confusion between String and &str in function signatures.

Lesson 2 • Panics and Unrecoverable Errors

Distinguishes panic from Result, explains unwrap and expect, and covers when panicking is appropriate. Prevents misuse of panics in library and production code.

Lesson 3 • Vectors

Covers Vec creation, pushing, indexing, iteration, and ownership interactions. Vectors are the most common heap-allocated collection in Rust programs.

Lesson 4 • Handling Errors with Result

Covers the ? operator, match-based error handling, and converting between error types. Establishes the idiomatic Rust approach to recoverable errors.

Lesson 1 • Defining and Implementing Traits

Explains trait definitions, default method implementations, and implementing traits on custom types. Traits are Rust's primary abstraction mechanism for shared behavior.

Lesson 2 • Trait Objects and Dynamic Dispatch

Explains dyn Trait, fat pointers, and the trade-off between static and dynamic dispatch. Enables heterogeneous collections and plugin-style architectures.

Lesson 3 • Generic Functions and Structs

Introduces type parameters in functions and structs with trait bounds. Enables writing algorithms that operate on any type satisfying specified constraints.

Lesson 4 • Common Standard Library Traits

Covers Display, Debug, Clone, PartialEq, PartialOrd, and Iterator. Familiarity with these traits is required for idiomatic Rust in every domain.

Lesson 1 • Iterator Adapters and Consumers

Covers map, filter, flat_map, take, skip, zip, and collect. Students build readable data pipelines that compile to efficient machine code.

Lesson 2 • The Iterator Trait

Defines the Iterator trait, the next method, and how to implement a custom iterator. Provides the foundation for understanding all iterator adapters.

Lesson 3 • Folding and Aggregating Data

Teaches fold, reduce, sum, product, any, all, and find for aggregating iterator output. Completes the toolkit for replacing imperative loops with declarative pipelines.

Lesson 4 • Closures: Syntax and Captures

Covers closure syntax, environment capture by reference or value, and the move keyword. Closures are used extensively in iterators, threads, and async code.

Lesson 1 • Modules and Visibility

Explains the mod keyword, file-based module layout, and pub visibility rules. Proper module design prevents tight coupling and exposes clean public APIs.

Lesson 2 • Testing Within Modules

Covers unit tests in #[cfg(test)] modules, integration tests in the tests directory, and doc tests. Embeds a testing culture from the project structure level.

Lesson 3 • Using External Crates

Demonstrates adding dependencies from crates.io, version constraints, and re-exporting items. Enables students to leverage the Rust ecosystem in their projects.

Lesson 4 • Crates and the Cargo Manifest

Defines binary and library crates, Cargo.toml fields, and workspace configuration. Students understand how Rust projects are compiled and linked.