Abstract
Have you implemented a software model but find yourself uncertain about how to refine it with new business constraints effectively? 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 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), 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’s 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 reflect 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 in advance.
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 true intricacies of your domain but also catalyzes significant breakthroughs in product development.
Recognizing that many projects begin with simplistic models which later become limiting as complexity grows, this workshop starts with a Bounded Context derived from an EventStorming exercise.
Participants will engage in 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.
Through iterative refinement with new, unexpected requirements, participants will demystify the concepts of supple design and deep modeling. The workshop reveals practical strategies for ‘designing by coding,’ ensuring that code remains in alignment with the changing domain model.
Attendees will not only learn to harness the full potential of Domain-Driven Design and Model-Driven Design but also develop the skills to become domain experts as developers, and be able to start unlocking critical breakthroughs in product development.
Agenda
Module 1 – Software Design
- 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
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 reflect 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 modeling
- 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 modeling using tools such as Miro.
The main focus is on coding, 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 modeling 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.
The majority 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 modeling 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 key in helping you identify the most suitable practices and patterns for your own professional endeavors.
Why should you buy a ticket?
Get to 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 that all participants keep their webcam on for the whole workshop duration: 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, and you’ll be engaged in real-time activities for the majority of the time… as if we were in a real classroom!
