Rust — Systems and Safe Programming

Those two existing courses are narrower, standalone courses focused on systems security and systems-programming basics in Rust, respectively. This course is a five-day, end-to-end workshop that combines, in one path, four areas developed separately elsewhere: the ownership/borrow-checker model, asynchronous programming with Tokio, deliberate use of unsafe Rust and FFI for C/C++ integration, and complete production tooling (cargo, tests, CI/CD). It is a full course from fundamentals to production readiness, not a deep dive into a single thread.

It is not a formal requirement, but experience with a low-level language significantly helps with understanding Rust's memory model and the FFI module, where Rust communicates with existing C code. Participants without such experience should expect a slower pace in the first two days of the workshop.

Unsafe Rust is needed where the compiler cannot verify the safety of an operation even though the programmer knows it is correct — for example, working with raw pointers, FFI calls to C, or implementing low-level data structures. The course teaches not just unsafe syntax but, more importantly, the pattern of safely wrapping such code in safe abstractions so the rest of the application still benefits from Rust's guarantees.

Rust eliminates an entire class of memory bugs (use-after-free, buffer overflow, data race) at compile time, without the performance cost of a garbage collector — hence its adoption in the Linux kernel, the Android OS, Windows components (Microsoft), and AWS infrastructure, where memory safety and performance are both critical simultaneously. The course shows how to apply those same guarantees in your own projects.