Prelude-The Philosophy Behind the Syllabus¶

Before week 1, sit with this document for an evening. The rest of the curriculum is mechanically dense; this is the only chapter where we step back and define the shape of the discipline.

1. Rust Is an Affine Type System Bolted to a Region Calculus¶

Rust is most often described as "a memory-safe systems language." That description is marketing, not engineering. The accurate description:

Affine types: every value can be used at most once by move (std::mem::take - style semantics), unless it isCopy`.
Region inference: lifetimes ('a) are region variables in a constraint solver-they exist only at compile time and never appear in the binary.
Sub-structural extensions: traits like Send, Sync, Unpin, Sized add capability axes that the type checker propagates.

If you internalize this framing, you stop fighting the borrow checker and start reading the constraint failures it emits.

Reading: Ralf Jung et al., RustBelt: Securing the Foundations of the Rust Programming Language (POPL 2018). Skim the introduction; you do not yet need the separation-logic semantics.

2. The Cost Model You Must Adopt¶

A working Rust engineer reasons about every line of code along four axes simultaneously:

Axis	Question to ask
Ownership	Who frees this? When?
Layout	Where does this live-stack, heap, `.data`, `.rodata`, TLS? Aligned to what?
Codegen	Is this monomorphized? How many copies will the linker see?
Failure	What does the panic path look like? Is unwinding allowed here?

Beginner courses teach axis 1 only. This curriculum forces all four into your hands by week 8.

3. The Reading List¶

These are referenced throughout the curriculum. You are not expected to read them cover-to-cover before starting; they are pinned tabs.

Primary - The Rust Reference-doc.rust-lang.org/reference. The normative spec. - The Rustonomicon-doc.rust-lang.org/nomicon. Unsafe semantics. - Rust for Rustaceans (Jon Gjengset)-the only book worth reading after The Book. - Programming Rust, 2e (Blandy/Orendorff/Tindall)-best treatment of the type system.

Secondary, by phase - Concurrency: Rust Atomics and Locks (Mara Bos). Read once at week 9, again at week 11. - Async: Tokio's runtime/ source tree; withoutboats's blog (without.boats). - Macros: The Little Book of Rust Macros and dtolnay/proc-macro-workshop. - Compiler: rustc-dev-guide (rustc-dev-guide.rust-lang.org). - Allocators: Phil Opperman's Writing an OS in Rust-chapters 9–11.

Adjacent canon (not Rust, but you must know it) - Drepper, What Every Programmer Should Know About Memory (2007). Re-read in week 9. - Herlihy & Shavit, The Art of Multiprocessor Programming, chapters 7, 9, 13. - Intel SDM Vol. 3A, chapter 8 (memory ordering). RISC-V and ARMv8 equivalents if those are your targets.

4. Curriculum Philosophy: "Read the Source, Ship the Lab"¶

Three rules govern every module:

Source first, blog second. When the curriculum says "study Tokio's Notify," it means open tokio/src/sync/notify.rs and read it. Blogs go stale; commits are dated.
One lab per concept, one PR per phase. By the end of each month, the reader has produced one open-source-quality artifact (crate, gist, or PR)-not a notebook of toy snippets.
The compiler is the teacher. When you do not understand why something fails to compile, the first response is to enable RUSTC_LOG=trace, the second is to consult rustc --explain Exxxx, and only the third is to ask another human.

5. What Rust Is Not For¶

A graduate of this curriculum should be able to argue these points in a design review without sounding ideological:

Greenfield CRUD web apps with frequent schema churn. Your iteration speed will be dominated by compile times and serde ceremony. Go, TypeScript, or Elixir are usually better.
Throwaway scripts. Use Python.
Code where the team has no C/C++/systems intuition. Rust does not erase complexity; it surfaces it. A team that has never debugged a use-after-free will struggle to read Pin<&mut Self>.
GUI applications with rich tooling demands. The ecosystem is improving but is still a step behind Qt/SwiftUI/Flutter.

The signal that Rust is the right tool: you have a memory-safety, latency-tail, or single-binary-deployment constraint that ranks above developer iteration speed.

6. A Note on AI-Assisted Workflows¶

Modern Rust authors use LLM tooling. Two rules:

Never paste async/unsafe code from a model without reading the generated MIR (cargo rustc -- --emit=mir). The failure modes are subtle and the model's training data is biased toward older, simpler patterns.
Macros are the worst LLM modality. Hygiene bugs and span errors slip past human review. Write proc macros yourself; use the model only for the boilerplate around syn::parse.

You are now ready for Week 1. Open 01_MONTH_FOUNDATIONS.md.