Using events to deliver core business value

This intensive, two-day, hands-on workshop teaches you DDD within an explicitly event-oriented microservices business domain. You will learn both strategic and tactical design. This workshop is specially designed for mid-level and senior software developers and architects who are interested in applying event-driven and microservices architectures using DDD. 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 that are event-driven and that use DDD strategic and tactical design.

This hands-on, code-prolific, DDD workshop teaches you the essentials of how to implement using the Domain-Driven Design approach. Students first receive an overview of DDD’s strategic and tactical design, including ways to develop a Ubiquitous Language within a Bounded Context, using both Event Storming and Specification by Example.

Following this, teams of students use these tools to reach a shared understanding of a Core Domain and Subdomains. Each team presents their “big picture” and “design level” direction and receive helpful feedback before the implementation begins. This step leads to a succession of strategic and tactical design learning and implementation steps with either Java or C#. Implementations may use Event Sourcing and traditional domain model persistence.

Takeaways:

• Essential DDD, with strategic and tactical design, including developing a Ubiquitous Language in a Bounded Context
• Bounded Contexts, Core Domain, Subdomains, and Context Mapping
• Domain Events and Aggregates
• Project acceleration and management tools
• Learn the basics of Event Storming using “big picture” and “design level” modeling
• Apply your storming results to actual implementations using Aggregates and Domain Events
• Use Domain Events to integrate with multiple Bounded Contexts
• The tradeoffs of using traditional domain model persistence and Event Sourcing

Outline

• 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.

• Context mapping

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 the Microservices Architecture, Ports and Adapters Architecture, along with an Event-Driven Architecture, can be used to support your DDD projects. 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.

• Aggregates

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.

• Acceleration and management tools

Every project stakeholder knows the urgency of staying on task and on time. What techniques and tools can be used to accelerate your DDD effort, provide project estimates, time box domain modeling efforts, collaborate with domain experts, and how much time will that require? The answers are given and reenforced through practical guidelines.

Developers around the world are moving to rapidly adopt Domain-Driven Design (DDD), and in greater numbers than ever before. That's because DDD delivers powerful results in practice. At the same time, Reactive software development is becoming essential to implementing responsive, resilient, elastic, and message-driven solutions, including event streams of fast data. This world of distribution, concurrency, latency, and the uncertainty of time-critical results, must be tackled along with the complex business challenges. This talk gives practical guidance on using DDD to model business-driven solutions that result in software that is fluent, type-safe, and with core Reactive properties. Specific attention is given to moving legacy systems that have deep debt to ones that have clear boundaries, deliver explicit and fluent business models, and exploit modern hardware and software architectures.