Course Structure
This page is for the course instructor.
Rust Fundamentals
The first four days make up Rust Fundamentals. The days are fast-paced and we cover a lot of ground!
Course schedule:
- Day 1 Morning (2 hours and 10 minutes, including breaks)
| Segment | Duration |
|---|---|
| Welcome | 5 minutes |
| Hello, World | 15 minutes |
| Types and Values | 40 minutes |
| Control Flow Basics | 45 minutes |
- Day 1 Afternoon (2 hours and 45 minutes, including breaks)
| Segment | Duration |
|---|---|
| Tuples and Arrays | 35 minutes |
| References | 55 minutes |
| User-Defined Types | 1 hour |
- Day 2 Morning (2 hours and 50 minutes, including breaks)
| Segment | Duration |
|---|---|
| Welcome | 3 minutes |
| Pattern Matching | 50 minutes |
| Methods and Traits | 45 minutes |
| Generics | 50 minutes |
- Day 2 Afternoon (2 hours and 50 minutes, including breaks)
| Segment | Duration |
|---|---|
| Closures | 30 minutes |
| Standard Library Types | 1 hour |
| Standard Library Traits | 1 hour |
- Day 3 Morning (2 hours and 20 minutes, including breaks)
| Segment | Duration |
|---|---|
| Welcome | 3 minutes |
| Memory Management | 1 hour |
| Smart Pointers | 55 minutes |
- Day 3 Afternoon (2 hours and 10 minutes, including breaks)
| Segment | Duration |
|---|---|
| Borrowing | 55 minutes |
| Lifetimes | 1 hour and 5 minutes |
- Day 4 Morning (2 hours and 50 minutes, including breaks)
| Segment | Duration |
|---|---|
| Welcome | 3 minutes |
| Iterators | 55 minutes |
| Modules | 45 minutes |
| Testing | 45 minutes |
- Day 4 Afternoon (2 hours and 20 minutes, including breaks)
| Segment | Duration |
|---|---|
| Error Handling | 55 minutes |
| Unsafe Rust | 1 hour and 15 minutes |
Deep Dives
In addition to the 4-day class on Rust Fundamentals, we cover some more specialized topics:
Rust in Android
The Rust in Android deep dive is a half-day course on using Rust for Android platform development. This includes interoperability with C, C++, and Java.
You will need an AOSP checkout. Make a checkout of the
course repository on the same machine and move the src/android/ directory
into the root of your AOSP checkout. This will ensure that the Android build
system sees the Android.bp files in src/android/.
Ensure that adb sync works with your emulator or real device and pre-build all
Android examples using src/android/build_all.sh. Read the script to see the
commands it runs and make sure they work when you run them by hand.
Rust in Chromium
The Rust in Chromium deep dive is a half-day course on using
Rust as part of the Chromium browser. It includes using Rust in Chromium’s gn
build system, bringing in third-party libraries (“crates”) and C++
interoperability.
You will need to be able to build Chromium — a debug, component build is recommended for speed but any build will work. Ensure that you can run the Chromium browser that you’ve built.
Bare-Metal Rust
The Bare-Metal Rust deep dive is a full day class on using Rust for bare-metal (embedded) development. Both microcontrollers and application processors are covered.
For the microcontroller part, you will need to buy the BBC micro:bit v2 development board ahead of time. Everybody will need to install a number of packages as described on the welcome page.
Concurrency in Rust
The Concurrency in Rust deep dive is a full day
class on classical as well as async/await concurrency.
You will need a fresh crate set up and the dependencies downloaded and ready to
go. You can then copy/paste the examples into src/main.rs to experiment with
them:
cargo init concurrency
cd concurrency
cargo add tokio --features full
cargo run
Course schedule:
- Morning (3 hours and 20 minutes, including breaks)
| Segment | Duration |
|---|---|
| Threads | 30 minutes |
| Channels | 20 minutes |
| Send and Sync | 15 minutes |
| Shared State | 30 minutes |
| Exercises | 1 hour and 10 minutes |
- Afternoon (3 hours and 30 minutes, including breaks)
| Segment | Duration |
|---|---|
| Async Basics | 40 minutes |
| Channels and Control Flow | 20 minutes |
| Pitfalls | 55 minutes |
| Exercises | 1 hour and 10 minutes |
Idiomatic Rust
The Idiomatic Rust deep dive is a 2-day class on Rust idioms and patterns.
You should be familiar with the material in Rust Fundamentals before starting this course.
Course schedule:
- Morning (3 hours and 35 minutes, including breaks)
| Segment | Duration |
|---|---|
| Leveraging the Type System | 3 hours and 35 minutes |
Unsafe (Work in Progress)
The Unsafe deep dive is a two-day class on the
unsafe Rust language. It covers the fundamentals of Rust’s safety guarantees,
the motivation for unsafe, review process for unsafe code, FFI basics, and
building data structures that the borrow checker would normally reject.
Course schedule:
- Day 1 Morning (1 hour, including breaks)
| Segment | Duration |
|---|---|
| Setup | 2 minutes |
| Motivations | 20 minutes |
| Foundations | 25 minutes |
Format
The course is meant to be very interactive and we recommend letting the questions drive the exploration of Rust!