Rust training

Lesson 1 • Control Flow Essentials

Teaches if/else, loops, and pattern-based matching. Enables students to direct program execution through branching and iteration.

Lesson 2 • Functions and Modules

Defines function signatures, return types, and module visibility. Establishes code organization patterns used throughout the course.

Lesson 3 • Core Syntax and Data Types

Introduces variables, scalar types, and compound types. Builds the vocabulary needed to express logic in every later chapter.

Lesson 4 • Cargo and Project Structure

Explores Cargo commands, Cargo.toml, and workspace layout. Students gain the project management skills required for all hands-on exercises.

Lesson 1 • References and Borrowing

Introduces shared and mutable references with borrow rules. Students learn to pass data without transferring ownership.

Lesson 2 • Ownership Rules and Move Semantics

Explains single-owner invariant and value moves. Directly addresses the most common beginner compilation errors in Rust.

Lesson 3 • Lifetime Annotations

Teaches explicit lifetime syntax for functions and structs. Enables students to resolve lifetime errors the compiler cannot infer automatically.

Lesson 4 • Slice Types

Covers string slices and array slices as reference views. Connects borrowing concepts to practical data access patterns.

Lesson 1 • Methods and Associated Functions

Adds behavior to structs via impl blocks and constructors. Bridges data modeling with object-oriented-style encapsulation in Rust.

Lesson 2 • Defining and Using Structs

Covers named, tuple, and unit structs with field access. Provides the primary tool for grouping related data throughout the course.

Lesson 3 • Advanced Pattern Matching

Extends match to destructuring, guards, and binding. Enables concise, exhaustive handling of complex data shapes.

Lesson 4 • Enums and Option Type

Introduces enums with data variants and the Option<T> type. Eliminates null-pointer errors by encoding absence explicitly in the type system.

Lesson 1 • Standard Library Traits

Surveys Display, Debug, From, Into, Iterator, and Clone. Integrating these traits makes custom types interoperate with the entire ecosystem.

Lesson 2 • Trait Bounds and Where Clauses

Constrains generics with trait bounds and where syntax. Allows the compiler to verify that generic types support required operations.

Lesson 3 • Generic Functions and Structs

Introduces type parameters for functions, structs, and enums. Enables writing algorithms that operate over any compatible type.

Lesson 4 • Dynamic Dispatch with Trait Objects

Contrasts static dispatch with dyn Trait for runtime polymorphism. Students choose the right dispatch strategy for each design scenario.

Lesson 1 • The ? Operator and Propagation

Teaches the ? operator for concise error propagation in functions. Dramatically reduces boilerplate in functions that call multiple fallible operations.

Lesson 2 • Custom Error Types

Covers defining error enums, implementing std::error::Error, and conversions. Enables libraries to expose meaningful, structured error information.

Lesson 3 • Error Handling in Applications

Introduces anyhow for application-level error aggregation and context. Bridges library-style typed errors with user-facing diagnostic messages.

Lesson 4 • Panic and Unrecoverable Errors

Explains panic!, assert!, and stack unwinding. Establishes when crashing is appropriate versus when errors must be propagated.

Lesson 1 • Custom Iterators

Guides students through implementing Iterator on custom structs. Deepens understanding of the trait system and enables domain-specific iteration.

Lesson 2 • Closures and Capturing

Explains closure syntax, capture modes, and Fn trait families. Enables passing behavior as values to iterators and higher-order functions.

Lesson 3 • Vec, HashMap, and HashSet

Covers creation, insertion, lookup, and removal for core collections. Provides the data structures used in the majority of real Rust programs.

Lesson 4 • Consuming Iterators and Collect

Covers fold, sum, count, collect, and partition consumers. Converts lazy pipelines into concrete results and collections.

Lesson 1 • Message Passing with Channels

Teaches mpsc channels for inter-thread communication. Demonstrates the message-passing concurrency model as an alternative to shared state.

Lesson 2 • Tokio Runtime Essentials

Covers Tokio executor setup, async tasks, and async I/O primitives. Enables students to build real networked applications with the dominant async runtime.

Lesson 3 • Synchronization Primitives

Surveys async Mutex, RwLock, Semaphore, and Notify from Tokio. Equips students to coordinate concurrent tasks without data races.

Lesson 4 • Async/Await Fundamentals

Introduces Future trait, async fn, and .await syntax. Provides the conceptual model for non-blocking I/O in Rust applications.

Lesson 1 • Unsafe Blocks and Functions

Explains the five unsafe superpowers and how to encapsulate them. Students learn to minimize unsafe surface area and document safety invariants.

Lesson 2 • Foreign Function Interface

Covers extern blocks, C ABI, and calling C libraries from Rust. Enables integration with existing native codebases and system libraries.

Lesson 3 • Raw Pointers and Memory Layout

Introduces *const T and *mut T, pointer arithmetic, and memory alignment. Provides the foundation for FFI and manual memory management.

Lesson 4 • Custom Allocators and Memory Management

Introduces the GlobalAlloc trait, jemalloc, and arena allocation. Enables fine-grained memory control for performance-critical applications.