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



This course is not scheduled as a public course.
It is delivered exclusively as customised training. The content, duration, date, and delivery format are tailored to the customer's requirements and can also be provided in English.

Request customised training

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