Learn Rust

This course exists because I cannot memorize rules and never could. If I understand the system that produces the rules, I remember it for years, because systems have structure and structure compresses.

Rust tutorials gave me rules such as “one mutable reference or many immutable,” “moves invalidate the source,” and “lifetimes must not outlive their referent.” Stack architecture, computability constraints, and Rice’s theorem sit underneath these rules and explain every decision Rust’s designers made. Dig into them and the rules stop requiring memorization because they become derivable. The borrow checker becomes a consequence of what memory is, what compilers can analyze, and what tradeoffs Rust chose.

I did not find that path in any existing course. The Rust Book, Google’s Comprehensive Rust, r4cppp, Codecademy, and Udemy teach the rules well. This course derives them. SPACE x TIME x COORDINATES is a framework for memory bugs. Use-after-free, data races, and dangling references are failures in one of these three dimensions. The course builds the framework first, and the borrow checker falls out of it.

Who this course is for

This course is for experienced programmers, particularly those with a C++ background, who already have a mental model of systems programming. The course updates that model. The density is high and the chapters are short, because we believe every sentence should be valuable and add to what you already know.

If you are new to programming or new to systems languages, start with The Rust Book. It builds the mental model this course assumes you already have. Come back here when you want to understand the system underneath the rules.

Chapters

• 01 First Contact Before: Experienced C++ programmer. Has not written Rust.
  After: Knows Rust catches bugs C++ misses. Does not know how yet. Curious.
• 02 Space, Time, Coordinates Before: Knows Rust catches bugs C++ misses. Does not know how.
  After: Has a framework for understanding memory bugs. Ready to see how Rust applies these ideas.
• 03 Catching Coherence at Compile Time Before: Has framework: SPACE, TIME, COORDINATES. Does not know how a compiler could detect these problems.
  After: Understands how Rust makes compile-time coordinate analysis possible. Ready for lifetime syntax and mechanics.
• 04 Limits of Compile-Time Analysis Before: Understands how Rust makes compile-time coordinate analysis possible.
  After: Understands why the compiler must be conservative and what trade-offs that creates.
• 05 ... This chapter and subsequent chapters are a work in progress.
•  ~  Exercises Hands-on exercises organized around the framework, not language features. Starts with the explicit! macro — a companion crate that makes Rust's implicit operations visible.