Rust has rapidly grown into one of the most influential modern programming languages. It combines the performance of C/C++ with a unique memory and type system that prevents errors before the program even runs. Participants are introduced to the language, learn to understand its core concepts, and discover how Rust is applied across diverse domains: from systems programming and web backends to embedded software and game development.

• Understand the foundations of Rust: declare and use variables, constants, and types; apply control flow and functions effectively.
• Apply Rust’s ownership and borrowing model to write memory-safe code without garbage collection.
• Design and implement data structures using structs, enums, and generics.
• Use traits and trait bounds to express polymorphism and abstraction in Rust.
• Organize codebases with modules and crates, and apply unit and integration testing for quality assurance.
• Handle errors safely and idiomatically using `Result`, `Option`, and custom error types.
• Work with core standard library features such as strings, collections, and I/O (console, files, and networking).
• Develop idiomatic Rust code using closures, iterators, and functional programming techniques.
• Leverage smart pointers and reference types (`Box`, `Rc`, `Arc`, `RefCell`, etc.) to manage memory and data sharing.
• Build concurrent applications with threads, channels, and synchronization primitives.
• Apply lifetime annotations to ensure safe references across functions and data structures.
• Understand and use unsafe Rust features responsibly to extend capabilities while maintaining safety through abstractions.
• Develop practical Rust projects that consolidate theory into applied coding experience.

• Introduction: mindset of Rust, safety + performance
• Variables, constants, and types (scalars, tuples, arrays)
• Expressions, control flow, and functions
• Core concept: ownership, stack vs. heap, borrowing, compiler guarantees
• Structs and enums (with generics)
• Traits: basics, trait bounds, trait objects
• Advanced trait features (associated types, operator overloading)
• Modules and crates: organizing projects, using Cargo
• Testing: unit + integration testing
• Error handling: `Result`, `Option`, custom error types
• Strings: Unicode, slices, parsing, formatting, performance
• Collections: Vec, HashMap, BTreeMap, Sets, BinaryHeap
• Projects: *Math Quiz*, *Hangman*, *To-Do List*, *User Registration System*
• Functional programming in Rust: closures, iterators, FP techniques
• Smart pointers: Box, Rc, Arc, RefCell, interior mutability
• Concurrency: threads, channels, synchronization primitives
• Lifetimes: functions, structs, best practices
• Unsafe Rust: when and why, safe abstractions

Live instructor-led training, with plenty of opportunities for hands-on exercises and discussion.

Delivered as a live, interactive training: available in-person or online, or in a hybrid format. Training can be implemented in English or Dutch.

Basic knowledge of programming (variables, functions, data structures) is required. Experience with another language such as C, C++, Python, or Java is recommended but not strictly necessary.

Software developers, systems programmers, and engineers who want to get started with Rust or apply the language in their daily work. Also suitable for developers experienced in languages such as C, C++, Java, or Python who are looking for safer and higher-performance programming.