Rust

Rust from absolute zero to advanced: what a compiler does, values and types and how they sit in memory, then the ideas that make Rust different (ownership, borrowing, lifetimes) taught slowly with diagrams and real compiler errors. After that: structs, enums and pattern matching, error handling, collections, generics and traits, closures and iterators, modules and testing, smart pointers, threads, a look at unsafe code and FFI, and two practical projects. Exercises are compiled with rustc and checked in a sandbox; reading the compiler's messages is part of the craft, so some exercises start out broken on purpose.

• Getting Started: Programs and the Compiler
  What a program is, what rustc does to your source, cargo, reading compiler errors, and printing formatted output.
  1. What a Program Is, and What a Compiler Does · 30 min · 5 exercises
  2. rustc and cargo · 30 min · 4 exercises
  3. Reading Compiler Errors · 30 min · 5 exercises
  4. Printing and Formatting Output · 35 min · 5 exercises
• Variables, Types and Functions
  Bindings, mutability and shadowing; integer, float, bool and char types and their bits; tuples and arrays in memory; functions, expressions and statements; reading input.
  1. Variables, Mutability and Shadowing · 35 min · 5 exercises
  2. Integers: Bits, Sizes and Overflow · 40 min · 5 exercises
  3. Floats, Booleans, Characters and Casts · 40 min · 5 exercises
  4. Tuples and Arrays in Memory · 40 min · 5 exercises
  5. Functions, Expressions and Statements · 40 min · 5 exercises
  6. Reading Input: stdin and Command-Line Arguments · 40 min · 5 exercises
• Control Flow
  if as an expression, loop, while and for, ranges, labeled breaks, and a first look at match.
  1. if, else and Conditions as Expressions · 35 min · 4 exercises
  2. Loops: loop, while, break and continue · 40 min · 4 exercises
  3. for Loops, Ranges and Iterating Arrays · 40 min · 4 exercises
  4. First match: Choosing Between Many Cases · 35 min · 4 exercises
  5. Practice: Small Programs with Loops · 50 min · 4 exercises
• Ownership
  The stack and the heap, ownership and moves, Copy and Clone, Drop and scope, and how ownership flows through functions.
  1. The Stack and the Heap · 40 min · 4 exercises
  2. Ownership Rules and Moves · 45 min · 4 exercises
  3. Copy, Clone and the Cost of Duplicating · 35 min · 4 exercises
  4. Scope and Drop: Deterministic Cleanup · 40 min · 4 exercises
  5. Ownership Through Functions · 40 min · 4 exercises
• Borrowing and Slices
  Shared and mutable references, the aliasing rule, how the borrow checker reasons, dangling references, and slices.
  1. References: Borrowing Without Taking · 40 min · 4 exercises
  2. Mutable References and the Aliasing Rule · 40 min · 4 exercises
  3. Inside the Borrow Checker · 40 min · 4 exercises
  4. Dangling References and Why Rust Forbids Them · 35 min · 3 exercises
  5. Slices: Borrowing Part of a Collection · 40 min · 4 exercises
• Strings and Text
  String versus &str, UTF-8 bytes and chars, why you cannot index a string, and practical text processing.
  1. String and &str · 35 min · 3 exercises
  2. UTF-8: Bytes, chars and Why s[0] Does Not Compile · 40 min · 4 exercises
  3. Working with Text: Splitting, Trimming, Parsing, Building · 45 min · 3 exercises
• Structs, Enums and Pattern Matching
  Defining your own types, methods and associated functions, enums that carry data, and match, if let and destructuring in depth.
  1. Structs: Grouping Data · 40 min · 4 exercises
  2. Methods and impl Blocks · 40 min · 3 exercises
  3. Enums: Types with Variants · 45 min · 4 exercises
  4. Pattern Matching in Depth · 45 min · 4 exercises
• Option, Result and Error Handling
  Absence without null, recoverable versus unrecoverable errors, the ? operator, and writing your own error types.
  1. Option: A Value That Might Not Be There · 40 min · 3 exercises
  2. Result and panic!: Recoverable and Unrecoverable Errors · 45 min · 3 exercises
  3. The ? Operator and Propagating Errors · 40 min · 3 exercises
  4. Custom Error Types · 45 min · 3 exercises
• Collections
  Vec in depth with its memory layout, HashMap and BTreeMap with the entry API, sets, and choosing the right collection.
  1. Vec in Depth · 40 min · 3 exercises
  2. HashMap and BTreeMap · 45 min · 3 exercises
  3. Sets, VecDeque and Choosing a Collection · 45 min · 4 exercises
• Generics, Traits and Lifetimes
  Generic functions and types, defining and implementing traits, static versus dynamic dispatch, the standard traits, and lifetimes.
  1. Generics: Code for Many Types · 40 min · 3 exercises
  2. Traits: Shared Behavior · 45 min · 3 exercises
  3. Trait Bounds, impl Trait and dyn Trait · 45 min · 3 exercises
  4. The Standard Traits and derive · 40 min · 3 exercises
  5. Lifetimes: Naming How Long Borrows Live · 45 min · 3 exercises
• Closures and Iterators
  Closures and what they capture, Fn, FnMut and FnOnce, the Iterator trait, adapters and laziness, and writing your own iterators.
  1. Closures and Capturing · 40 min · 3 exercises
  2. Fn, FnMut and FnOnce · 35 min · 3 exercises
  3. The Iterator Trait and Adapters · 45 min · 3 exercises
  4. Writing Your Own Iterator · 40 min · 3 exercises
• Modules, Visibility and Testing
  Organizing code with mod and pub, paths and use, how files map to modules in a cargo project, and unit tests with #[test].
  1. Modules, Visibility and Paths · 45 min · 3 exercises
  2. Unit Tests with #[test] · 45 min · 3 exercises
  3. Testing Well: Edge Cases, Panics and Test Design · 45 min · 3 exercises
• Smart Pointers
  Box for heap allocation and recursive types, Deref and Drop, Rc for shared ownership, RefCell for interior mutability, and Weak to break cycles.
  1. Box, Deref and Drop: Owning Data on the Heap · 45 min · 3 exercises
  2. Rc: Shared Ownership · 35 min · 3 exercises
  3. RefCell and Interior Mutability · 40 min · 3 exercises
  4. Weak References and Reference Cycles · 40 min · 3 exercises
• Concurrency
  Threads and join, moving data into threads, channels, Arc and Mutex, Send and Sync, and scoped threads.
  1. Threads: Running Code at the Same Time · 40 min · 3 exercises
  2. Channels: Passing Messages Between Threads · 40 min · 3 exercises
  3. Shared State: Arc and Mutex · 45 min · 3 exercises
  4. Send, Sync and Scoped Threads · 40 min · 3 exercises
• Unsafe Rust and FFI
  What unsafe permits and what it still checks, raw pointers, writing safe abstractions over unsafe code, and calling C from Rust.
  1. What unsafe Means, and Raw Pointers · 45 min · 3 exercises
  2. Safe Abstractions over Unsafe Code · 40 min · 3 exercises
  3. FFI: Calling C from Rust, and Rust from C · 50 min · 3 exercises
• Projects
  Putting it together: a command-line word-frequency tool with options, a CSV state machine, and an expression interpreter with a tokenizer and recursive-descent parser.
  1. Project: A Word-Frequency Tool with Options · 60 min · 2 exercises
  2. Project: A State Machine for CSV · 60 min · 2 exercises
  3. Project: An Expression Interpreter · 90 min · 2 exercises