Software Architecture: The Hard Parts (2 Day)

Format: Live Virtual Training
Duration: 2-Day Class

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 hands-on, platform-agnostic architecture class 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 2 main parts:

  • Part 1: Pulling Things Part (Modularity and Building Blocks)
  • Part 2: Putting Them Back Together (Patterns and Tradeoffs)

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. Part 2 also covers the stitching of the parts, 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 course for private (corporate) training, please contact me at info@developertoarchitect.com. For public training offerings for this course, please see my public schedule at my upcoming events page. 

Public Training Dates
See the Public Course Schedule page for scheduled dates for this class


Course Agenda (2-Day Virtual Class)

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
  • The Knife Analogy

Components as Architecture Building Blocks

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

Architecture Quantum

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

Architecture Kata Exercises #1 - Breaking Apart The System

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

Domain Partitioning

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

Monolithic vs. Distributed Architecture

  • Choosing an Architecture Style
  • Fallacies of Distributed Computing  

Building Blocks For Distributed Architectures

  • The Origins of Orchestration
  • Broker Topology
  • Mediator Topology 

Modularity vs. Granularity

  • Determining The Right Level of Granularity
  • Service Granularity Drivers 
  • Service Granularity Factors

Architecture Kata Exercises #2 - Identifying Services

  • Identify Service Candidates
  • Determine Service Granularity Level
  • Refine Quanta

Data Abstraction Patterns

  • Breaking Apart Data
  • How Data Impacts Service Granularity
  • Data Domains
  • Dealing With Common Data
  • Data Ownership and Bounded Contexts

Architecture Kata Exercises #3 - Data Ownership and Bounded Contexts

  • Identify Data Domains 
  • Determine Data Ownership
  • Create Bounded Contexts
  • Refine Quanta


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

Synchronous vs. Asynchronous Communication

  • Quantum Separation
  • Messaging For East-West Communication
  • Leveraging Queues For Back Pressure
  • Leveraging Publish-Subscribe For Extensibility

Architecture Kata Exercises #4 - Communication Styles

  • Identify Async vs. Sync Communication
  • Refine Quanta

Contract Management

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

Fitness Functions for Contract Management

  • Defining Fitness Functions
  • Fitness Function Tools
  • Example Fitness Function

Architecture Kata Exercises #5 - Contract Styles and Tradeoffs

  • Identify Contract Styles Between Services
  • Analyze and Qualify Tradeoffs
  • Create Fitness Functions for Contract Management

Orchestration and Workflow

  • Differences Between Orchestration and Choreography 
  • Choreography Examples 
  • Orchestration Examples
  • Workflow Patterns and Sagas

Architecture Kata Exercises #6 - Orchestration and Workflow

  • Identify Workflow Patterns Between Services
  • Identify Sagas
  • Choosing Between Orchestration and Choreography
  • Refine Quanta

Communication Patterns

  • Event Forwarding Pattern
  • Thread Delegate Pattern
  • Multi-Broker Pattern
  • Watch Notification Pattern
  • Supervisor-Consumer pattern
  • Ambulance Pattern
  • Workflow Event Pattern

Architecture Kata Exercises #7 - Identify Patterns and Tradeoffs

  • Identify Pattern Usage
  • Analyze Tradeoffs

Data Access and Sharing Strategies

  • Interservice Communication
  • Data Replication
  • Replicated Caching
  • Data Domains Revisited

Architecture Kata Exercises #8 - Data Access Techniques

  • Identify Data Access and Data Sharing
  • Analyze Tradeoffs

Data Mesh

  • Comparing Data Warehouse, Data Lake, and Data Mesh
  • Partitioning a Data Warehouse

Class Summary

  • Final Words of Advice
©2020 DeveloperToArchitect