Rust

Rust

Ownership, borrowing, and the compiler as a teaching device. 13 lessons, 6 phases — built up from first principles.

Start at lesson 0 →
Phase 0

Foundations

  1. 🦀 #0 Welcome — Programming, and Why Rust Starting from scratch: what a program is, and what makes Rust different
  2. 📦 #1 Installing Rust and Running Your First Program Cargo — the one tool that handles every part of a Rust project
  3. 🔤 #2 Variables, Types & Mutability Naming data, knowing what shape it is, and saying when it's allowed to change
  4. 🔀 #3 Making Decisions and Repeating Work if, match, and three kinds of loop — all of them produce values
Phase 1

Ownership & Borrowing

  1. 🪪 #4 Ownership: Who Owns the Data? The single idea that makes Rust safe without a garbage collector
  2. 🔗 #5 Borrowing — Reading Data Without Taking It References, &mut, and the one rule that prevents data races
  3. 🪓 #6 Slices and the Two Kinds of String Why Rust splits owning a buffer from borrowing a view into it
Phase 2

Types & Traits

  1. 🧱 #7 Building Your Own Types: Structs and Enums How to model your domain — and why enums in Rust are unusually powerful
  2. 🧬 #8 Traits and Generics — Code That Works for Many Types Polymorphism without inheritance, and the static-vs-dynamic dispatch trade-off
  3. 🔁 #9 Closures and Iterators — Pipelines That Process Data Anonymous functions and lazy, composable data pipelines
Phase 3

Errors & Options

  1. ⚠️ #10 Things Going Wrong — Option, Result, and ? How Rust signals failure without exceptions
Phase 4

Concurrency

  1. 🧵 #11 Doing Many Things at Once — Threads and Channels Concurrency without data races, because the compiler won't let you write one
Phase 5

Capstone

  1. 🎯 #12 Capstone: A CSV Summariser Pulling everything together into one small, real program

Rust

Learn Rust by editing real code and seeing why the compiler pushes back.

Rust from absolute zero, assuming it's your first language. Thirteen lessons run from "what is a program" through ownership, borrowing, traits, iterators, error handling, and concurrency, finishing with a small CSV summariser that pulls every idea together.

What makes it stick: every lesson has editable code boxes that compile and run for real against the official Rust Playground — including snippets designed to fail, so you watch the borrow checker catch a bug before it runs and learn to read the error. Woven through is the human story (Graydon Hoare, Tony Hoare's null, Bjarne Stroustrup's RAII, Barbara Liskov's iterators) and the type-theory roots of why Rust works the way it does.