Learn How Your Team Can Put DDD to Use
Intensive, 3-Day, Hands-On IDDD Workshop by Vaughn Vernon
|Go beyond the theory of DDD and see how your team can actually use DDD to accelerate your strategic initiatives in a way that helps you design for the business’ competitive advantage. Emphasis is placed on software development as a craft by embracing software design in source code that works within the framework of agile processes, and de-emphasizes attempts to solve real strategic business software initiatives by throwing technology at the problem. The event is best for senior and mid-level software developers and architects interested in software craftsmanship and learning domain modeling using the Domain-Driven Design (DDD) approach. If your organization is looking for the way forward with Microservices, consider this workshop an essential foundation. This is a hands-on workshop. Students are strongly encouraged to engage in workshop exercises and write source code that includes implementing multiple interacting Microservices, as DDD Bounded Contexts, that are event-driven. You will use DDD strategic and tactical design in your implementations.||
Contact us directly to reserve dates for private workshops.
See also the Implementing Domain-Driven Design Workshop for planned public workshop events and registration.
Day 1: Getting Started, Strategic Design, and Architecture
The goal of Day 1 is for you to get grounded with a DDD mentality that will free your mind from data-driven approaches. This is necessary to grasp the thrust of developing a Ubiquitous Language within a Bounded Context, the hallmark of DDD. From there you will be ready to embrace strategic design using Subdomains, Bounded Contexts, and Context Maps. Day 1 then crosses over to architecture, preparing you to employ Ports and Adapters, Event-Driven, and other powerful architectural tools as you develop new Bounded Contexts in classroom exercises. Students learn ways to develop a Ubiquitous Language within a Bounded Context, using both Specification by Example and Event Storming. Find your way toward correct software delivery goals using Impact Mapping. Teams of students will use these tools to reach a shared understanding of a Core Domain and Subdomains. Each team will present their “big picture” and “design level” direction and receive helpful feedback before the implementation begins in Day 2.
Getting Started with DDD
Understand the essence of DDD. Form the right mentality for powerful software modeling. Develop a Ubiquitous Language for your project using the Specification by Example approach and Acceptance Tests. This lays a foundation for moving forward with DDD.
Domains, Subdomains, and Bounded Contexts
Grasp the core concepts of DDD strategic modeling, and put them to use. Learn to vigorously gather core concepts and separate irrelevant ones. Learn why strategic design is so essential. Develop the ability to determine when your domain models are composed correctly and when they required more rigorous design.
Learn how to integrate with other subsystems using DDD and straightforward design techniques. Context Maps are not just drawings. Use them for cross-team communications, project thinking, learning, planning, and as an integration tool.
Architectures that Support DDD
See how various architecture styles and patterns can be used to support your DDD projects. We will look at the following: Layers; Dependency Inversion Principle; Hexagonal; Microservices; REST; Event-Driven; Process Management; Event Sourcing and CQRS; Actor Model. Coupled with DDD, these architecture styles and patterns will support your microservices efforts.
Domain Events and Event Storming
Learn to use Domain Events and Event Storming for both “big picture” systems designs and “detail level” tactical designs. Exercises will lead to using and Event-Driven Architecture in Day-2 implementations.
Day 2: Tactical Design
In Day 2 we switch our focus to tactical design, giving you the aptitude to make proper finer-grained modeling decisions within a Core Domain. Whether its the use of Entities, Value Objects, Aggregates,Domain Events, or Domain Services that best fit your specific modeling situation, you can put each of the tactical tools to use in your own Core Domain project. As the day progresses, you will learn the advantages of using each of the tools, and when another tool could provide a better set of tradeoffs.
There will likely be at least some Entities in object-oriented domain models because of the need to manage change over the life cycle of mutable objects. Understand how to properly employ this necessary modeling tool, but also why you should use these less often than you may think. Rather than overusing Entities, learn how to best use them only when a domain concept must change over time.
Embrace this invaluable, functional modeling tool, which you should use as often as possible. You will learn the Value Object characteristics and why using Values where possible is a safer way to design. You will learn by modeling concepts as Values, and you may even decide to use Value-prolific designs rather than Entities.
Demystify effective aggregate designs with the use of a set of simple rules. Learn how to design object clusters for correct transactional consistency, performance, and high scalability.
Learn how to model, publish, and consume the facts of what happened in a domain model. You will see how Domain Events have far reaching impact on your designs across the enterprise. Here you will gain an understanding of how to publish and consume Events using messaging.
Add powerful stateless operations to your model when its use is appropriate. The modeling techniques cover both domain-specific services and those of a more technical nature, often used for integration.
Understand the importance of and techniques for organizing concepts within a single domain model. Why go to all the trouble to carefully craft domain objects but without proper modularization using your Ubiquitous Language?
See when and how to use factories to support the creation of domain objects.
Day 3: Aggregate Persistence, Integrating Bounded Contexts, Application
During Day 3 we bring all the parts together to form an application. We look at different ways to persist Aggregates using object-relational mapping, document databases, key-value stores, as well as by employing Event Sourcing. We then take a deep dive into applying Context Mapping techniques as we return to strategic design, but this time by developing integration solutions between Core Domains and other Bounded Contexts in your whole-system solution. Finally we give attention to other parts of the application, such as the user interface and querying with CQRS. We also take a look at how to use Applications Services when necessary. With all this background you will be better prepared to move forward with a DDD project of your own, or to make greater strides on your current DDD strategic initiative.
Repositories and Event Sourcing
Consider two primary approaches to persisting and reconstituting your domain objects. You will learn how to persist and retrieve your Aggregates using both SQL and NoSQL databases. You will also learn how to use Event Sourcing as both a persistence approach and to publish Domain Events for broader consumption.
Integrating Bounded Contexts
Employ both REST and messaging to realize your Context Maps in code as you integrate multiple Bounded Contexts of enterprise applications. Understand the complexities and challenges of distributed computing environments, and how to deal with them. An important lesson that is reemphasized is to model each Bounded Context cleanly and separately from those with which you integrate.
Learn how the components that surround your domain model comprise a whole subsystem application. Consideration is given to User Interface strategies and the Application Programming Interface (API) using Application Services. Here you will learn how to apply CQRS from Domain Events and Event Sourcing.