Tactical Software Architecture

Domain-Driven Design – Motivation

​​Domain-Driven Design is a family of software and architecture patterns and best practices. It is also a process that aligns the code with the reality of the problem domain and keeps developers and domain experts working together. It has proven to be really helpful when you want to write maintainable software for a problem space that has a certain complexity. So if you need to build software that is strategically relevant for your business – and that is likely to change and evolve over time – you should be familiar with the ideas and building blocks of Domain-Driven Design.
​​ 
​​A software that is modeled close to the real problem domain is much easier to grow and adapt with it: In fact, the difficulty in adding new features remains constant and relatively small. And if the solution is properly broken apart along bounded context lines, it is easy to extract parts of it into microservices for example.
​​ 
​​Domain-Driven Design goes hand in hand with “Clean Code” and Hexagonal Architectures and in your hands-on trainings we integrate these approaches and tell from the experience we have from real project implementations. Furthermore, DDD increases security (security by design) and testability of your software a lot.

Training goals and concepts

The training starts with a reflection on common challenges in software development and where DDD practices are appropriate to address these challenges.

Then we give an overview of tactical DDD building blocks and patterns and provide practical implementation knowledge. In order for you to be able to follow the training well, we use a sample domain, which we follow step by step and discuss practical code examples (in Golang).

After the training you are prepared to:

• Reflect where and why to apply DDD practices
• Recognize and start using the basic DDD building blocks
• Implement applications with clean layering and know some best practices
• Discuss the relation between namespaces, modules, aggregates and bounded contexts
• Be aware of typical smells

1. Introduction to DDD

• Motivation and Context. Clarification of terms.
• When to use DDD and when not?
• Whats the focus of “Strategic DDD” and “Tactical DDD Patterns”. What are Bounded Contexts?
• What is a potent “Domain Model“? What are representations and artefacts?

2. Introducing the example domain "Hackerando"

3. Application Architecture: Benefits of a “technology free domain model”, separation of concerns and typical layerings, concept of "ports and adapters" and hexagonal architecture

4. Tactical Patterns Overview and Building Blocks

• Overview of Building Blocks and Design Pattern
• Value Objects in Detail
• Entities in detail
• Domain Services in Detail

5. Design Patterns

• Modeling the Domain
• General Principles and Goals
• Aggregates, Aggregate Roots and Invariants
• Repositories
• Repository Implementation Examples
• Factories and Reconstitution
• Lifecycle Overview 
• Domain Events
• References and why to reduce them

6. Implementing DDD

• Bounded Context, Modules, Namespaces.. How do they relate?
• How can an application with modules be structured? 
• Typical DDD Smells

• Duration: 4 hours
• Language: English or German, depending on preference
• Location: Online
• Group size: from 5 to 10 participants