Chapter 24

Appendix

The following pages cover how the course was built and why the exercises are arranged this way.

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

Practice the core mechanics on a problem that matters to you:

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 use and trace one path through its source, from a public function to its return value. You do not need to understand the whole crate to pick up an idiom or two.
Use it for the next thing you'd otherwise do in another language. The first project will be slow. Decisions about errors, modules, and tests can often be reused in later projects.
Investigate unexpected behavior. When behavior or a compiler message catches you off guard, reduce it to a small example and change one thing at a time.

A note from corrode

This course is open source on github.com/corrode/course. Issues and pull requests are 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

I built this course around a simple bet: Rust sinks in faster when you write code before you study every rule. The choices below follow from that bet.

A reading-first path	This course
Read several chapters before writing any code	You write code from the first exercise
Ownership dumped as theory early on	Ownership introduced as a spiral, consolidated late
Little "why should I care?" motivation	Problem-first: show the bug Rust prevents, then the fix
No feedback when your code is wrong	Tests and focused `todo!()` stubs that point at what's missing

Here 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 we use that order throughout.

Future directions

I haven't built all the ideas below, but I don't want to lose them:

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, I keep the prose language-neutral.
Pillar slogan titles for the chapters ("No null", "No exceptions", and so on). For now, I keep that motivation in the 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.