Rust Advanced ( rustadv | 14 hours )

• Proficiency in Rust Fundamentals or equivalent experience
• Experience with systems-level programming
• Intermediate-level programming experience

Audience

• Developers

Rust is a modern systems-level programming language known for its memory safety, concurrency, and performance. Rust Advanced is a comprehensive instructor-led training that delves deeper into advanced topics and techniques in Rust programming. 

This instructor-led, live training (online or onsite) is aimed at intermediate to advanced-level Rust developers who have a solid understanding of Rust fundamentals and wish to enhance their expertise in the language.

By the end of this training, participants will be able to:

• Understand advanced topics and techniques in Rust programming.
• Master advanced ownership, asynchronous programming, and traits/generics.
• Gain proficiency in advanced error handling, macros, and performance optimization.
• Interface with other languages, leverage unsafe Rust, and implement advanced concurrency.
• Apply advanced troubleshooting techniques to debug and resolve complex issues in Rust programs.

Format of the Course

• Interactive lecture and discussion.
• Lots of exercises and practice.
• Hands-on implementation in a live-lab environment.

Course Customization Options

• To request a customized training for this course, please contact us to arrange.

Advanced Ownership

• Understanding lifetimes and borrowing
• Exploring smart pointers: Box, Rc, and Arc
• Working with reference cycles using Weak and Unsync
• Advanced ownership patterns and techniques

Asynchronous Programming with Async/Await

• Introduction to asynchronous programming in Rust
• Working with async/await syntax
• Composing futures and working with async libraries
• Exploring the async ecosystem and libraries

Traits and Generics

• Advanced trait usage and associated types
• Implementing generic functions, structs, and enums
• Bounds and trait objects
• Exploring trait coherence and orphan rules

Advanced Error Handling

• Creating custom error types
• Advanced error handling techniques: try!, ? operator, custom error chains
• Error handling strategies and patterns

Macros

• Procedural macros: attribute and function-like macros
• Declarative macros: macro_rules! and the match-like syntax
• Advanced macro usage and metaprogramming

Performance Optimization

• Profiling and benchmarking Rust code
• Identifying performance bottlenecks
• Optimization techniques: data structures, algorithms, and compiler flags
• Writing high-performance Rust code

FFI (Foreign Function Interface)

• Interfacing Rust with C/C++ code
• Exposing Rust APIs to other languages
• Handling data types and memory management in FFI

Unsafe Rust

• Understanding unsafe blocks and unsafe functions
• Working with raw pointers and mutable aliasing
• Safe abstractions around unsafe code

Advanced Concurrency

• Advanced synchronization primitives: Mutex, RwLock, and Condvar
• Implementing lock-free and wait-free data structures
• Channels and message passing
• Exploring advanced concurrency patterns

Web Development with Rust

• Overview of web development in Rust
• Exploring Rust web frameworks: Rocket, Actix, Warp, etc.
• Interacting with databases
• Deployment options and considerations

Advanced Troubleshooting

• Advanced techniques for debugging and resolving complex issues in Rust programs
• Profiling and optimizing performance in real-world scenarios
• Strategies for handling edge cases and unusual behavior

Summary and Next Steps