Software Architecture: The Hard Parts by Neal Ford -- Read -- Imperial Library of Trantor

Index

Preface

Conventions Used in This Book Using Code Examples O’Reilly Online Learning How to Contact Us Acknowledgments

Acknowledgments from Mark Richards Acknowledgments from Neal Ford Acknowledgments from Pramod Sadalage Acknowledgments from Zhamak

1. What Happens When There Are No “Best Practices”?

Why “The Hard Parts”? Giving Timeless Advice About Software Architecture The Importance of Data in Architecture Architecture Decision Records Architecture Fitness Functions

Using Fitness Functions

Architecture versus Design: Keeping Definitions Simple Introducing the Sysops Squad Saga

Non-Ticketing Workflow Ticketing Workflow A Bad Scenario Sysops Squad Architectural Components Sysops Squad Data Model

I. Pulling Things Apart 2. Discerning Coupling in Software Architecture

Architecture (Quantum | Quanta)

Independently Deployable High Functional Cohesion High Static Coupling Dynamic Quantum Coupling

Sysops Squad Saga: Understanding Quanta

3. Architectural Modularity

Modularity Drivers

Maintainability Testability Deployability Scalability Availability/Fault Tolerance

Sysops Squad Saga: Creating a Business Case

4. Architectural Decomposition

Is the Code Base Decomposable?

Afferent and Efferent Coupling Abstractness, Instability, and Distance from the Main Sequence Distance from the Main Sequence

Component-Based Decomposition Tactical Forking

Trade-offs

Sysops Squad Saga: Choosing A Decomposition Approach

5. Component-Based Decomposition Patterns

Identify and Size Components Pattern

Pattern Description Fitness Functions for Governance Sysops Squad Saga: Sizing Components

Gather Common Domain Components Pattern

Pattern Description Fitness Functions for Governance Sysops Squad Saga: Gathering Common Components

Flatten Components Pattern

Pattern Description Fitness Functions for Governance Sysops Squad Saga: Flattening Components

Determine Component Dependencies Pattern

Pattern Description Fitness Functions for Governance Sysops Squad Saga: Identifying Component Dependencies

Create Component Domains Pattern

Pattern Description Fitness Functions for Governance Sysops Squad Saga: Creating Component Domains

Create Domain Services Pattern

Pattern Description Fitness Functions for Governance Sysops Squad Saga: Creating Domain Services

Summary

6. Pulling Apart Operational Data

Data Decomposition Drivers

Data Disintegrators Data Integrators Sysops Squad Saga: Justifying Database Decomposition

Decomposing Monolithic Data

Step 1: Analyze Database and Create Data Domains Step 2: Assign Tables To Data Domains Step 3: Separate Database Connections To Data Domains Step 4: Move Schemas To Separate Database Servers Step 5: Switch over to independent database servers

Selecting a Database Type

Relational Databases Key-Value Databases Document Databases Column Family Databases Graph databases NewSQL Databases Cloud Native Databases Time series Databases

Sysops Squad Saga: Polyglot Databases

7. Service Granularity

Granularity Disintegrators

Service Scope and Function Code Volatility Scalability and Throughput Fault Tolerance Security Extensibility

Granularity Integrators

Database Transactions Workflow and Choreography Shared Code Data Relationships

Finding The Right Balance Sysops Squad Saga: Ticket Assignment Granularity Sysops Squad Saga: Customer Registration Granularity

II. Putting Things Back Together 8. Reuse Patterns

Code Replication

When To Use

Shared Library

Dependency Management and Change Control Versioning Strategies When To Use

Shared Service

Change Risk Performance Scalability Fault Tolerance When To Use

Sidecars and Service Mesh

When To Use

Sysops Squad Saga: Common Infrastructure Logic Code Reuse: When Does It Add Value?

Reuse via Platforms

Sysops Squad Saga: Shared Domain Functionality

9. Data Ownership and Distributed Transactions

Assigning Data Ownership Single Ownership Scenario Common Ownership Scenario Joint Ownership Scenario

Table Split Technique Data Domain Technique Delegate Technique

Service Consolidation Technique Data Ownership Summary Distributed Transactions Eventual Consistency Patterns

Background Synchronization Pattern Orchestrated Request-Based Pattern Event-Based Pattern

Sysops Squad Saga: Data Ownership For Ticket Processing

10. Distributed Data Access

Inter-service Communication Pattern Column Schema Replication Pattern Replicated Caching Pattern Data Domain Pattern Sysops Squad Saga: Data Access For Ticket Assignment

11. Managing Distributed Workflows

Orchestration Communication Style Choreography Communication Style Trade-Offs Between Orchestration and Choreography

State Owner and Coupling

Sysops Squad Saga: Managing Workflows

12. Transactional Sagas

Transactional Saga Patterns

Epic Saga(sao) Phone Tag Saga(sac) Pattern Fairy Tale Saga(seo) Pattern Time Travel Saga(sec) Pattern Fantasy Fiction Saga(aao) Pattern Horror Story(aac) Pattern Parallel Saga(aeo) Pattern Anthology Saga(aec) Pattern

State Management and Eventual Consistency

Saga State Machines

Techniques For Managing Sagas What Next? Sysops Squad Saga: Atomic Transactions and Compensating Updates

13. Contracts

Strict versus Loose Contracts

Trade-offs Between Strict versus Loose Contracts Contracts in microservices

Stamp Coupling

Over-coupling via Stamp Coupling Bandwidth Stamp Coupling for Workflow Management

Sysops Squad Saga: Managing Ticketing Contracts

14. Managing Analytical Data

Previous Approaches

The Data Warehouse The Data Lake

The Data Mesh

Definition of Data Mesh Data Product Quantum Data Mesh, Coupling, and Architecture Quantum When to Use Data Mesh

Sysops Squad Saga: Data Mesh

15. Build Your Own Trade-Off Analysis

Finding Entangled Dimensions

Coupling

Analyze Coupling Points Assess Trade-Offs Trade-Off Techniques

Qualitative versus Quantative Analysis MECE Lists The “Out of Context” Trap Model Relevant Domain Cases Prefer Bottom Line over Overwhelming Evidence Avoiding Snake Oil and Evangelism

Sysops Squad Saga: Epilog

A. Appendix A

Concept and Term References Architecture Decision Record References Trade-Off Table References

Index

← Prev
Back
Next →

← Prev
Back
Next →