Abstract
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 and the intricate complexities of your domain, as well as 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 modelling 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), specifically designed for those looking to advance beyond basic concepts like aggregates, entities, and value objects.
Target Audience
The workshop’s language will be either Java or C#, and it is aimed at Software Developers & Engineers with at least five years of experience.
- Tech Leads
- Software or Solution Architects
- Engineering Managers
- Staff engineers.
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 – Refining the domain model through the coding process rather than being extensively planned upfront.
Program
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 not only captures the actual intricacies of your domain but also 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 serves as 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 modelling 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.
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?
Learning Objectives – What are we gonna learn?
- 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.
Expect to get your hands dirty – 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 modelling using tools such as Miro.
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.
We’ll kick off with a check-in, creating a space to get to know each other and our needs. Then, we’ll smoothly transition into an impromptu networking session, focusing on understanding how you currently design software and the challenges you face. This initial phase is crucial in setting the right expectations and providing a comprehensive introduction to modelling for our journey.
Next, we’ll introduce you to the “Model Exploration Whirlpool.” This framework will be central to the exercises during this workshop. You’ll find yourself deeply involved in multiple iterations of this whirlpool exercise, working alongside 2-3 peers in break-out rooms.
Most of your time will be spent engaging with the domain, mainly through Design by Coding. You might occasionally step back to the Miro digital whiteboard for some insightful refactoring.
Our methodology is designed to keep theoretical and conceptual lectures brief, giving precedence to hands-on practice. We’re convinced that the real benefits of supple design and deep modelling are best understood through direct experience.
There will be plenty of opportunities for dialogue and debate, creating a dynamic environment for uncovering emerging practices. These conversations will be vital in helping you identify the most suitable practices and patterns for your professional endeavours.
Why should you buy a ticket?
Experience the true power of Domain-Driven Design and go beyond using the basic tactical patterns.
These emerging practices will guide you in continuously refactoring your code build for complex domains, ensuring it remains supple and deeply aligned with the evolving insights you gain from conversations with your domain experts.
This approach allows you to dedicate more cognitive resources to comprehending and addressing the core needs of your stakeholders and users, rather than spending excessive time on translating requirements into your code.
This shift in focus not only enhances your understanding but also paves the way for groundbreaking developments in the products you’re developing software for.
The workshop will keep its highly interactive and hands-on spirit despite being online.
This is why we require all participants to keep their webcams on for the duration of the workshop: this will enhance the quality of the communication and the workshop as a whole.
You won’t be sitting at your desk watching slides and videos; instead, you’ll be engaged in real-time activities for the majority of the time… as if we were in a real classroom!
