Refining Domain Models in Code
Have you implemented a software model but need help refining it effectively with new business constraints? Are you grappling with an initial domain model that, amidst changing business landscapes, seems more like an impediment than a help? Do you notice a growing disconnect between your code, the intricate complexities of your domain, and the core domain concepts?
Embark on a journey with ‘Deep Dive into Model-Driven Design: Refining Domain Models in Code,’ an intensive workshop that immerses Java and C# developers in the transformative process of Eric Evans’s modeling whirlpool. This workshop is not just an exploration but a deep dive into Part III of Evans’s groundbreaking work on Domain-Driven Design (DDD). It is specifically designed for those looking to advance beyond basic concepts like aggregates, entities, and value objects.
The workshop’s language will be Java or C#. It is aimed at Software Developers and engineers with at least five years of experience.
- Software or Solution Architects
- Engineering Managers
- Staff engineers
- Supple Design – Creating a flexible, cohesive, and easily maintainable domain model in code.
- Deep Modeling – Accurately reflecting the complex realities and rules of the domain in code.
- Refactoring toward deeper insight – Continuously improving and evolving the domain model
- Design by coding – Refine the domain model through the coding process rather than having it extensively planned upfront.
Dive deep into the complexities of Model-Driven Design and discover practical strategies beyond simple solutions to refine your Domain Model in Code. This approach guides you in developing a resilient, supple design that captures the actual intricacies of your domain and catalyzes significant breakthroughs in product development.
Recognizing that many projects begin with simplistic models, which become limiting as complexity grows, this workshop starts with a Bounded Context derived from an EventStorming exercise. Participants will use Example Mapping and CRC-cards sessions to formalize acceptance criteria, sketching a ‘naive’ domain model for our defined bounded context. This is a launchpad for practical, hands-on coding experiences, where acceptance criteria guide Test-Driven Development (TDD) exercises in both C# and Java.
Participants will demystify the concepts of supple design and deep modeling through iterative refinement with new, unexpected requirements. The workshop will reveal practical strategies for ‘designing by coding, ‘ensuring that code remains aligned with the changing domain model. Attendees will learn to harness the full potential of Domain-Driven Design and Model-Driven Design, develop the skills to become domain experts as developers and start unlocking critical breakthroughs in product development.
- How do we tackle software design today?
- The true meaning of modeling, according to Eric Evans.
- Collaboration in the Model Exploration Whirlpool
- Introduction to our problem through an EventStorming outcome
- Refreshment of the Bounded Context pattern
- Lab 1 – Discovering acceptance criteria through Example Mapping
- Lab 2 – Sketching our early model with CRC-Cards
- Emerging tactical patterns of the model
- Lab 3 – Code probe the naive model through Outside-in TDD
- How the code can become rigid to unexpected requirements
- Lab 4 – Introducing new requirements we did not account for
- Supple Design – Creating a flexible, cohesive, and easily maintainable domain model in code
- How the code can be left behind from the domain model
- Lab 5 – Introducing more complex business rules in the code
- Deep Modeling – Accurately reflecting the complex realities and rules of the domain in code
- Refactoring toward deeper insight – Continuously improving and evolving the domain model
- When to collaborate with domain experts
- Lab 6 – Prototype and Design by Coding through advanced deep modeling
- Complexity – when do we need all this?
Kenny Baas-Schwegler believes in collaborative software design where ‘every voice shapes the software.’ Leveraging a domain-driven design approach, Kenny facilitates more transparent communication between stakeholders and software creators by collaborative modeling and deep democracy, decoding complexities, resolving conflicts, and ensuring software remains agile to business demands.
As an independent software consultant, tech lead, and software architect, Kenny catalyzes organizations and teams to design and build sustainable and resilient software architectures.
Bruno Boucard is an Agile and technical coach and speaker who specializes in collaborative modeling within organizations. His expertise extends to the tactical side, focusing on transforming complex problems into clear, code-based solutions.
Consultant, trainer, and speaker for OCTO Technology. He is the leader of the BDD Paris & Play Agile user group. A long-time Microsoft MVP, he still codes Java, Python, and C++ with an occasional emphasis on C#.
He started coding on a TRS 80 machine in the 1980s and loves explaining things with concrete examples and, if necessary, live coding. He is the leader of the BDD Paris & Play Agile user group.
A long-time Microsoft MVP, he still codes Java, Python, and C++, occasionally emphasizing C#.