Implementing Domain-Driven Design
Training for Practical Use of DDD with industry leading expert and author, Vaughn Vernon
Online 4 Half-Day Sessions
Now with 4 Half-Day Online Sessions
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. Exercises are worked within a Peer-to-Peer Economy business, involving e-commerce in a whole new light.
This live online workshop is fully redesigned for the best online experience and includes all the great content of the best-selling on-site training. Break up your day with a morning or afternoon of DDD training and then get back to your regular development work. You are going to love this format!
We offer this workshop to private groups as well as the public. If you have a large team that wants to attend please contact us and we can arrange it.
Accelerate your strategic initiatives in a way that helps you design for the business’ competitive advantage. If your organization is looking for the way forward with Microservices, consider this workshop an essential foundation.
Hands-on exercises show you how to use DDD strategic and tactical design in your implementations. Students who wish to engage in workshop exercises and write source code will be able to do so. Learn how multiple interacting Microservices that are event-driven are implemented as DDD Bounded Contexts.
Strategic Domain-Driven Design
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 Sub-domains, Bounded Contexts, and Context Maps.
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.
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 require more rigorous design. You will gain a new tool from this experience, known as Context Topo Maps.
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. You will use Context Topo Maps to make it all make sense.
Architecture and Event-Driven Modeling
Day 2 crosses over to architecture, preparing you for modularity, to employ Ports and Adapters, Event-Driven, and other powerful architectural tools as you develop new Bounded Contexts in hands-on exercises and homework. Students learn ways to develop a Ubiquitous Language within a Bounded Context, using Event Storming, Extreme Modeling, and Context Topo Maps. Students use these tools to reach a shared understanding of a Core Domain and Subdomains.
If you don’t understand modularity and apply it to the full, you will have trouble using DDD. Don’t go to all the trouble to carefully craft a Ubiquitous Language with domain objects but overlook proper modularization. Learn why modularity at every level is so vital to good architecture and design. Capture the techniques for organizing concepts within a Bounded Context and inside its domain model.
See how various architecture styles and patterns can be used to support your DDD projects. We will survey use of 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.
Learn to use Domain Events and Event Storming for both “big picture” systems designs and “detail level” tactical designs. Yet, with remote team interactions, you’ll need a technique beyond Event Storming. That’s why you’ll learn to leverage Extreme Modeling. Includes online exercises.
Tactical Domain-Driven Design
On Day 3 we switch our focus to tactical design, giving you the aptitude to make proper finer-grained modeling decisions within a Core Domain. Whether it’s 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. Learn the advantages and trade offs of using each of the tools, and when another tool could provide a better set of trade offs.
Understand how to properly employ this necessary modeling tool. 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. Rather than overusing Entities, you will 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.
Use this powerful modeling tool to shape, structure, and compose, transactional boundaries around a meaningful whole concept. Transform your understanding of Entity thinking into one that scales broadly and performs under high load, all while protecting valuable and time-sensitive business state.
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.
Learn when and how to use domain-specific factories to support the creation of domain objects.
Strategic Design Meets Implementation
During Day 4 we bring all the parts together to form a microservice (or 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. 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 support REST frontends and Applications Services when necessary. With all this background you will be prepared to move forward with a DDD project of your own, or to make greater strides on your current DDD strategic initiative.
You will learn how to persist and retrieve your Aggregates using object-based persistence and with Event Sourcing.
Learn what CQRS is and how to apply CQRS using full Entity state, Domain Events, and Event Sourced models. Discover how to partition your Bounded Context for two-sided operation for the command model and the query model. We consider the basics of query/read-side projections, how to deal with complex projections, and how to implement queries.
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. Integration techniques include long-running transactions by means of Process Managers, aka Sagas.
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. Guidance includes how the CQRS query model factors in as well as using API composition.