Rust – Design Patterns (RUST5)

Programming, Rust

In this course you will examine software design in Rust, which lacks data inheritance but offers traits to express abstraction and both static and dynamic polymorphism. You will map familiar object-oriented patterns to idiomatic Rust and test Rust-specific alternatives with examples.

Practice common creational, structural and behavioral patterns while using Rust features: composition, smart pointers, and generics. Learn when to prefer composition over inheritance, how to manage dependencies, and how to design clear, maintainable and extensible Rust libraries.

THIS TRAINING COURSE WILL HELP YOU:

  • Apply common design patterns in idiomatic Rust
  • Choose patterns using traits, generics, and ownership
  • Design maintainable, extensible Rust architectures
  • Refactor OO ideas into Rust-friendly solutions

WHO SHOULD ATTEND?

  • Experienced Rust developers wanting better design skills
  • Developers familiar with OO concepts like C++ or Java
  • Library authors and system architects using Rust

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
  • Program architecture
    1. Object-oriented design
    2. Established design patterns
    3. Dependencies between objects
  • Design principles
    1. SOLID and object design
    2. Understandable and maintainable software
    3. Seamless extensibility
  • Basic tools
    1. Composition and smart pointers
    2. Dynamic polymorphism
    3. Generic programming
  • Creational patterns
    1. Factory
    2. Builder
    3. Singleton
    4. Prototype
  • Structural patterns
    1. Bridge
    2. Facade
    3. Adapter
    4. Decorator
    5. Proxy
  • Behavioral patterns
    1. Chain of responsibility
    2. Command
    3. Iterator
    4. Generator
    5. Mediator
    6. Observer
    7. Visitor
    8. Template method
  • General recommendations
    1. Choosing from known patterns
    2. Finding your own patterns
    3. Using language features
    4. Stability of library interfaces
Prerequisites:
Basic knowledge of Rust and familiarity with object-oriented concepts.
Recommended previous course:
Rust – Parallel Programming (RUST4)
Recommended follow-up course:
Rust – Unsafe Programming (RUST6)
Schedule:
3 days (9:00-17:00)
Price per person:
736.00 € ( 890.56 € incl. 21% VAT)

Training and learning environment