Learn Rust properly, from the toolchain and ownership to traits, concurrency, async and unsafe code. Pavel Yosifovich, co-author of Windows Internals and a systems developer with more than 25 years in C and C++, explains why Rust works the way it does, with labs and full solution walkthroughs after most modules.
17+ hours
on-demand video
Labs
with full solution walkthroughs
121
video lessons
4
downloadable resources
17 CPE
CEU credits, self-reported
Certification
Certificate of completion
Rust promises the speed and control of C and C++ without their most expensive bugs. Memory errors and data races are caught by the compiler, not discovered in production. That is why Rust is now used in operating systems, browsers, cloud infrastructure and security tools, and why more and more teams want developers who can write it well. The catch is the learning curve: ownership, borrowing and lifetimes feel strange at first, and many developers give up fighting the borrow checker.
In this course Pavel Yosifovich explains Rust from the ground up, always showing why the rules exist. You start with the toolchain and the language basics, then learn ownership and borrowing, the feature that most sets Rust apart. From there you model data with structs, enums, Option and Result, use the standard collections, organize projects with crates and modules, and handle errors without exceptions. The second half covers generics and traits, smart pointers, closures and iterators, threads and fearless concurrency, async programming with tokio, unsafe Rust with C and Windows interoperability, macros and lifetimes.
The course is a recording of a live class: 121 video lessons in 14 modules plus an introduction, with a slides PDF, a labs PDF and downloadable demo and lab code. Most modules end with labs and a full solution walkthrough on video, from a guessing game to Game of Life and a parallel Mandelbrot renderer. All videos have English captions, and you learn at your own pace with lifetime access.
Pavel has been writing systems software in C and C++ for more than 25 years, as a developer, consultant, trainer, author and speaker, and is a Microsoft MVP. He is the co-author of “Windows Internals, 7th Edition, Part 1” (Microsoft Press) and the author of “Windows Kernel Programming”, “Windows 10 System Programming” and “Windows Native API Programming”.
That background shapes this course: he explains Rust’s ownership, traits and concurrency model by showing which C and C++ problems they solve, and takes Rust all the way down to the Windows API and the native API.
Not the right fit if you have never programmed before, if you want C++ rather than Rust (take Modern C++ Programming), or if you want kernel or driver development (take Windows Kernel Programming 1).
Rust has topped developer surveys as the most admired language for years, and it is moving from enthusiasts into production: operating system components, cloud services, command line tools and security software. This course covers the whole language, from the first cargo new to procedural macros, so you can start at the beginning or jump to the modules you need.
Every module combines slides, live coding and explanation, and most end with labs and a full solution walkthrough. Rust is regularly compared to C++ throughout, which makes the course especially valuable if you come from C or C++, but developers from any language can follow it.
Rust gives you the performance and low-level control of C and C++, while the compiler guarantees memory safety and prevents data races. You get a modern toolchain out of the box: Cargo for building, testing and dependencies, Clippy for linting and rustfmt for formatting. The result is systems code that is fast, safe and maintainable, and a skill that more and more teams are hiring for.
The course does not stop at the safe subset. The unsafe Rust module shows raw pointers, calling C from Rust and Rust from C, and Windows system programming with the windows crate: a Win32 GUI window and a native API tool that lists Object Manager objects. If you want to go deeper into Windows itself, Windows System Programming 1 and Windows Native API Programming are the natural next steps.
Meet the course and its instructor: the logistics of the live class and a preview of the 14 modules, from the language fundamentals and ownership through generics, traits, concurrency, async, unsafe Rust, macros and lifetimes. The slides PDF, labs PDF, demo code and lab code are available here.
What Rust is and why it exists: a safe, fast systems language. You install and update the toolchain with rustup, find the documentation, write hello world with rustc and then with Cargo, and set up Clippy, rustfmt, an IDE with rust-analyzer and a debugger. The module also previews Rust’s built-in testing and ends with a setup lab.
The building blocks of the language: variables, immutability and shadowing, const and static, the scalar data types, literals and casting, tuples, arrays and operators. Then functions, control flow with if, loop, while and for, scope and the use keyword, attributes and derive, and pulling in external crates from crates.io. It ends with a lab solutions walkthrough, including a guessing game.
The feature that most sets Rust apart. You learn single ownership, move versus copy, the Copy and Clone traits, and how String and Vec are laid out on the stack and the heap. Then references and the borrowing rules, why dangling references cannot happen, and slices of strings, arrays and vectors. The module ends with labs on primes and slices and a full solutions walkthrough.
Modeling data in Rust. The module covers structs and tuple structs, printing them with Debug, methods and the different forms of self, and associated functions in place of constructors. Then enums that carry data, the Option and Result types, and pattern matching with match, if let and while let. It also covers file and path I/O, and ends with labs on structs, methods and a turtle graphics command enum.
The standard collections and how to use them well. Vec as the default dynamic array, with capacity, indexing and iteration; String as UTF-8 text and why you cannot index characters; and HashMap with the entry API and custom keys. It also surveys VecDeque, HashSet, BTreeMap, BinaryHeap and the other collections. The labs walkthrough builds Game of Life, a Mandelbrot PNG renderer, a word counter and an RPN calculator.
Organizing real Rust code. The module explains packages, binary and library crates, the Cargo directory conventions, and the module system with mod, super, crate and self paths. It teaches visibility, the use keyword with aliases and re-exports, external dependencies from Git or local paths, and build scripts, and ends with a lab that moves the turtle graphics code into a library.
Rust’s approach to errors without exceptions: panics for unrecoverable errors and Result for recoverable ones. You learn panics and backtraces, matching on Result, unwrap and expect, propagating errors with the ? operator, returning Result from main, Box<dyn Error> for mixed error types, and module-specific Result aliases such as io::Result.
Writing reusable code. The module covers generic functions, structs, enums and methods, and how monomorphization works. It then teaches traits in depth: defining and implementing them, generic traits, associated types, the common standard traits, the orphan rule, trait bounds, and polymorphism with impl Trait and trait objects. The labs build a generic Stack, a Queue, an RPN calculator and a Shape hierarchy.
Heap allocation and shared ownership done safely. You learn what makes a smart pointer, Box for heap allocation, recursive types and trait objects, writing your own Deref type, and the Drop trait for cleanup. Then Rc and Arc reference counting with Weak to break cycles, and interior mutability with Cell and RefCell.
Functional-style Rust. The module covers anonymous functions and the Fn, FnMut and FnOnce traits, storing functions in structs, and closures with their capture rules and the move keyword. The second half covers iterators: the Iterator trait and lazy evaluation, adapters such as map, filter, take, skip, enumerate and collect, and implementing your own iterators.
Fearless concurrency: data races are caught at compile time. You create threads, pass data to them and collect results, use the fork-join pattern and parallelize work with the rayon crate. Then message passing with channels and crossbeam, atomics, Mutex, RwLock, Condvar, Barrier and Once, and the Send and Sync traits that make it all safe. The lab parallelizes the Mandelbrot renderer by hand and with rayon.
Asynchronous programming for scalable servers. The module explains synchronous versus asynchronous I/O, compares a classic TCP echo server with a tokio version, and introduces async functions, futures and polling. It then covers the tokio runtime: spawning tasks, sleeping, join, try_join and select, and async I/O with tokio::io.
When and how to leave safe Rust. You learn what unsafe allows and what it does not, raw pointers, and interoperability with C in both directions, including exporting a function from a DLL. Then Windows system programming with the windows crate: a Win32 GUI window with GDI drawing and a native API tool that lists Object Manager objects. It ends with a survey of GUI libraries for Rust.
Extending the language and mastering lifetimes. The module shows how macros work, writes declarative macros with macro_rules!, and builds the three kinds of procedural macros with syn and quote. It closes with lifetime annotations, the static lifetime and the elision rules, followed by the course wrap-up.
No. The course starts with installing the toolchain and the language basics and builds up from there. You do need programming experience in some language, because the fundamentals modules move quickly.
No. Pavel often compares Rust to C++ (templates, vectors, unique_ptr and shared_ptr), so a C++ background helps, but developers coming from C#, Java, Python or similar languages can follow the course. Some C and Windows API familiarity helps in the unsafe Rust module.
No. Most of the course is plain Rust that runs on any platform. The unsafe Rust module is the exception: its demos use the Windows API, so you need Windows to run those yourself.
The Rust toolchain via rustup, plus an editor. The course uses Visual Studio Code with rust-analyzer, Clippy and rustfmt, and shows how to set up debugging. Everything else is crates pulled in by Cargo, such as rand, serde, crossbeam, rayon and tokio.
Yes. Most modules end with labs and a full solution walkthrough on video. Projects include a guessing game, turtle graphics, Game of Life, a Mandelbrot PNG renderer later parallelized with rayon, a word counter, an RPN calculator, and generic data structures. The demo and lab code are downloadable.
Yes. A full module covers async and await with tokio: futures, the tokio runtime, spawning tasks, join and select, and async I/O, built around a TCP echo server example.
No. The course covers the language, the standard library, concurrency, async with tokio, unsafe Rust and macros. GUI library options are surveyed briefly but not taught.
They are parallel courses with the same instructor and comparable depth. Choose Rust for compile-time memory and thread safety and a modern toolchain. Choose Modern C++ Programming if you work with C++ code or plan to take TrainSec’s Windows programming courses, which are taught in C and C++.
Recorded and self-paced. It is a recording of a live class, with lifetime access, and every video has English captions.
Yes. When you complete every lesson you receive a certificate of completion and a Credly digital badge. The course also earns 17 CPE/CEU credits, which you self-report to your certification body using your certificate.
Yes. Two lessons are free to preview: Course Introduction and What is Rust. Watch them on the course page.
There are 121 video lessons, about 18 hours of video. With the labs, plan on considerably more than the video time, typically several weeks of part time study.
Lifetime access on the TrainSec learning platform. Videos stream in the browser at 1080p and cannot be downloaded.
$690 as a single payment, or 5 monthly payments of $140 ($700 in total).
Yes. Refunds are available up to 14 days after purchase, to the original payment method. Email [email protected].
Pavel has been writing systems software in C and C++ for more than 25 years, as a developer, consultant, trainer, author and speaker, and is a Microsoft MVP. He is the co-author of “Windows Internals, 7th Edition, Part 1” (Microsoft Press) and the author of “Windows Kernel Programming”, “Windows 10 System Programming” and “Windows Native API Programming”.
That background shapes this course: he explains Rust’s ownership, traits and concurrency model by showing which C and C++ problems they solve, and takes Rust all the way down to the Windows API and the native API.
Learn Rust properly, from the toolchain and ownership to traits, concurrency, async and unsafe code. Pavel Yosifovich, co-author of Windows Internals and a systems developer with more than 25 years in C and C++, explains why Rust works the way it does, with labs and full solution walkthroughs after most modules.
