Software Architecture: The Hard Parts: Modern Trade-Off Analysis for Distributed Architectures
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 to succeed. 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–the authors 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 discoverand weigh the trade-offs as you confront the issues you face as an architect. You will:
- 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
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 Dehghani 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 Architectural Decision Records Architecture Fitness Functions Using Fitness Functions Architecture Versus Design: Keeping Definitions Simple Introducing the Sysops Squad Saga Nonticketing 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 Codebase Decomposable? Afferent and Efferent Coupling Abstractness and Instability 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 Interservice 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 Workflow State Management Trade-Offs Between Orchestration and Choreography State Owner and Coupling Sysops Squad Saga: Managing Workflows 12. Transactional Sagas Transactional Saga Patterns Epic Saga(sao) Pattern 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 Sysops Squad Saga: Atomic Transactions and Compensating Updates 13. Contracts Strict Versus Loose Contracts Trade-Offs Between Strict and 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: Epilogue A. Concept and Term References B. Architecture Decision Record References C. Trade-Off References Index
How to download source code?
1. Go to:
2. Search the book title:
Software Architecture: The Hard Parts: Modern Trade-Off Analysis for Distributed Architectures, sometime you may not get the results, please search the main title
3. Click the book title in the search results
Publisher resources section, click
Download Example Code.
1. Disable the AdBlock plugin. Otherwise, you may not get any links.
2. Solve the CAPTCHA.
3. Click download link.
4. Lead to download server to download.