Appendix

This is an appendix to the course. It contains additional material that may or may not be interesting to you.

About this course

You finished the course (or you're skipping ahead, which is fine too). A bit of background, in case you're curious.

Why this course exists

There's no shortage of Rust resources. The official book is excellent, and you should read it. So is Rust by Example, and plenty of others.

What was missing, for me, was a path you could open in a browser and just do. Not a book to read on the couch, not a lecture to watch on 2x speed: a sequence of small, real problems with tests that turn green. Something where the code leaves your fingers and lands in the machine right away.

These exercises started as a folder on my laptop, the kind of thing I'd pull out whenever someone asked "where do I start with Rust?" Over the years it grew into a structured path through the language. This site is that path, with an editor attached.

How to keep going

The course covers the core mechanics. Real fluency comes from using those mechanics on problems that matter to you. A few suggestions:

• Build something tiny. A CLI that does one thing for you. A scraper. A toy interpreter. The smaller and more personal, the better. Finishing it teaches more than reading another tutorial.
• Read other people's Rust. Pick a small crate you find useful and read its source. The Rust ecosystem leans toward clean, idiomatic code; you'll absorb a lot just by skimming.
• Use it for the next thing you'd otherwise do in another language. The first project will be slow. The second will be noticeably less slow. By the fifth, Rust feels like home.
• Stay curious. Rust is a deep language; nobody knows all of it. When something surprises you, that's the language inviting you to dig in.

A note from corrode

This course is open source on github.com/corrode/course. Issues and pull requests welcome. If you'd like Rust training, code review, or consulting for your team, see corrode.dev.

Thanks for spending time here. Now go write some Rust.

Why this course is built the way it is

A few deliberate choices set this course apart from reading the official book front to back. None of them are knocks on the book, which is excellent. They're different bets about how people actually pick up a language.

The throughline is that you learn Rust by hitting its rules in practice, not by reading about them in advance. The borrow checker makes more sense after you've watched it reject something than it does as a list of rules up front, so the course leans on that order everywhere.

Future directions

Some ideas didn't make this version but are worth writing down so they aren't lost:

• Difficulty signposting: an explicit "this chapter is a cliff" warning before the hard spots.
• A dedicated closures chapter (Fn, FnMut, FnOnce, and capture semantics) as another turn of the ownership spiral.
• A fearless-concurrency chapter, the fourth pillar alongside no null, no exceptions, and memory safety without a GC.
• A problem-first language picker: ask which language you're coming from and show the bug in that language first. For now the prose stays language-neutral.
• Pillar slogan titles for the chapters ("No null", "No exceptions", and so on). For now that motivation lives in each chapter's opening lines.
• A running project thread that carries one program across chapters instead of standalone exercises.

If you have opinions on any of these, the issue tracker is open.