Introducing Yet Another Rust Resource (or YARR!)

Monday, November 13, 2023

Rust is a hard language to learn, in the scheme 1 of things. I've previously talked about why the learning curve is hard and what we could do about it. Today, I'm proud to say that there's another resource to help people learn Rust in a more approachable way.

Introducing Yet Another Rust Resource 2 , or YARR. (Yes, many examples are pirate themed.) YARR is a short introductory course on Rust which is designed to be completed in just a few days. The goal is to get you some foundational knowledge and the lay of the land so you can go forth and deepen your knowledge through real-world programming and other books/courses. When you complete YARR, you should be able to write simple Rust programs and you should have enough familiarity to pair with someone on a bigger Rust program.

I've linked to YARR previously from my projects page and soft-launched it with some friends, but never officially announced it. Whoops! So here it is, announced and ready to use.

What follows are some usage suggestions, how to contribute feedback and help, and why this exists in the first place.

How to use YARR!

YARR is written to get people up to speed quickly in an environment where they will be able to continue working with an experienced Rust programmer. This may be a work environment, it may be the best community for programmers, or it could be a hobby project where you can pair a lot. People can also learn entirely independently and use deeper resources after or alongside YARR.

Here's my suggestion on how to complete the course:

  1. Read/skim through it once without doing the exercises. You won't retain a lot of the material or understand it well on the first read. The purpose of the first pass is to start to load terms into your head and start building familiarity. You'll also get a little lay of the land. If you don't understand something, skip it and move on.
  2. Find another Rust programmer to help you when you have questions or are stuck. The goal with getting comfortable with Rust quickly is to avoid some of the hard parts, and an experienced Rust programmer will be able to get you unstuck and move past some of the tricky things. You may want to reach out to people at work, in your communities (RC is great for this), friends, or internet strangers. If you don't have someone to pair with, feel free to email me; I can pair with a few people who are working through this and I can also pair volunteers.
  3. Read it carefully and do the exercises (get your friend). Your second pass through it should be a more careful reading. Do the exercises as you go, and try to see if you generally get the concepts. This is a great time to work with your Rust partner on this. As a more experienced Rust programmer they should be able to help you through the tricky bits and help with some of the concepts. And don't be too hard on yourself, though: You will probably not understand lifetimes and a lot of the other concepts your first time through. Those sure took me a long time to grok, too. Just see what you understand, see if you can do the exercises, and ask your partner for help!
  4. Bookmark it as a resource. Once you've finished the course but before you move on to something else, make sure you save it! (You can actually do this whenever you like.) It's a handy resource to come back to for a quick refresher on things, especially after you've gone through something deeper.
  5. Explore more deeply! Now that you've finished YARR, you can move on to other resources and other learning paths. There are a lot of great books out there on Rust, each with a different flavor, so it is worth looking at multiple for which suits you best. And you can also dive in more deeply through pair programming: this is how I helped a coworker get more comfortable with Rust (he also did YARR and has read some of a Rust book). And as you go through these paths, revisit YARR occasionally to get an overview again.

Feedback and help wanted

This is just the first version of YARR, which is very much a living document. I wrote this version by myself with very gracious feedback from friends and coworkers, but it needs more to be even better.

Here's what you can do to help YARR be even better:

  • Send me feedback! What worked well for you? What are you still confused on? Is something wrong? Do you have a better pirate example I should include?
  • Volunteer to pair with learners! It can be hard to find an experienced Rust programmer to pair with so I'm going to see if I can do those pairings. If you want to be paired with someone learning or you want to be paired with a mentor, email me!
  • Share this post and YARR! If you found this material helpful or you think someone else would, please share it with friends, on your blog, wherever you think someone who can use it will find it. Resources are only as helpful as they are discoverable. I think sharing this post would be the best introduction into YARR, but do as you feel best.
  • Send a patch! If you want to directly contribute improvements to the content, you can also submit patches to it. Instructions are in the repo and you can also email me if you want any pointers on contributing, since email contribution workflows are uncommon.

Why YARR exists

I wrote the content for the first version of YARR because I wanted—no, needed—it to exist. There were a dearth of training materials for quickly getting people up to speed in Rust, and that's a big gap. We were considering introducing Rust at work, and one of the big challenges with Rust has always been the time to onboard new programmers into it. When we used Go, we could get someone up to speed in under a week (although mastery takes far longer), so this was a big drawback for Rust. If we could make this faster, it would aid adoption of Rust at work.

When Google released the content for Comprehensive Rust, I saw an opportunity to make a similar training course that's run asynchronously. I can't run a 3-day workshop at work, but I can write the material ahead of time and help people when they get stuck! So I wrote this material to help my coworkers quickly get up to speed on Rust so that we could use Rust in production.

The full version here is public and shared because the material was written once, but can be shared many times. There's no sense in writing good training materials and then keeping them closed off. This exists so that everyone can learn Rust and can get up to speed as quickly as possible.

It isn't intended as a full, comprehensive course in Rust. That's not doable in a condensed timeframe. It's just intended to be a pragmatic introduction to get people going and to make it a whole lot less scary.


  1. On the other hand, Scheme is a relatively easy language to learn, though as hard to master as any.
  2. Yes, I shamelessly borrowed the "yet another" convention just to make a memorable name.

If this post was enjoyable or useful for you, please share it! If you have comments, questions, or feedback, you can email my personal email. To get new posts and support my work, subscribe to the newsletter. There is also an RSS feed.

Want to become a better programmer? Join the Recurse Center!