Our material has moved!
Our training slides now live at https://github.com/ferrous-systems/rust-training.
Our training exercises now live at https://github.com/ferrous-systems/rust-exercises.
This repository will be archived to retain any external links.
This is free workshop material produced by Ferrous Systems for trainings. Get in touch for a custom quote. The time for the full course is around three to four days.
The material is created with people with zero Rust experience but with a programming background in mind.
Ferrous Systems offers a large Rust curriculum for both beginner and advanced Rust developers.
Ferrous Systems specialises in custom, topic focused workshops for enterprises starting or expanding their use of Rust. Supplemental to our courses, we offer ongoing help and feedback.
- Ferrous Teaching Material
- Overview
- Courses
- Topics
- Core topics
- Advanced Generic Programming in Rust
- Rust in C/C++ Environments
- Unsafe Rust
- Rust Testing
- Rust for Application Development
- Binary Size Optimisation
- Rust Speed Optimisation
- Rust for Networking
- Asynchronous and Concurrent Rust
- Cross Compilation
- Embedded Rust
- Embedded Rust using RTIC
- Writing Drivers for Embedded Rust
- Productive coding in Rust
- Rust and WebAssembly (WASM)
- Credits
- Commercial use
- License
The materials are presented as a set of small, self-contained lessons on a specific topic. Note that lessons might be revised, extended, or removed, when necessary to keep material up to date or relevant to new audiences. Lessons can be arranged into courses exploring various aspects of Rust.
See https://ferrous-systems.com/training for open courses or mail office@ferrous-systems.com for custom offers.
Ferrous Systems recommends a trainer per 6 attendees for full trainer bandwidth. If possible, we recommend opting for groups of at least 12, to efficiently allow for 2 trainers.
When selecting groups for training, we recommend that participants have a similar experience level in Rust, and similar goals for using the language when possible. We are experienced with training developers from a wide range of backgrounds and experience levels, and can design a training suitable for your team.
Ferrous Systems offers our training material under MIT/Apache-2.0 license for source code (examples and exercises) and Creative Commons (CC-BY-SA) for textual content.
Custom course material developed on request, including any provided examples or exercises, will be delivered directly to you as part of the training.
The Ferrous Systems training staff consists of multiple Rust project maintainers and domain experts, active in multiple working groups. This makes sure our trainers are always up to speed on new developments and can give current and authoritive answers.
Among those are:
-
Florian Gilcher: Training Rust since 2015. Over 30 trainings, most for large enterprises. Rust core team member and community team manager. Broad knowledge about all aspects of Rust, with special knowledge on network and async/concurrent programming.
-
Jonathan Pallant: Training Rust since 2018. Focus on Rust for Beginners, and Embedded Rust. Member of the Rust Embedded Working Group. Rust 'firsts' include running code on the nRF9160, TM4C123 and RP2040 MCUs.
-
Jonas Schievek: Training Rust since 2019. Focus on general Rust and multiple architectures. Contributor to the Rust compiler. Great knowledge of compilation details and performance concerns.
-
Tanks Transfeld: Training Rust since 2018. Focus on general Rust and Rust for beginners. Part of several Rust learning projects. All Rust subjects, from async to bare metal. Great knowledge around beginners concerns and how to get started.
Ferrous Systems can also collaborate with local trainers in Europe, US, Canada, South America, South Africa, and Oceania.
Ferrous Systems offers courses in many different settings.
Courses will be tailored to the clients needs during an interview before the event. This interview should happen as early as possible.
Specifically courses for companies in a transformation towards using Rust will be tailored to the companies core subjects.
Ferrous Systems builds its core course around a base course of three days. This course consists of introduction into shared Rust subjects plus application in one domain. Three days gives enough time to focus on this domain for at least one day, plus enough time to answer questions coming up from the audience.
After a three days course, attendees will have a solid knowledge in Rusts core concepts, especially Ownership and Borrowing. They will also have the core skills necessary for efficient self-guided learning.
Variations of the course, such as a shorter or a longer version are available.
A course that focuses more on an ecosystem overview over a detailed core subject. It may cover up to 4 topics.
Attendees may not become productive in all areas, but get a good feeling for them.
This course is perfect for engineering management that will most likely not end up using Rust daily, but needs broad knowledge to assess Rust as a technology. It is also frequently given in academic settings.
The longer versions covers similar subjects as above, but in more detail. This allows for exercises such as the construction of a larger piece of software in the training group collaboratively.
These courses are recommended for people that are intended to be multipliers in your organisation, teaching or leading other teams using Rust.
After 5 days, attendees will have solid knowledge in a topical domain and full productivity.
A condensed version of the three days course. Detailed topic deep dives will be reduced and some self-guided exercises reduced to "code along" sessions.
Advanced courses deepen a Rust subject and are indended for groups that have already attended a course previously. They quickly refresh core knowledge and then add a specific deep dive on topic. Advanced courses also differ from base courses in that they include a number facilitated discussions for attendees to share their experience.
Advanced courses are tailored like base courses to the need of the group. For example, an basic course for for asynchronous programming explains how concurrent execution in Rust works, while the advanced one may include writing your own execution engine.
Ferrous Systems offers Rust courses for a wide variety of subjects. The following is a non-exhaustive list of subjects.
Every subject with be taught with hands-on exercises.
This is the core component of the course. In this course, attendees will learn:
-
Ownership
-
Borrowing
-
Lifetimes
-
Working with memory and data structures
-
Control flow
-
Structuring of applications
-
Using and configuring cargo and rustup
-
Introducing Rust into existing products
-
General Rust patterns
-
Error Handling
-
Using Generic APIs
-
Using Rust’s guarantees as foundation for secure programming
-
Testing and Debugging
-
Documentation tooling
-
Basics of concurrency safety
-
Overview of important documentation
-
Overview the standard library, especially core interface like collections, input/output and networking
-
Overview of common libraries
-
"Refactoring towards Speed" a core technique to safely derive a fast program from a working program
Exercises will be tailored to the chosen special subjects.
Although the use of generics is taught in the core course, this section instead focuses on how, and when, to use them effectively. For developers of widely used libraries (internal or public), this material is particularly important.
In this module, attendees will learn:
-
Introduction into advanced programming with generics in Rust
-
Writing generic APIs
-
Impact on compile time, size and runtime speed
-
Useful generics patterns
-
Patterns to avoid
Rust is often deployed in existing products, especially within or among solutions written in C/C. This module explains binding efficiently from C/C to Rust and from Rust to C/C++ codebases.
In this module, attendees will learn:
-
Rusts FFI (Foreign Function Interface)
-
unsafe, as needed for FFI -
Safe binding, both manually and automatically
-
Binding strategies
-
Working with raw pointers and helping pointers
-
Costs of boundary crossing
-
Assessment of feasibility
Rusts unsafe feature is sometimes necessary for speed optimisations or
implementation of special data structures. This module explains its
position and use in the language.
In this module, attendees will learn:
-
The role of
unsafe -
The scope of
unsafe -
Do’s and Don’ts of unsafe Rust
-
Introduction into support APIs, like non-null pointers
-
Potential undefined behaviour arising from the use of
unsafe -
Checking unsafe Rust for safety
This module teaches advanced Rust testing techniques.
In this module, attendees will learn:
-
Fuzzing of Rust applications
-
Using property based testing
-
Rust in continous integration
-
Documentation testing
This module is meant for developers that mostly produce application layer code and work less on libraries. It focuses less on line-by-line details, but on system construction and usage of foreign code.
In this module, attendees will learn:
-
Useful libraries for many common usecases
-
How to evaluate a library
-
Componentising Rust projects
-
Error handling at large
-
Logging and tracing
This module is meant for developers working on systems with constraints on program size, such as switches or IoT gateways. It explains techniques to keep the binary size of Rust applications small.
In this module, attendees will learn:
-
Compiler options to optimise for size over aggressive optimisation
-
Programming techniques for smaller programs
-
Tools to further reduce the size of resulting binaries
This module is meant for developers working on systems with high speed demands. It explains techniques to test for performance and optimise for speed.
In this module, attendees will learn:
-
Tools to analyse speed and memory consumption
-
Programming techniques for faster programs
-
"Refactoring towards Speed": futher deepening for optimising working code bases
-
Optimising programs for specific resource usage needs
This module is meant for developers working on the networking layer. It combines well with the "Asynchronous and Concurrent Rust" module.
In this module, attendees will learn:
-
Rusts concurrency safety features
-
The Futures model
-
Rust async/.await programming
-
Available libraries and frameworks
-
Specifics of Rusts I/O libraries
This module is meant for developers interested in building highly concurrent systems. It combines well with the "Rust for Networking" module.
In this module, attendees will learn:
-
Rust threads vs. asynchronous tasks
-
Communication and sharing between concurrent units of a program
-
Effective memory safety features in concurrent applications
-
Available libraries and frameworks
This module is meant for developers targeting many different architectures.
In this module, attendees will learn:
-
Rust’s cross-compile toolchain
-
Dealing with target differences
-
Keeping programs portable
-
Configuring targets in cargo
-
(optional) Defining your own custom targets
-
(optional) cross-compiling mixed codebases
The optional targets are taught on client need.
This module is meant for developers interested in building bare metal systems such as microcontrollers. It includes the "Cross-Compilation" module, as far as it applies to microcontrollers.
In this module, attendees will learn:
-
Cross-compilation of Rust to embedded devices
-
Programming Rust without a standard library
-
Target specific libraries for microcontrollers
-
Rust embedded hardware abstraction layer ("embedded HAL")
-
Libraries for use in heapless environments
-
Managing memory mapped devices
This module is similar to "Embedded Rust", but uses the RTIC concurrency framework for teaching (previously known as "Real Time For The Masses").
This module extends the "Embedded Rust" or "Embedded Rust using RTIC" module.
In this module, attendees will learn:
-
How to build a driver
-
Proper modularisation
-
Testing
This module further teaches Rust working techniques, also with the support of IDEs.
In this module, attendees will learn:
-
Setting up rust-analyzer or CLion to their needs
-
General development workflows
-
Draft coding
-
Going from draft to stable software
-
"Refactoring towards speed"
-
-
Fast testing
-
Tools for reactive development workflows (such as
cargo watch)
WebAssembly (WASM) is a intermediate language optimised for fast evaluation in secure sandboxes. This module focuses on understanding the role of WebAssembly and its usage. It is taught on a platform relevant to the group.
In this module, attendees will learn:
-
What WASM is and what to use it for
-
Security properties of WASM and WASI
-
Common WASM implementations
-
Binding between a host language (usually JavaScript) and WASM
The development of this course is financed by Ferrous Systems.
They are open sourced as a contribution to the growth of the Rust language.
If you want to fund further development of the course, book a training!
This course is expressively intended for commercial and free use.