Software Architecture: The Hard Parts Training

Software architects have no clean, easy decisions: everything is a terrible tradeoff. Architecture has lots of difficult problems, which this 2-day platform-agnostic workshop highlights by investigating what makes architecture so hard. This hands-on, platform-agnostic architecture workshop goes beyond the fundamentals of software architecture and focuses on the really hard problems. This class focuses primarily on aspects of distributed architectures and on areas surrounding modularity versus granularity, the challenges of event-driven architectures (including difficult error handing issues), distributed architecture patterns and how to decouple services to achieve proper granularity. Architecture is full of hard parts; by attending this workshop you can gain the insights and techniques to make it just a little softer.

This class is divided into 3 main parts:

  • Part 1: Pulling Things Part (Modularity and Building Blocks)
  • Part 2: Putting Them Back Together (Alternatives and Tradeoffs)
  • Part 3: With Simple Parts (Patterns and Solutions)

Pulling things apart (Part 1) focuses on how to break up systems and identify levels of modularity. However, once you’ve broken apart your systems, how do you tie them back together?  Putting them back together (Part 2) focuses on just this - the techniques of how to do orchestration, workflows, and transactions, while keeping parts decoupled from one another. The stitching of the parts is what is covered in Part 3, where you will learn the patterns and solutions used within distributed architecture to keep everything loosely tied together and running smoothly.

For more information about the pricing and availability of this 2-day course for private (corporate) training, please contact me at For public training offerings for this course, please see my public schedule at my upcoming events page. 

Course Agenda (2-Day Workshop)

Part 1: Pulling Things Apart (Modularity and Building Blocks)

Architectural Modularity

  • Why Migrate From Monoliths?
  • Business Drivers
  • Technical Drivers
  • How Much Modularity Is Enough?
  • The Glass Analogy
  • Architecture Styles and Modularity

Architecture Quantum

  • What is an Architectural Quantum?
  • Why are Quanta so Important to Architecture? 
  • Examples of Architecture Quantum

Characteristics as Architecture Drivers

  • Defining Architecture Characteristics 
  • Domain Knowledge
  • Environmental Characteristics
  • Explicit Characteristics 
  • Dimensions of Architecture Characteristics
  • Cart Before The Horse AntiPattern

Architecture Kata Exercises #1 - Breaking Apart The System

  • Identify Architectural Quantum
  • Identify Architecture Characteristics (Per Quanta)
  • Refine Quanta

Components as Architecture Building Blocks

  • Component Definition
  • Coupling Types
  • Connascence
  • Connascence Properties
  • Abstractness vs. Instability (Main Sequence)
  • Component Cohesion 
  • Modern Connascence

Architecture Kata Exercises #2 - Breaking Apart The Functionality

  • Identify Component Groups (Domains)
  • Identify Components (Per Quanta)
  • Identify Candidate Services 

Data Domains

  • Data Distribution Issues
  • Defining Data Domains
  • Dealing With Common Data 

Architecture Kata Exercises #3 - Breaking Apart The Data

  • Identify Groups of Related Data (Information)
  • Identify Data Domains 

Part 2: Putting Them Back Together (Alternatives 
and Tradeoffs)

Domain Partitioning

  • Technical Partitioning
  • Domain Partitioning 
  • Advantages of Domain Partitioning
  • Migrating From Technical To Domain Partitioning

The Value of Asynchronicity

  • Quantum Separation
  • Leveraging Queues For Back Pressure
  • Leveraging Publish-Subscribe For Extensibility

Modularity vs. Granularity

  • Service Functionality 
  • Database Transactions
  • Data Dependencies
  • Workflow and Choreography 
  • Code Structure

Architecture Kata Exercises #4 - Refining Modularity and Granularity  

  • Catalog Proposed Services
  • Refine Service Granularity 

Orchestration vs. Choreography

  • Differences Between Orchestration and Choreography 
  • Origins of Orchestration 
  • Choreography Examples 
  • Orchestration Examples

Distributed Data Management

  • Data Abstraction Layers
  • Transactional Sagas
  • Distributed Transactions 

Contract Management

  • Consumer-Driven Contracts
  • Value-Driven Contracts
  • GraphQL

Architecture Kata Exercises #5 - Identifying Workflows and Transactions   

  • Identify Workflows
  • Determine Orchestration and Choreography 
  • Refining Service Granularity
  • Refining Data Domains
  • Identifying Transactions
  • Refining Architecture Quanta

Part 3: With Simple Parts (Patterns and Solutions)

Preventing Asynchronous Data Loss

  • Sending Data to a Queue
  • Receiving data From a Queue 
  • Persisting Data in a Database 

Thread Delegate Pattern: Maintaining Message Order

  • Context
  • Pattern Description
  • Pattern Implementation
  • Live Demo

Multi-Broker Pattern: Achieving High Throughput

  • Context
  • Pattern Description
  • Pattern Implementation
  • Live Demo

Watch Notification Pattern: Connectionless Notification

  • Context
  • Pattern Description
  • Pattern Implementation
  • Live Demo

Supervisor Consumer Pattern: Programmatic Scalability

  • Context
  • Pattern Description
  • Pattern Implementation
  • Live Demo

Ambulance Pattern: Managing Request Priority

  • Context
  • Pattern Description
  • Pattern Implementation
  • Live Demo

Workflow Event Pattern: Handling Asynchronous Errors

  • Context
  • Pattern Description
  • Pattern Implementation
  • Live Demo

Producer Control Flow Pattern: Applying System-Wide Back Pressure

  • Context
  • Pattern Description
  • Pattern Implementation
  • Live Demo

Threshold Adjust Pattern: Self-Configuring Timeout Values

  • Context
  • Pattern Description
  • Pattern Implementation
  • Live Demo

Architecture Kata Exercises #6 - Applying Patterns  

  • Identify Opportunities For Patterns

Class Summary

  • Final Words of Advice
©2020 Developer To Architect