Architecture: The Hard Parts

Software architects have no clean, easy decisions: everything is a terrible tradeoff. Architecture has lots of difficult problems, which this platform-agnostic class highlights by investigating what makes architecture so hard. This class goes beyond the fundamentals of software architecture and focuses on hard problems within distributed architectures such as microservices and event-driven systems.

This class is divided into 2 main parts—pulling things apart, then putting them back together again. In part 1 (pulling things apart), you’ll learn about the differences between modularity and granularity, techniques, and patterns for breaking apart monolithic systems and migrating them to a distributed architecture, how to choose the right size for a service, and how to break apart monolithic data. However, once you break a system apart, necessarily you need to put it back together again. That’s what part 2 is about - putting things back together.

In part 2 you’ll learn about communication protocols for communicating between services, how to reconnect distributed data, whether your workflow should use orchestration or choreography, what sort of contract you should have between services, what patterns to use for complex event processing, and how to manage distributed transactions while still maintaining some level of data consistency and integrity.

Software architecture is full of hard parts. By attending this 2-day class you can gain the insights and techniques to make it just a little softer.

Target Audience

The target audience is existing architects, aspiring architects interesting in learning about fundamental tradeoffs, and developers working within complex architectures. No laptop is required, but access to a browser on some device is necessary as the exercises are online.

Outline & Agenda

Part 1: Pulling Things Apart

Unit 1: Architectural Modularity

Why migrate from monolithic systems? Business and technical drivers Migration patterns and approaches Hands-on exercises: Migration drivers

Unit 2: Architectural Quantum

Defining a quantum Why this is important Application partitioning Quantum examples Hands-on exercises: Identifying architectural quanta

Unit 3: Technical vs. Domain Partitioning

Technically partitioned architectures Conway’s Law Dynamically partitioned architectures Inverse Conway maneuver Advantages and disadvantages of each Architecture and organizational alignment Migrating from technical to domain partitioning Hands-on exercises: Identifying partitioning

Unit 4: Component-Based Decomposition

Microservices migration patterns Identifying and sizing components Flattening components Identifying component dependencies Creating component domains Creating domain services Domain service decomposition Hands-on exercises: Flattening components

Unit 5: Service Granularity

Granularity disintegration drivers Granularity integration drivers Analyzing tradeoffs Hands-on exercises: Determining service granularity

Unit 6: Breaking Apart Monolithic Data

Drivers for data decomposition Creating Data domains Resolving data dependencies Hands-on exercises: Decomposing monolithic databases

Part 2: Putting Them Back Together

Unit 7: Data Access and Ownership

Creating bounded contexts Managing common data ownership Managing joint data ownership Data Access patterns Hands-on exercises: Accessing remote data

Unit 8: Managing Contracts

Strict vs. loose contracts Bandwidth and stamp coupling Consumer-driven contracts

Unit 9: Communication Protocols

Synchronous communication Asynchronous communication Dynamic quantum entanglement

Unit 10: Managing Workflows

Defining orchestration Defining Choreography Analyzing tradeoffs Hybrid topologies Hands-on exercises: Choosing a workflow type

Unit 11: Distributed Transactions

ACID transactions BASE Transactions Eventual consistency patterns Managing transaction through state machines Compensating updates

Unit 12: Transactional Sagas

Three dimensional sagas Epic Saga Fantasy Fiction Saga Fairy Tale Saga Parallel Saga Phone Tag Saga Horror Story Saga Time Travel Saga Anthology Saga Transactional Saga Tradeoffs Hands-on exercises: Choosing the right transactional saga

Testimonials

This workshop helps me to back up my architectural decisions with measurements and proofs rather than just by gut feeling. – Anonymous post-workshop feedback

The workshop reinforces my learning in distributed systems and helps me to consider important aspects when designing the architecture in my business. – Anonymous post-workshop feedback

Excellent concepts were introduced that I can use to evaluate and discuss architectural choices with colleagues. The workshop provided a vocabulary that makes these discussions easier. – Anonymous post-workshop feedback

Prerequisites

No laptop required. Experience with architecture-level decisions