Appendix

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

About This Course

You've made it to the end (or you're just skipping ahead, which is fine too). With the core exercises behind you, allow me to share a bit of context about this course and how to keep going.

Why I Wrote This Course

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.

Some resources require setup before you can run the examples. You might have to set up a project, install the Rust toolchain, or figure out how to run tests. What was missing, for me, was a URL I could just open in a browser and write code immediately. And you'd get instant feedback on how you're doing.

This course started as a folder on my laptop, the kind of thing I'd pull out during workshops whenever someone asked "how do I do this in Rust?" Over the years, I collected enough material for a structured path through the language. This course is the result.

My hope is that it gives you a complementary perspective on Rust, from a practitioner's perspective. Let me know how I did.

How to Keep Going

If you haven't done the bonus exercises, please do. They are more free-form and loose than the strict core exercises, and they are a great way to expand your skills as you come up with your own challenges.

I recommend Build a password validator as a starting point.

In general, practice the Rust core mechanics on a problem that matters to you. Some recommendations:

• Build something tiny. A CLI that does one thing for you. A scraper. A toy interpreter. The smaller and more personal, the better. And I mean it: there are no problems too small to practice on. Often, the simplest tasks are the most revealing about a language's mechanics.
• 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. After more than a decade of Rust, I still pick up a nugget or two from every crate I read.
• Use it for "the next thing" you'd otherwise do in another language. Give yourself time; you'll be making decisions that are already familiar in your usual language. Decisions about errors, modules, and tests can often be reused in later projects, so this is not wasted time.
• Investigate unexpected behavior. When behavior seems surprising or a compiler message catches you off guard, take the time to investigate. Reduce it to a small example and change one thing at a time. This is a little gift from the compiler: it is telling you something about the language that you didn't fully grasp.

A Note from corrode

corrode is a Rust training and consulting company. I help people go from prototype to production. If your company is looking to migrate to Rust, give me a call and let's see if I can help. Go to corrode.dev/services to learn more.

This course is open source. You can find the source code at github.com/corrode/course. Issues and pull requests are highly appreciated.

Welcome to the Rust community.

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.

Here you try the code before reading the rules behind it. I use that order because a borrow-checker error gives you something concrete to work through instead of a rule to memorize.

Future Directions

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

• More warning before the hard spots, so you know when to set aside extra time.
• A dedicated closures chapter (Fn, FnMut, FnOnce, and capture semantics) as another turn of the ownership spiral.
• A concurrency chapter on threads, shared state, and the compiler checks that prevent data races.
• 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.
• A mix of descriptive and motivational chapter titles. Keep the explanations concrete about what Rust does and where its limits are.
• 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.