Have you implemented a software model but find yourself uncertain about how to refine 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?
Experience the true power of Domain-Driven Design, dive deep into the complexities of Model-Driven Design and discover practical strategies beyond simple solutions to refine your Domain Model in Code.
Embark on a journey with an intensive workshop that immerses Java and C# developers in the transformative process of Eric Evans’s modeling whirlpool.
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 serves as a launchpad for practical, hands-on coding experiences, where acceptance criteria guide Test-Driven Development (TDD) exercises in both C# and Java.
This Deep Dive into Model-Driven Design Workshop will reveal practical strategies for ‘designing by coding‘, ensuring that code remains aligned with the changing domain model.
This workshop is not just an exploration but a deep dive into Part III of Evans’s groundbreaking work on Domain-Driven Design (DDD), specifically designed for those looking to advance beyond basic concepts like aggregates, entities, and value objects.
Learning Objectives
- Refining Software Models: Understand how you can include Design by coding in
- Refining a basic domain model to a complex, refined one that deeply resonates with the domain experts’ understanding.
- Supple Design Principles: Learn the principles of supple design and how they contribute to a more flexible and adaptive model.
- Deep Modeling: Accurately reflect the complex realities and rules of the domain in code
- Refactoring to deeper insights: Delve into the transformative concepts of chapter 13 from Eric Evans’s blue book, gaining insights that can be directly applied to your projects.
The Trainers
In this workshop you will be guided by Kenny Baas-Schwegler and Bruno Boucard.
Kenny Baas-Schwegler is a passionate practitioner and supporter of collaborative software design, believing that “every voice shapes the
software.” He has contributed to many books, such as Collaborative Software Design, Domain-Driven Design: The First 15 Years, Visual Collaboration Tools.
Bruno Boucard is a consultant at OCTO Technology, as well as a technical manager and software architect. He has extensive experience as an agile and technical coach, specializing in TDD, BDD, DDD, and refactoring legacy code.
Target Audience
The workshop is aimed at:
- Software Developers and Engineers with at least five years of experience
- Tech Leads
- Software or Solution Architects
- Engineering Managers.
The workshop’s language will be either Java or C#.
Topics
- 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.
Agenda
Module 1 – Software Design
- How do we tackle software design today?
- The true meaning of modelling, according to Eric Evans.
- Collaboration in the Model Exploration Whirlpool
- Introduction to our problem through an EventStorming outcome
- Refreshment of the Bounded Context pattern
Module 2 – Sketching and probing the early model
- 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
Module 3 – Supple design
- How the code can become rigid by 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
Module 4 – Deep modeling
- 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
Module 5 – Refactoring to deeper insights
- 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 modelling
- Complexity – when do we need all this?
How it works
The workshop will include a variety of activities, including coding (both solo, in pair or mob programming), discussions, group exercises and collaborative modeling using tools such as Miro and Zoom.
Coding is the main focus, guided by Test-Driven Development in Java or C#. While you have the option to code individually, we strongly recommend pair programming or ensemble programming to enhance the learning experience.
You’ll spend most of your time engaging with the domain, mainly through Design by Coding. You might occasionally return to the Miro digital whiteboard for insightful refactoring.
