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.
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.
Taster sessions that favor experiences over solid knowledge and get people excited.
Perfect for conferences and internal all-hands to expand people’s horizons.
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.