Intensive, 3-day, hands-on, code-prolific, workshop teaches you DDD within an explicitly modeled Event-Oriented Microservices business domain.
Are you a Spring developer who wants to build event-driven applications using the best of breed practices and approaches provided by Domain-Driven Design? This workshop is for you!
You will learn both strategic and tactical design for building and evolving a Microservices development practice with Spring Boot and Spring Cloud. 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. Spring experience is not required, but recommended. Willingness to learn and use fluency in writing Java or JVM-based applications is recommended. 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. Exercises are worked within a Peer-to-Peer Economy business, involving e-commerce in a whole new light.
This hands-on, code-prolific, DDD workshop teaches you the essentials of how to implement using the Domain-Driven Design approach with an Events First 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 Spring Boot and Spring Cloud.
Essentials, Strategic Design, Events-First, Architecture
Develop your DDD mojo, with lessons around a Ubiquitous Language within a Bounded Context. Following this, use strategic design with Subdomains, Bounded Contexts, and Context Maps. Learn techniques for breaking a Big Ball of Mud Monolith into Bounded Contexts as Microservices.
Day 1 then switches into tactical design with Commands and Domain Events, and Event Storming for learning and project acceleration. Finally you will learn architectures and patterns including Event-Driven, and other powerful architectural tools as you develop new Bounded Contexts in classroom exercises. Teams of students will use these tools to reach a shared understanding of a Core Domain and Subdomains.
Learn how to use strategic and tactical design, including developing a Ubiquitous Language in a Bounded Context
Bounded Contexts, Core Domain, Subdomains
Acquire an understanding how to partition models linguistically. 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.
Big Ball of Mud Monoliths To Bounded Contexts as Microservices
Using Event Storming to understand the business process, and business capabilities modeling to identify service boundaries, learn multiple strategies and tactics for decomposing troublesome legacy systems into well-factored Bounded Contexts as Microservices. Use Strangler and Change-Data Capture to take control of the code and data chaos. Gain techniques for dividing large databases into manageable schemas that are dedicated to individual services.
Grasp the difference between Commands and Domain Events, why Domain Events provide a superior modeling experience, and how to use both Commands and Domain Events in a DDD model. Gain know-how in the use of project acceleration tools with Event Storming using “big picture” and “design level” modeling.
Architecture for Event-Oriented DDD
See how architecture styles and patterns can be used to support your Events-First DDD projects. We will look at the following: Ports and Adapters (aka Hexagonal); Event-Driven; Process Management; Event Sourcing and CQRS; Actor Model. Coupled with DDD, these architecture styles and patterns will support your microservices efforts.
Cloud-native Java Applications with Spring
In the latter half of day one you will be introduced to the Spring ecosystem of tools and projects used to build modern cloud-native JVM applications. Here, we will see how design meets implementation in a multi-hour live coding session that will prepare you for exercises and labs in day 2 and 3 of this training.
- Building reactive applications with Spring Boot
- Building and monitoring microservices with Spring Cloud
- Building a Reactive Microservice using DDD and Event Sourcing
For each of these live coding sessions, you’ll be able to follow along as the instructors introduce you to the Spring ecosystem’s best-of-breed practices for implementing end-to-end Reactive applications. The code for each of the live coding sessions will be provided in advance so that you can follow along in your IDE of choice. It is not expected for you to write any code until day two.
The morning of day 2 will be focused again on theory before we begin the exercises that focus on tactical implementation with Spring Boot and Spring Cloud.
Tactical Design and Integrating Bounded Contexts
In Day 2 we switch our focus first to tactical design, giving you the aptitude to make proper finer-grained modeling decisions within a Core Domain. Learn to use Entities, Value Objects, Aggregates, Domain Events, or Domain Services to address specific modeling situations. You will put each of the tactical tools to use in your own Core Domain and Supporting Subdomains. This leads to the crescendo of integrating Bounded Contexts using Event-Oriented design.
Use Entities to model the “things” in your Bounded Contexts to manage change over the life cycle of mutable objects. Learn to balance the use of Entities with other modeling tools that offer alternatives to identity with mutability.
Learning to use this invaluable, functional modeling tool, will change the way you think about problem solving with software. Embrace the characteristics of Value Objects 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.
Integrating Bounded Contexts
Employ Reactive techniques with choreographed and orchestrated processes. 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, translating between multiple Ubiquitous Languages.
Continuing from Day 2 exercises, learn how Reactive tools such a Reactor and the Actor Model of computation can be leveraged to increase productivity, throughput, scalability, and compute efficiency. This introduces you to the next generation of Cloud Computing by stretching beyond Event-Driven to entire systems delivered as Message-Driven solutions.
Exercises for Day-2 and Day-3
During the second half of day two, we will be focusing on a guided hands-on implementation of a Microservice architecture that puts techniques into practice. These exercises will focus on high- and low-level overviews of the Spring Boot and Spring Cloud projects used in best practice production deployments of event-driven reactive applications. We’ll see how Domain-Driven Design ties into continuous delivery of Spring-based applications that use Event Sourcing. Learn how to capture user behavior as a stream of events that mutate into queryable data models with CQRS. Finally, we’ll explore how Bounded Contexts should be composed and decomposed as features are added to Microservices over time.