Domain-Focused Architecture (Hands On)
We live in a world of volatile requirements. Traditional N-tier monoliths, which focus on the needs of the hardware and infrastructure, fail miserably in this world. They're hard to build, resist change, and generally cost us considerable time and money. Modern solutions—Agile processes and microservices, for example—require a different approach entirely, one that focuses on the customer's environment and the problems that our customers need to solve. By directly modeling the customer's world, changes mandated by that world are easy to implement. The convenience of the hardware and infrasture is secondary.
Similarly, moving to an Agile process without changing your architecture guarantees failure. Adopting a modern, domain-focused, architecture is essential to the success of every software project, but is mandatory in Agile and microservice-based systems. They're far more effective than traditional N-tier approaches.
This practical, hands-on workshop teaches you how to build a truly robust, domain-based architecture that adapts painlessly when requirements change, where it's best to design incrementally as your understanding of the problem matures. You'll learn to design highly scalable systems, appropriate not only in modern, microservice-based back ends and Agile development environments, but anywhere that requirements can change. Domain-focused architectures have considerable benefits (ease of maintenance, for example) even with traditional infrastructure.
You'll learn the entire process, starting with planning strategies and “user stories” and ending with a full microservice-based implementation architecture. You'll work on real-world problems that you bring to class rather than a pedagogic exercise.
What you’ll learnOver the course of a few days:
- you'll learn how to really understand what the systems does with a formal Problem Statement that establish an overall architecture.
- you'll learn what user stories really are, and at how to write and organize them effectively.
- you'll learn how to factor stories, how to extract architectural elements from them, and how to derive classes and microservices from those elements.
- you'll learn how to build an architectural model from the stories, and how to forge that model into a coherent system architecture.
- you'll learn about the best physical architectures for volatile environments, including microservices, messaging, and agents.
- You'll lean the essentials of classic domain-focused appoaches like DDD, but also learn how to actually apply those principles to real work.
You'll come away withYou'll come away from this class understanding how to build a scalable and robust system that can easily expand incrementally and accommodate new and changing requirements. In particular, you'll
- understand the entire system design process, starting with “user stories” and ending with a full implementation architecture
- learn how to develop stories, how to factor them into smaller units, how to extract architectural elements from them, and how to derive classes and microservices from them
- know how to look at your system design from both the within-the-application coding architecture and the system architecture perspective
Alternative presentationsThe class can be presented in an abbreviated, lecture only, format. However, designing around volatility requires thinking about both the problem and solution in a new way, and this shift in thinking can be difficult to achieve without a guided exercise. I can also add an extra day or two of hands on if you want to work on a complex problem.
AudienceThis hands-on course is aimed both at:
- Planning when requirements are volatile
- Story maps
- Cumulative flow diagrams
- The Kanban board
- The server (microservices)
- Domain-driven design (DDD)
- Connections between DDD and OO thinking
- Context, Domain, Model, and Language
- Strategic Design
- Bounded Contexts, CI, Context Maps
- Building Blocks
- Entity, value object, aggregate, domain events, service, repository, factory
- What is an object?
- What is a story?
- Defining a story
- The conversation
- How do you test it?
- Modeling Basics
- Domain-focused architecture
- Defining the problem (problem statements)
- Story Maps and System coherence
- Refining the story
- Factoring (narrowing)
- Stories to Activities
- Diagramming complex systems
- Simplified UML as a communication tool.
- CRC-card walls
- Responsibility-based design
- CRC cards and roles
- Using code to develop architecture
- Demo: authentication
- Exercise: Developing a problem statement
- Exercise: Creating and organizing stories
- Exercise: Translating stories to activities
- Exercise: Creating classes and messaging systems from activities
- Implementation Architecture
- Design by coding
- Leveraging Simulation
- Micro- and Mini-services
- Essential characteristics and how to implement them
- Messaging systems
- A quick overview of ZeroMQ
- Services as objects
- Microservice Swarms