Using Rust for Secure Embedded Development
What is Rust?
Rust is an excellent modern programming language for embedded systems design. It allows for the same precision as C language, while also providing high-level abstractions and safety against the memory allocation issues that typically scourge old languages. Programs written in Rust are more dependable with the productivity rate easily comparable with that of Python.
In a StackOverflow survey (2021) targeted for developers, Rust was the most popular programming language for the sixth year in a row. According to the study, 87% of Rust users are not willing to shift away from Rust.
Why use Rust on Embedded Development?
While offering reliability and efficiency, Rust also provides a blazingly fast speed and excellent memory utilization, making it an excellent choice for performance-critical services running on embedded devices.
Rust is a statically typed language designed keeping security and high performance in mind. It’s especially suitable for safe concurrency and memory management, addressing the common problems related to memory errors and concurrent programming.
It is also a low-level programming language, enabling a direct access to hardware and memory. This makes it very attractive language for developing embedded applications.
Increasingly growing amount of Linux kernel code lines is written in Rust. The language also integrates easily with other languages.
This course provides embedded developers with an introduction to Rust, equipping them with basic level understanding of what is required in order to write Rust code on embedded targets.
The course provides the participants with the necessary background concepts and programming techniques enabled by Rust, enabling effective software development in their own projects.
The course contains hands-on exercises on an embedded target assisted by the course trainer.
Course Material and Literature
To be announced later.
– Rust now – where is it used?
– Philosophy of Rust
– VSCode / IntelliJ IDEA
Rust language fundamentals
– Basic structure
– Rust data primitives
– Compound data types
– Condition and repetition
– Error handling
– Not Nul but Option
Rust memory handling
-Memory structures: static, stack, heap
-&str vs. String
– cargo test
– cargo bench
Compilation parameters, #!
Basic data types, bit operations
– cargo doc
Choosing target architectures
– How to build a program with a minimal runtime?
– Programming with core-libs only (not std) without heap
– FFI interface with C programs
Wrap-up & Summary