Software Architecture: The Hard Parts

Software Architecture: The Hard Parts

by Neal Ford, Mark Richards, Pramod Sadalage, Zhamak Dehghani
Released October 2021
Publisher(s): O'Reilly Media, Inc.
ISBN: 9781492086895

Read it now on the O’Reilly learning platform with a 10-day free trial.

O’Reilly members get unlimited access to books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Buy on Amazon Buy on ebooks.com
Start your free trial

Book description

There are no easy decisions in software architecture. Instead, there are many hard parts--difficult problems or issues with no best practices--that force you to choose among various compromises. With this book, you'll learn how to think critically about the trade-offs involved with distributed architectures.

Architecture veterans and practicing consultants Neal Ford, Mark Richards, Pramod Sadalage, and Zhamak Dehghani discuss strategies for choosing an appropriate architecture. By interweaving a story about a fictional group of technology professionals--the Sysops Squad--they examine everything from how to determine service granularity, manage workflows and orchestration, manage and decouple contracts, and manage distributed transactions to how to optimize operational characteristics, such as scalability, elasticity, and performance.

By focusing on commonly asked questions, this book provides techniques to help you discover and weigh the trade-offs as you confront the issues you face as an architect.

  • Analyze trade-offs and effectively document your decisions
  • Make better decisions regarding service granularity
  • Understand the complexities of breaking apart monolithic applications
  • Manage and decouple contracts between services
  • Handle data in a highly distributed architecture
  • Learn patterns to manage workflow and transactions when breaking apart applications

Table of contents

  1. Preface
    1. Conventions Used in This Book
    2. Using Code Examples
    3. O’Reilly Online Learning
    4. How to Contact Us
    5. Acknowledgments
      1. Acknowledgments from Mark Richards
      2. Acknowledgments from Neal Ford
      3. Acknowledgments from Pramod Sadalage
      4. Acknowledgments from Zhamak Dehghani
  2. 1. What Happens When There Are No “Best Practices”?
    1. Why “The Hard Parts”?
    2. Giving Timeless Advice About Software Architecture
    3. The Importance of Data in Architecture
    4. Architectural Decision Records
    5. Architecture Fitness Functions
      1. Using Fitness Functions
    6. Architecture Versus Design: Keeping Definitions Simple
    7. Introducing the Sysops Squad Saga
      1. Nonticketing Workflow
      2. Ticketing Workflow
      3. A Bad Scenario
      4. Sysops Squad Architectural Components
      5. Sysops Squad Data Model
  3. I. Pulling Things Apart
  4. 2. Discerning Coupling in Software Architecture
    1. Architecture (Quantum | Quanta)
      1. Independently Deployable
      2. High Functional Cohesion
      3. High Static Coupling
      4. Dynamic Quantum Coupling
    2. Sysops Squad Saga: Understanding Quanta
  5. 3. Architectural Modularity
    1. Modularity Drivers
      1. Maintainability
      2. Testability
      3. Deployability
      4. Scalability
      5. Availability/Fault Tolerance
    2. Sysops Squad Saga: Creating a Business Case
  6. 4. Architectural Decomposition
    1. Is the Codebase Decomposable?
      1. Afferent and Efferent Coupling
      2. Abstractness and Instability
      3. Distance from the Main Sequence
    2. Component-Based Decomposition
    3. Tactical Forking
      1. Trade-Offs
    4. Sysops Squad Saga: Choosing a Decomposition Approach
  7. 5. Component-Based Decomposition Patterns
    1. Identify and Size Components Pattern
      1. Pattern Description
      2. Fitness Functions for Governance
      3. Sysops Squad Saga: Sizing Components
    2. Gather Common Domain Components Pattern
      1. Pattern Description
      2. Fitness Functions for Governance
      3. Sysops Squad Saga: Gathering Common Components
    3. Flatten Components Pattern
      1. Pattern Description
      2. Fitness Functions for Governance
      3. Sysops Squad Saga: Flattening Components
    4. Determine Component Dependencies Pattern
      1. Pattern Description
      2. Fitness Functions for Governance
      3. Sysops Squad Saga: Identifying Component Dependencies
    5. Create Component Domains Pattern
      1. Pattern Description
      2. Fitness Functions for Governance
      3. Sysops Squad Saga: Creating Component Domains
    6. Create Domain Services Pattern
      1. Pattern Description
      2. Fitness Functions for Governance
      3. Sysops Squad Saga: Creating Domain Services
    7. Summary
  8. 6. Pulling Apart Operational Data
    1. Data Decomposition Drivers
      1. Data Disintegrators
      2. Data Integrators
      3. Sysops Squad Saga: Justifying Database Decomposition
    2. Decomposing Monolithic Data
      1. Step 1: Analyze Database and Create Data Domains
      2. Step 2: Assign Tables to Data Domains
      3. Step 3: Separate Database Connections to Data Domains
      4. Step 4: Move Schemas to Separate Database Servers
      5. Step 5: Switch Over to Independent Database Servers
    3. Selecting a Database Type
      1. Relational Databases
      2. Key-Value Databases
      3. Document Databases
      4. Column Family Databases
      5. Graph Databases
      6. NewSQL Databases
      7. Cloud Native Databases
      8. Time-Series Databases
    4. Sysops Squad Saga: Polyglot Databases
  9. 7. Service Granularity
    1. Granularity Disintegrators
      1. Service Scope and Function
      2. Code Volatility
      3. Scalability and Throughput
      4. Fault Tolerance
      5. Security
      6. Extensibility
    2. Granularity Integrators
      1. Database Transactions
      2. Workflow and Choreography
      3. Shared Code
      4. Data Relationships
    3. Finding the Right Balance
    4. Sysops Squad Saga: Ticket Assignment Granularity
    5. Sysops Squad Saga: Customer Registration Granularity
  10. II. Putting Things Back Together
  11. 8. Reuse Patterns
    1. Code Replication
      1. When to Use
    2. Shared Library
      1. Dependency Management and Change Control
      2. Versioning Strategies
      3. When To Use
    3. Shared Service
      1. Change Risk
      2. Performance
      3. Scalability
      4. Fault Tolerance
      5. When to Use
    4. Sidecars and Service Mesh
      1. When to Use
    5. Sysops Squad Saga: Common Infrastructure Logic
    6. Code Reuse: When Does It Add Value?
      1. Reuse via Platforms
    7. Sysops Squad Saga: Shared Domain Functionality
  12. 9. Data Ownership and Distributed Transactions
    1. Assigning Data Ownership
    2. Single Ownership Scenario
    3. Common Ownership Scenario
    4. Joint Ownership Scenario
      1. Table Split Technique
      2. Data Domain Technique
      3. Delegate Technique
    5. Service Consolidation Technique
    6. Data Ownership Summary
    7. Distributed Transactions
    8. Eventual Consistency Patterns
      1. Background Synchronization Pattern
      2. Orchestrated Request-Based Pattern
      3. Event-Based Pattern
    9. Sysops Squad Saga: Data Ownership for Ticket Processing
  13. 10. Distributed Data Access
    1. Interservice Communication Pattern
    2. Column Schema Replication Pattern
    3. Replicated Caching Pattern
    4. Data Domain Pattern
    5. Sysops Squad Saga: Data Access for Ticket Assignment
  14. 11. Managing Distributed Workflows
    1. Orchestration Communication Style
    2. Choreography Communication Style
      1. Workflow State Management
    3. Trade-Offs Between Orchestration and Choreography
      1. State Owner and Coupling
    4. Sysops Squad Saga: Managing Workflows
  15. 12. Transactional Sagas
    1. Transactional Saga Patterns
      1. Epic Saga(sao) Pattern
      2. Phone Tag Saga(sac) Pattern
      3. Fairy Tale Saga(seo) Pattern
      4. Time Travel Saga(sec) Pattern
      5. Fantasy Fiction Saga(aao) Pattern
      6. Horror Story(aac) Pattern
      7. Parallel Saga(aeo) Pattern
      8. Anthology Saga(aec) Pattern
    2. State Management and Eventual Consistency
      1. Saga State Machines
    3. Techniques for Managing Sagas
    4. Sysops Squad Saga: Atomic Transactions and Compensating Updates
  16. 13. Contracts
    1. Strict Versus Loose Contracts
      1. Trade-Offs Between Strict and Loose Contracts
      2. Contracts in Microservices
    2. Stamp Coupling
      1. Over-Coupling via Stamp Coupling
      2. Bandwidth
      3. Stamp Coupling for Workflow Management
    3. Sysops Squad Saga: Managing Ticketing Contracts
  17. 14. Managing Analytical Data
    1. Previous Approaches
      1. The Data Warehouse
      2. The Data Lake
    2. The Data Mesh
      1. Definition of Data Mesh
      2. Data Product Quantum
      3. Data Mesh, Coupling, and Architecture Quantum
      4. When to Use Data Mesh
    3. Sysops Squad Saga: Data Mesh
  18. 15. Build Your Own Trade-Off Analysis
    1. Finding Entangled Dimensions
      1. Coupling
      2. Analyze Coupling Points
      3. Assess Trade-Offs
    2. Trade-Off Techniques
      1. Qualitative Versus Quantative Analysis
      2. MECE Lists
      3. The “Out-of-Context” Trap
      4. Model Relevant Domain Cases
      5. Prefer Bottom Line over Overwhelming Evidence
      6. Avoiding Snake Oil and Evangelism
    3. Sysops Squad Saga: Epilogue
  19. A. Concept and Term References
  20. B. Architecture Decision Record References
  21. C. Trade-Off References
  22. Index
  23. About the Authors

Product information

  • Title: Software Architecture: The Hard Parts
  • Author(s): Neal Ford, Mark Richards, Pramod Sadalage, Zhamak Dehghani
  • Release date: October 2021
  • Publisher(s): O'Reilly Media, Inc.
  • ISBN: 9781492086895