Rust Programming Crash Course
Rust is shaping to be the next (and current) big thing in system programming, but not just that. Its learning curve is steep, however, due to its memory and concurrency safety guarantees and its ownership model. This crash course will bring attendees to a good level of understanding and programming in Rust.
The Rust programming language promises to be safe, fast and productive. Created by Mozilla, Rust provides high level features while maintaining control and safety for low level code if required. Rust plays in the same playing field as C/C++ but is fit for any kind of software, from low-level system code to servers, clients and anything in between.
This course introduces the fundamentals of Rust, from the basics up to using types, modules, generics, pattern matching, error handling and more. Lab exercises are used to help sink in the theoretical concepts.
Objectives
- Understand the Rust language fundamentals
- Write idiomatic Rust code with structs, functions, traits, enums, and other fundamental Rust pieces
- Understand Rust ownership
- Use modules to organize code
Target Audience
Developers
Prerequisites
Good knowledge and experience with at least one programming language such as C++, C#, Java, Python, JavaScript, Kotlin, Visual Basic, …
Computer Setup
This workshop requires you to bring your own laptop with the following installed:
- Windows, Linux, or MacOS
- VS Code or RustRover installed
- Some PDF viewer
Syllabus
- Module 1: Introduction to Rust
- Why Rust?
- Hello, Rust!
- Tools
- The Rust compiler
- Cargo
- Summary
- Module 2: Language Fundamentals
- Variables
- Mutability
- Fundamental Data Types
- Tuples
- Arrays
- Functions
- Control Flow
- Summary
- Module 3: Ownership
- Why ownership?oReferences
- Borrowing
- Slices
- Summary
- Module 4: Compound Types
- Structs
- Creating Objects
- Traits
- Implementing traits
- Enums
- Pattern Matching
- Methods
- Summary
- Module 5: Common Types and Collections
- Strings
- Vectors
- Hash maps
- Summary
- Module 6: Managing Projects
- Packages and Crates
- Using crates.io
- Crates and Modules
- Visibility and Scope
- Modules and Files
- Testing
- Summary
- Module 7: Error Handling
- Types of Errors
- Panicking
- Using the Result type
- Propagating Errors
- When to panic
- Summary
- Module 8: Generics and Traits
- Generic Data Types
- Traits
- Implementing traits
- Common traits in the standard library
- Polymorphism with traits
- Summary
- Module 9: Smart Pointers
- The need for smart pointers
- The Box typeoRC and ARC
- Summary
- Module 10: Functional Programming
- The Iterator trait
- Closures
- The Function Types
- Summary
- Module 11: Threads and Concurrency (if time permits)
- Processes and Threads
- Creating Threads
- Threads and Ownership
- Thread Synchronization
- Summary
- Module 14: Advanced Topics (if time permits)
- Lifetimes
- Lifetime Annotations
- Lifetime Elision
- Macros basics
- Summary

Pavel Yosifovich is a renowned author, developer, and expert in Windows Internals, system programming, and software development. With extensive experience in low-level programming, he has authored several highly regarded books, including Windows Internals, Part 1 (7th Edition) and Windows 10 System Programming. His works provide deep insights into Windows architecture, kernel-mode development, and debugging techniques, making them essential resources for developers, security researchers, and IT professionals.
Beyond his books, Pavel is also known for his contributions to the developer community through training, blog posts, and technical talks. He offers in-depth courses on TrainSec, where students can learn Windows Internals, debugging, and system programming directly from his expertise. His writing style balances technical depth with clarity, making complex topics accessible to both beginners and experienced programmers. Whether delving into kernel drivers, Windows debugging, or modern programming languages, Pavel’s books and courses serve as authoritative guides for those looking to master Windows and programming.
