Rust – Unsafe Programming (RUST6)

Programming, Rust

Explore when to step beyond Rust's safety model and use unsafe correctly, how to interoperate with other languages, and how to build optimized data structures with clear trade-offs between safety and performance.

See when generics and safe Rust fall short and you must use unsafe code; learn to enforce invariants with runtime checks, design safe abstractions, and safely combine FFI and low-level concurrency for flexible systems work.

THIS TRAINING COURSE WILL HELP YOU:

  • Integrate Rust code with C and other languages
  • Write and reason about safe abstractions over unsafe code
  • Implement optimized, intrusive data structures
  • Use synchronization and partitioning for parallel access

WHO SHOULD ATTEND?

  • Systems programmers working in Rust
  • Library authors and API designers
  • Developers needing low-level performance
  • Experienced Rust devs learning unsafe patterns

COURSE LOCATION AND AVAILABLE DATES



Public courses are usually delivered in Czech, but this course is also available in English. We can arrange private training for your team online, at your premises or in our classrooms, and tailor the content to your needs.

For groups of around 4 or more participants, private training can already be comparable in price to booking individual places on a public course. Send us your requirements and we’ll recommend the best format and provide an exact quote.

Request training in English

Course content:

Hide details
  • Programming without restrictions
    1. Rust 2018/2021
    2. Bypassing static analysis
    3. Assuming responsibility
  • Responsibility model
    1. Borrow checker guarantees
    2. Runtime enforcement of guarantees
    3. Validating data-structure usage
  • Working with raw pointers
    1. Classic pointers
    2. Direct memory manipulation
    3. Safe interfaces
  • Unsafe functions and methods
    1. Standard library
    2. Custom unsafe functions
    3. External functions (FFI)
  • Intrusive data structures
    1. Systems programming
    2. Linked lists
    3. Trees and graphs
  • Synchronization tools
    1. Shared data
    2. Concurrent access
    3. Safe abstractions
  • Partitioning data structures
    1. Communication mechanisms
    2. Data partitioning
    3. Parallelizing access
Prerequisites:
Basic Rust knowledge and experience with systems programming.
Recommended previous course:
Rust – Design Patterns (RUST5)
Schedule:
3 days (9:00-17:00)
Price per person:
736.00 € ( 890.56 € incl. 21% VAT)

Training and learning environment