Intensive, 3-day, hands-on DDD workshop by Vaughn Vernon and Tomasz Jaskula
There is no doubt that Microservices are a clear trend. Why is this architecture trending? Is it necessary to adopt, and if so, how do you do so successfully? Are you a developer who wants to learn how to identify the parts of the business that would benefit from development and deployment of Microservices? How should teams be formed that will stand up to the brutal facts of Conway’s Law? Are you interested in how strategic Domain-Driven Design is used to bolster your efforts and clarify your business vision? Of course! That’s why this intensive, three-day, hands-on, strategic and tactical, code-prolific workshop is for you.
This workshop is specially designed for mid-level and senior software developers and architects who are interested in applying strategic Domain-Driven Design to achieve a Microservices architecture. This is a hands-on workshop. Students are strongly encouraged to engage in business-driven workshop exercises, such as Impact Mapping, defining example-based scenario specifications, Event Storming, Domain Topo Mapping, and source code implementation. This leads to bringing multiple interacting, Reactive, Event-Driven, Microservices into operation. Exercises are worked within a real-to-life business domain.
You have certainly studied the landscape of a gigantic monolith and wondered how to identify Bounded Contexts. We provide the well-informed tools and steps. From test-driven modularization to monolith strangulation, and everything in between, you will be armed with the knowhow and design techniques to tackle your digital opponent.
Get a big-picture view of the problem space with Event Storming, and then dive toward detailed learning with a design-level timeline. Learn practical ways to identify Bounded Contexts by means of business- and language-driven decision making. Following this, teams of students use these tools to reach a shared understanding of Core Domains and Supporting Subdomains. As a by-product, you also gain essential understanding of an events-first approach to Microservices development.
Highlights of what we will cover
- Definitions and Drivers
- Determining Service Boundaries
- Domain Modeling
- Service Collaboration and Integration
- User Experience and User Interface
- Breaking Up the Monolith
- Strategic DDD
- Distributed System Patterns
- The importance of Conway’s Law in successful implementation of Microservices
- How to get business’ backing on team organization, so your efforts to develop and deploy Microservices into production succeed.
- How a pursuit of a “single-motion modeling, architecture, and APIs” leads to mastering software development and beyond.
- How DDD helps in modeling fresh core differentiating capabilities.
- How Agile plays into teams reaching continuous improvement, integration, and improvement.
- How reworking toward competitive distinction happens.
- The secrets to determining proper service divisions and boundaries, and the tools to make it happen.
- How to iteratively decompose source code and database schemas into manageable services.
- How to design query and action handling facilities that match up with the unique influences of a Microservices architecture.
- How important user experience and user interfaces are to Microservices.
Business Drivers, Identifying Boundaries, Teams, Service Collaboration, and ArchitectureDay 1 begins with everyone jumping head first into a large, unwieldy big-ball-of-mud monolith. We surface the executive mindset and business drivers behind this effort, which will determine our strategic and tactical decisions. This leads to our first big effort in identifying potential service boundaries, how to name them, and how to make them work together. Depending on the kinds of contextual boundaries that emerge, we will determine the kinds of teams and skills needed for each bounded service. At that point we examine potential architectures and architecture patterns by studying the responsibilities and capabilities of our candidate services, making sound architecture decisions as we go.
What To Do About Monoliths
Strategies, tools, and people to help box up the mud. Microservices don’t just appear. Make decisions and steer the project based on the business, their goals, and the way they communicate.
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 on 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 require 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 goals and process, and business capabilities modeling and Domain Topo Mapping 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 knowhow in the use of project acceleration tools with Event Storming using “big picture” and “design level” modeling.
Architecture for Event-Oriented DDDSee 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.
Design and Integrating Bounded ContextsDay 2 switches 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.
Domain Events (and Commands)
Learn the difference between Commands and Domain Events, and when to use each. You must well understand Domain Event design and maintenance in order to use an events-first approach to domain modeling and integration.
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. Learn to model the uncertainty introduced by distributed systems, latency, and failure, to provide a solution in the simplest possible way.
Domain ServicesAdd 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.
Continuing from Day 2 exercises, learn how Reactive tools such as Reactive Streams 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. (Don’t judge this section by the size of the content; it’s a ton of work.)
Messaging and Integration Patterns and ToolsReviews the patterns used for messaging solutions, including integration using messaging. What are the options for message passing within a Bounded Context? What about techniques for dealing with messaging around a full system of Microservices? These tools and techniques prepare you for the full collaboration between Microservices and the integration of them.
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.
Refactoring and Migrating Service Boundaries Over TimeSuccessful businesses are always changing, and the only Microservices that are not influenced by that change are at best Supporting Subdomains. Sometimes boundaries remain the same but have ever-growing features. Often times boundaries increase and change in composition because of business impacts. Learn how business impacts drive organizational, feature, language, and boundary changes, and how to respond to those by growing and reshaping your systems with success.
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. Learn how to capture user behavior as a stream of Domain Events that Event Sourced and are projected into queryable data models using CQRS. Finally, we’ll explore how Bounded Contexts should be composed and decomposed as features are added to Microservices over time.
- Using concrete examples, you will learn what is involved in the difficult task of breaking up a large and unwieldy monolith—often referred to as a Big Ball of Mud—and how to succeed in the face of this challenge.
- Employing lightweight tools to pivot within the mud, your efforts will lead to applying DDD strategic design with modern software architecture.
- You will learn how to achieve strong communication and collaboration with business experts. You will experience Context Mapping from quick drawings to actual multi-context integrations by using a set of prescriptive approaches.
- Gain the critical skills that you need to design effective service collaborations with robust integrations between multiple, even several or many, Microservices, comprising a whole-system solution.
- Dig in to acceptance, unit, and integration testing, examining the benefits of test-first vs test-after as you apply DDD tactical design within a Core Domain.
- Operating with both the Ubiquitous Language and tactical modeling tools, you will produce clean and clear domain models that event deal with distributed computing uncertainties and that hits the innovation target.
- Using a number of distributed computing patterns, you will round out your toolbox for successfully building systems that function despite the inherent complexity of cloud and networked whole-system solutions.