Learning Rust For Embedded Systems

Steve Branam - Watch Now - EOC 2022 - Duration: 46:51

Steve Branam

Abstract Test Your Knowledge Questions & Comments (3)

This will cover my experience learning to work in Rust for embedded systems. This is from working as a volunteer firmware developer on the VolksEEG open source/open hardware project. Most of my experience is with C and C++, and this is my first project using Rust. I'll cover the resources I've used to learn both general Rust and the specifics of Rust on embedded systems, as well as the challenges I've run into. Rust eliminates several classes of problems that typically occur with other languages, but in order to do so it follows some different language philosophies and rules.

1 / 5

Please log in or create an account to test your knowledge and see the answers.

What main benefit does Steve Branam cite as the reason to use Rust for embedded systems?

A Rust provides a runtime garbage collector that prevents memory leaks at the cost of occasional execution stalls.

B Rust's compiler enforces rules at compile time to guarantee memory safety and eliminate whole classes of bugs without runtime cost.

C Rust requires less discipline from programmers because the language fixes design mistakes automatically.

D Rust is primarily chosen because it closely matches C syntax, making porting C code trivial.

E Rust sacrifices performance in favor of safety by inserting heavy runtime checks into every memory access.

Which statement correctly describes Rust's ownership and borrowing model as explained in the talk?

A You can have multiple mutable references and multiple immutable references to the same value at the same time.

B Each value has a single owner, moving transfers ownership, and at any given time you can have either one mutable reference or any number of immutable references.

C Values have no owners; Rust relies on a garbage collector to track references instead of ownership rules.

D Assignment and passing by value never transfer ownership; they always create hidden deep copies.

E Copy types are not allowed in Rust because they break the ownership model.

What does the unsafe keyword mean in Rust according to the speaker?

A It automatically disables all compiler checks and allows arbitrary memory corruption without any programmer responsibility.

B It marks code that bypasses some of the compiler's safety protections; the programmer explicitly assumes responsibility for maintaining safety.

C It enables a high-performance mode where Rust inserts runtime bounds checks to avoid panics.

D It is only used to indicate unstable language features and has no impact on memory safety.

E It converts Rust code into C code at compile time so you can link C libraries directly.

When writing embedded application code in Rust, where does the speaker recommend you should operate and why?

A Directly on the Peripheral Access Crate (PAC) because it provides the most portable, high-level API for application logic.

B At the highest possible level of abstraction (board crate / HAL / BSP) so the application is insulated from low-level details while still being efficient.

C Always write your own register manipulation code instead of using HALs to guarantee minimal memory usage.

D Only use the PAC in application code since HALs are discouraged for embedded Rust development.

E Mix PAC and HAL calls randomly to get both low-level control and high-level convenience in the same functions.

Which of these best describes the speaker's advice on how long and what is hardest when learning Rust for embedded work?

A You can become fluent in Rust for embedded systems in a few days because the language is small and simple.

B The borrow checker and ownership/borrowing concepts are one of the biggest challenges; expect to invest roughly three to six months to become effective.

C Unsafe code is the primary barrier; once you learn unsafe, everything else is trivial and takes a couple of weeks.

D Type-state programming is the only thing you must learn; ownership and lifetimes are nearly identical to C++ and require no extra time.

E Because Rust's compiler is permissive like C, you don't need much time to adapt; most effort is learning Cargo only.

M↓ MARKDOWN HELP

italics	surround text with asterisks
bold	surround text with two asterisks
hyperlink	[hyperlink](https://example.com) or just a bare URL
code	surround text with `backticks`
~~strikethrough~~	surround text with ~~two tilde characters~~
quote	prefix with >

Upvotes Newest Oldest

bjuberchaub

Score: 1 | 3 years ago | 1 reply

Very interesting and well presented. Could you post active links (live) to the resources?

RaulPando

Score: 0 | 3 years ago | no reply

Best to download the slides, the links are easily accessible that way.

GlebPlekhotko

Score: 0 | 4 years ago | no reply

Thank you for presentation!
I'm currently learning Rust and the list of references you've provided in the beginning of the video is very valuable. Introduction about HAL and board crates plus SVD files "importing" is very appreciates as well.
Though, for a person with a very shallow knowledge of the language, it's quite difficult to assess how useful are those advance features like "lifetimes" you've mentioned. A little practical example would be a fine thing to get an idea of what is that. Hope to see that next year.
Thank you again and good luck!

Login

Topic(s) Covered

About Steve Branam