Finding time to learn Rust...

1) Tiny bites

The key is “tiny bites at a time”. Find 10-15 minutes, perhaps after lunch, or first thing in the morning—but certainly at a fixed time daily—to dedicate to your task.

2) Read short examples

The very first thing I did when I heard about Rust—and what I typically do with any language—was to look at some very short examples. What’s the syntax like? How many steps does it take to solve a trivial problem? As an embedded engineer, my foremost concerns are the easy ones: can I blink an LED or detect a button press with the same ease as I can in C? Can I read and write memory mapped registers? A language that does not allow access to low-level peripherals is useless for my purposes, so I was quite relieved to see that Rust offers packages (called crates) that do this very thing. It’s not as straightforward as assigning data to a pointer, but I was satisfied (despite readers’ comments) with this side-by-side comparison of porting a GPIO driver to Rust

I also spent a few days reading Rust by Example, to see what features the language offered to solve the types of problems I deal with in embedded development. It’s a great resource that fits into the “bite-sized” approach because most sections are relatively brief, and can be read within 15 minutes. In addition, check out some of the various excellent YouTube channels dedicated to Rust, like Let's Get Rusty, Jon Gjengset’s channel, or the Rust team’s curated channel.

3) Find an online simulator

Ultimately, to get a proper feel for what it would be like to program in Rust, you’d want to install the tools (e.g. compiler and package management) on your computer. However, since I wasn’t quite yet convinced, I didn’t want to invest any time (or disk space) to Rust quite yet. Instead, I started looking for online compilers and interpreters that could be run from a web-browser. I settled on the Rust Playground for experimenting and trying out some small examples. As an embedded developer, I often examine the resultant assembly code to be sure of what the machine is actually doing, and have come to find the Compiler Explorer invaluable for that purpose.

4) Try out small examples

Start trying out the concepts from the examples above by writing small programs using the online simulator. Experiment with variables, types, bindings, scope, shadowing; you might find yourself delighted with some niceties that you wished C had. Move on to flow control, iteration, functions, and high-order functions. Test aggregate types like tuples and structs.

Then comes the screeching halt: trying to implement a linked list with Rust. It’s surprisingly difficult given Rust’s perspective on object ownership, borrowing, and mutability. I went off in the weeds trying to implement what I think is an important abstract data type, before the realization hit me: Rust natively supports arrays, slices, vectors, and has a crate that implements queues. Why reinvent the wheel? See “too many linked lists” if you insist on solving a redundant issue.

Going further, try out some more complex examples that take advantage of the strengths of Rust. How does one write, say, a single producer-consumer program? Well, Rust provides threads to divvy up the work, channels to communicate between them, async/await for task concurrency—especially for i/o bound workloads—and can lock stdout to prevent interleaving of text messages. Bonus (for me): Rust can lock stdout to prevent interleaving of text messages; how many times have your debug messages stomped on each other? These are things hard to get right in C (or even C++), so having them be part of the language means less time spent debugging these patterns.

5) Looks like it’s time to install the thing

Unsurprisingly, installing the Rust development system takes little time since there are packages for pretty much every operating system. Alternatively, you could install it as part of an already existing Docker image (not to go off on a tangent, but Docker is a great containerization tool for embedded development).

Unlike C or C++, developing with Rust means you’ve got a native build system, updater, and package management that makes life a lot easier. It took all of 5 minutes to write my first complete (albeit tiny) Rust program and execute it locally.

If you’re like me, you have a collection of small utilities written in C. For instance, I have a much-simplified replacement to /usr/bin/find because I could never remember the more complex syntax. It’s straightforward path iterating and pattern matching, and hews to the Unix philosophy on simplicity. Another “shortcut” simply converts decimal arguments to their hex equivalent, and vice versa. Another sums all its arguments and so on. Why? Well, pipe some hex addresses from a piece of code, sum them, and find a few offsets in decimal. Beats using a GUI calculator and copy-pasting each thing manually. I found that writing a Rust version for each one gave me more motivation to keep at it because I was solving little problems that were personally meaningful to me. Often this may be the best way to learn.

6) Doing Embedded Rust

Now it’s time to turn our attention to the end-goal of all this effort and practice: get Rust working on an embedded system. The first thing to do is read up on Embedded Rust, and while doing so, find a platform you like that has good board support (for Rust). There are resources for STM32, NRF, NXP, AVR, and the Raspberry Pi Pico (among others), in different states of maturity, so you’re spoiled for choice. Alternatively, you can use QEMU. This allows you to emulate the hardware to run your programs on while you figure out the development platform, the tools, and how Rust can make use of various hardware resources. Then, proceed to rewrite small test utilities—or even an entire program—using the skills you developed during the earlier sections.

7) Make time for learning in your career

Far too many engineering companies expect every hour to be spent actively working on projects or billing for clients, with no time allocated to learning or self-improvement. There are some companies, like Dojo Five, that have found it beneficial to block out a few hours every week for engineering to spend time on education and process improvements. “Always learning” is one of our company values and "Dojo" translates to "place of the way"—representing an environment for immersive learning. By incorporating new ideas or learning a new skill, engineers can improve their craft.

In conclusion

Rust appears to be gaining steam as a solid language to solve complex and challenging problems in embedded systems; it provides powerful safety guarantees, is built for speed, and has mechanisms to make programs safe from memory guarantees while remaining fast. 

A colleague mentioned that every time he walks away from Rust for a while it changes and it's hard to get back into it, which appears to be an ongoing challenge that the Rust-curious run into. If you can continue to schedule time for tiny bites, build your skills through examples, and work these skills into your day-to-day work, you can finally learn and feel the confidence to apply Rust to many embedded development challenges.