This updated 2-day class (based on the prior Architecture: The Hard Parts class) takes a deep dive into the hard decisions architects face when creating or migrating to distributed systems—hard decisions involving service granularity, data topologies, communication protocols, workflow management, and distributed transactions (to name a few).
This course starts out with a deep dive exploring the differences between architectural modularity and service granularity, explaining why distributed architecture are so important in today’s world and how to get service granularity right. It then dives into defining the structure of distributed architectures, introducing the concept of an architectural quantum.
Taking a deep dive into the realm of data, we’ll explore various data topologies, and the corresponding tradeoffs associated with each. Here, you’ll learn how to align a distributed architecture with the most appropriate data topology, how to create bounded contexts, how to access data a service no longer owns, and finally various patterns for contracts and message payload.
Knowing that everything is not always microservices, this course then dives into event-driven architecture, exploring various event patterns and techniques for solving difficult problems when using asynchronous communication and event processing.
In the last part of the course, you’ll learn about the three primary decisions an architect faces when designing distributed systems—communication (async or sync), workflow (orchestration or choreography), and transactions (atomic or eventual consistency). The class concludes by bringing all three of these critical decisions together in the form of transactional sagas, simplifying the hard decisions an architect faces when designing distributed systems.
Designing distributed architectures is hard—very hard. By attending this 2-day class you’ll gain the insights and techniques to make it just a little softer.
Unit 1: Architectural Modularity
Unit 2: Service Granularity
Unit 3: The Structure of Distributed Systems
Unit 4: Data Topologies for Distributed Systems
Unit 5: Data Ownership and Access
Unit 6: Contract and Payload Patterns
Unit 7: Event-Driven Architecture Patterns
Unit 8: Communication Protocols
Unit 9: Managing Workflows
Unit 10: Distributed Transactions
Unit 11: Transactional Sagas
This course is for software developers that want to become software architects and for software architects that want to focus on problems within distributed architectures such as microservices and event-driven systems.
Mark Richards is an experienced, hands-on software architect involved in the architecture, design, and implementation of microservices architectures and other distributed systems in a variety of technologies. He has been in the software industry since 1983 and has significant experience and expertise in application, integration, and enterprise architecture. Mark is the founder of DeveloperToArchitect.com, a free website devoted to helping developers in the journey to becoming a software architect. In addition to hands-on consulting, Mark has authored numerous technical books and videos, including his three latest books Fundamentals of Software Architecture, Software Architecture: The Hard Parts, and Head-First Software Architecture. Mark has spoken at hundreds of conferences and user groups around the world on a variety of enterprise-related technical topics.
