Software Architecture: The Hard Parts


Software architects have no clean, easy decisions: everything is a terrible trade-off. 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 really 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.

Course contents

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 Things 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

Target audience and prerequisites

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.

 - 23 October 2024