Software Architecture Patterns, Antipatterns, and Pitfalls. Understanding Trade-Offs Mark Richards, Neal Ford, Raju Gandhi

Software Architecture Patterns, Antipatterns, and Pitfalls. Understanding Trade-Offs Mark Richards, Neal Ford, Raju Gandhi - okladka książki

Autorzy:: Mark Richards, Neal Ford, Raju Gandhi
Wydawnictwo:: O'Reilly Media (Z chęcią przeczytam książkę w języku polskim)
Ocena:: Bądź pierwszym, który oceni tę książkę
Stron:: 580
Dostępne formaty:: ePub

Mobi

Ebook

211,65 zł ~~249,00 zł~~ (-15%)

239,00 zł najniższa cena z 30 dni

Dodaj do koszyka Dostępny natychmiast po opłaceniu zakupu lub Kup na prezent Kup 1-kliknięciem

Przenieś na półkę

Do przechowalni

Kup w zestawie z dodatkowym rabatem

Software Architecture Patterns, Antipatterns, and Pitfalls. Understanding Trade-Offs Mark Richards, Neal Ford, Raju Gandhi

Head First Software Architecture Raju Gandhi, Mark Richards, Neal Ford

Fundamentals of Software Architecture. 2nd Edition Mark Richards, Neal Ford

Cena zestawu: 637.93 zł

Zyskujesz: 189.07 zł (-23%)

Dodaj do koszyka

As software systems grow in complexity and scale, choosing the right architectural pattern is critical to meeting performance, agility, and operational demands. In this book, Mark Richards, Neal Ford, and Raju Gandhi detail modern software architecture patterns and the antipatterns and pitfalls to avoid. Unique star-chart ratings for each pattern let you see at a glance how well it supports architectural capabilities such as scalability, resilience, and maintainability. You'll learn which patterns apply to different contexts, such as microservices or event-driven architectures, and how to evaluate trade-offs to select the right pattern for your system's needs.

Architects, software developers, and technical leaders will find new insights and tools for AI use, governance, and aligning architecture with domain and business needs.

Understand the core principles, strengths, and limitations of key architecture patterns and the antipatterns to avoid
Select and apply appropriate architecture patterns based on business and technical requirements
Analyze and compare architectural trade-offs to make informed decisions about how patterns affect capabilities
Use metrics and fitness functions to modernize governance
Design cohesive, resilient, and evolvable systems using proven patterns and modern industry practices

O autorach książki

Mark Richards jest doświadczonym architektem oprogramowania. Zajmuje się projektowaniem i wdrażaniem mikrousług oraz innych systemów o architekturze rozproszonej. Założył tematyczny serwis dla programistów — Developer to Architect.

Neal Ford jest architektem aplikacji w ThoughtWorks, międzynarodowej firmie konsultingowej z branży IT. Jest autorem programów komputerowych, artykułów i książek z dziedziny informatyki. Udziela konsultacji w zakresie projektowania i budowania dużych aplikacji korporacyjnych, a także prowadzi internetowe wykłady dla wojska i wielu firm z całego świata, wpisanych na listę „Fortune 500”.

Raju Gandhi jest architektem, konsultantem, autorem i prelegentem. Biegle posługuje się różnymi językami programowania i paradygmatami. Wierzy w prostotę.

Mark Richards, Neal Ford, Raju Gandhi - pozostałe książki

Ebooka "Software Architecture Patterns, Antipatterns, and Pitfalls. Understanding Trade-Offs" przeczytasz na:

czytnikach Inkbook, Kindle, Pocketbook, Onyx Boox i innych
systemach Windows, MacOS i innych

systemach Windows, Android, iOS, HarmonyOS
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi

Masz pytania? Zajrzyj do zakładki Pomoc »

Oceny i opinie klientów: Software Architecture Patterns, Antipatterns, and Pitfalls. Understanding Trade-Offs Mark Richards, Neal Ford, Raju Gandhi

(0)

Szczegóły książki

ISBN Ebooka:: 979-83-416-6390-9, 9798341663909
Data wydania ebooka :: 2026-10-29 Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@ebookpoint.pl.
Język publikacji:: angielski
Rozmiar pliku ePub:: 13.3MB
Rozmiar pliku Mobi:: 13.3MB

Zgłoś erratę

Dostępność produktu

Produkt nie został jeszcze oceniony pod kątem ułatwień dostępu lub nie podano żadnych informacji o ułatwieniach dostępu lub są one niewystarczające. Prawdopodobnie Wydawca/Dostawca jeszcze nie umożliwił dokonania walidacji produktu lub nie przekazał odpowiednich informacji na temat jego dostępności.

Spis treści książki

Preface
- How to Read This Book
  - Architecture Patterns Catalog
  - As a Narrative
  - Cross-Cutting References
- Conventions Used in This Book
- OReilly Online Learning
- How to Contact Us
- Acknowledgments
  - Acknowledgments from Mark Richards
  - Acknowledgments from Neal Ford
  - Acknowledgments from Raju Gandhi
1. Introduction: Fundamental Patterns and Antipatternswith Some Pitfalls
- Styles Versus Patterns
- Architecture Patterns Versus Design Patterns
- Antipatterns
- Pitfalls
- The Pattern, Antipattern, Pitfall Spectrum
- How Is This Book Different from Other Patterns Books?
- Qualitative Analysis
  - Building Qualitative Analysis
  - Building Quantitative Analysis
- How to Use Chapter 2, Capability and Context Cross-Reference
- Common Definitions
2. Capability and Context Cross-Reference
- Patterns by Capability
  - Adaptability
  - Agility
  - Atomicity
  - Auditability
  - Availability
  - Bandwidth Usage
  - Cost
  - Data Consistency
  - Data Integrity
  - Debuggability
  - Deployability
  - Domain Alignment
  - Elasticity
  - Error Handling
  - Evolvability
  - Fault Tolerance
  - Flexibility
  - Initial Time to Market
  - Maintainability
  - Message Processing Order
  - Modularity
  - Performance
  - Responsiveness
  - Reusability
  - Scalability
  - Simplicity
  - Testability
  - Throughput
  - Workflow
- Patterns by Context
  - Agentic Code Generation
  - Architectural Styles
  - Caching
  - Contracts
  - Data
  - Decision Making
  - Event-Driven Architecture
  - Event Granularity
  - High-Volume Processing
  - Integration Architecture
  - Iterative Architecture
  - Layered Architecture
  - Message-Based Architectures
  - Microservices
  - Modularity
  - Monolithic Architectures
  - Multiple User Interfaces
  - Service Granularity
  - Workflow
3. Ambulance Pattern
- How Do I Prioritize My Messages?
- Applying the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
4. Architecture by Implication Antipattern
- When Do I Need an Architecture?
- Why Is This an Antipattern?
- How to Avoid This Antipattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- Am I in This Antipattern?
- Related Patterns, Antipatterns, and Pitfalls
5. Architecture Sinkhole Antipattern
- When Should I Open Layers in a Layered Architecture?
- Why Is This an Antipattern?
- How to Avoid This Antipattern
  - Opening Layers
  - Consider a Different Architecture Style
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- Am I in This Antipattern?
- Related Patterns, Antipatterns, and Pitfalls
6. Async Chain of Persistence Pattern
- How Do I Prevent Message Loss?
  - Event-Driven Versus Message-Based Systems
  - Where Messages Can Get Lost
    - Receiving a message
    - The message broker crashes
    - Event chaining
- Applying the Pattern
  - Message Persistence
  - Client Acknowledgement Mode
  - Synchronous Send
  - Last Participant Support
  - Conflicting Patterns
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
7. Backend for Frontend Pattern
- How Can I Support Multiple User-Interface Types?
- Applying the Pattern
  - BFF Granularity
  - The Place for Specialized Data Query Languages
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
8. Cache Aside Pattern
- How Do I Improve Both Performance and Scalability?
- Applying the Pattern
  - Reads
  - Writes/Updates
  - The Cache Is Not in the Critical Path
  - Handling Cache Failures
  - Write-Around Caching Pattern Variant
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
  - Caching Topologies
  - Caching Topology Comparison
    - Improved
    - Degraded
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
9. Choreography Pattern
- How Should I Manage My Workflows?
- Applying the Pattern
  - What Happens When Everything Works
  - What Happens When an Error Occurs?
  - Implementing the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
  - Communication (Synchronous Versus Asynchronous)
    - Unchanged
    - Improved
    - Degraded
  - Atomicity (Data Consistency and Integrity)
    - Unchanged
    - Improved
    - Degraded
  - Architecture Quantum
- How to Govern This Pattern
  - Governing Communication
  - Cumulative Responsibility
- Related Patterns, Antipatterns, and Pitfalls
10. Command Query Responsibility Segregation (CQRS) Pattern
- How Can I Optimize My Data for Reads and Writes?
- Applying the Pattern
  - Implementing the Pattern
  - Single Service for Both Command and Query
  - Separate Services for Command and Query
    - A note on eventual consistency
    - The read-your-own-writes challenge
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
  - Team Topologies
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
11. Compensating Updates Pattern
- How Do I Roll Back a Distributed Transaction?
- Applying the Pattern
  - What Happens When Everything Works Correctly?
  - Compensating Update Failures
  - Implementing the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
  - Failure to Achieve the Compensating Update
  - What Level of Consistency Is Proper?
- Related Patterns, Antipatterns, and Pitfalls
12. Contextual Events Pattern
- How Many Events Should I Trigger from a Single Service?
- Applying the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
13. Cross-Cutting State Pattern
- How Should I Manage My Workflow State?
- Applying the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
14. Data-Based Event Contract Pattern
- How Much Data Should I Include in the Event Payload?
- Applying the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
15. Domain-Broker Pattern
- How Many Brokers Should I Have in My Distributed Architecture?
- Applying the Pattern
  - Implementing the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
  - Architecture Quantum
  - Workflow State
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
16. Event Sourcing Pattern
- Should I Capture My Data as an Event Stream?
- Applying the Pattern
  - Identifying Events and Aggregates
  - Domain Events
  - Event Store Structure
  - Reading Events
  - Writing Events
    - Command handler
    - Validation
    - Event generation
    - Persistence
  - Handling Concurrency
  - Schema Evolution
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
  - Consistency Model and Atomicity
  - Event Volume and Scale
  - Architecture Quantum
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
17. Explicit Workflow State Pattern
- How Should I Manage My Workflow State?
- Applying the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
18. Extensible Events Pattern
- Should I Trigger an Event If No One Is Listening for It (Yet)?
- Applying the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
19. Front Controller Pattern
- How Do I Handle Mediation Without an Explicit Orchestrator?
- Applying the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
20. Frozen Caveman Pitfall
- Should I Only Base My Decisions on Past Experiences?
- Why Is This a Pitfall?
- How to Avoid This Pitfall
  - Developing a Personal Radar
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
      - Process capabilities
      - Operational capabilities
      - Business impact
- Influences
- Related Patterns, Antipatterns, and Pitfalls
21. Grains of Sand Pitfall
- Are My Services Too Small?
- Why Is This a Pitfall?
- How to Avoid This Pitfall
  - Granularity Disintegrators
    - Service scope and function
    - Code volatility
    - Scalability and throughput
    - Fault tolerance
    - Security
    - Evolvability
  - Granularity integrators
    - Database transactions
    - Data relationships
    - Shared code
    - Workflow and choreography
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- Related Patterns, Antipatterns, and Pitfalls
22. Implicit Workflow State Pattern
- How Should I Manage My Workflow State?
- Applying the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
23. Key-Based Event Contract Pattern
- How Much Data Should I Include in the Event Payload?
- Applying the Pattern
  - Data Access Considerations
  - Anemic Events
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
  - Monolithic Database Topology
  - Domain-Based Database Topology
  - Database-Per-Service Database Topology
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
24. Microservice All the Things Pitfall
- Should I Make Everything a Microservice?
- Why Is This a Pitfall?
- How to Avoid This Pitfall
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- Related Patterns, Antipatterns, and Pitfalls
25. Multi-Broker Pattern
- How Can I Improve Message Throughput and Capacity?
- Applying the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
26. Nexus Architecture Pattern
- How Do I Manage Cross-Cutting Concerns?
  - Service Mesh and Sidecar
  - Data Mesh and Cooperative Quantum
  - Agentic Mesh, LLMs, and MCP
  - Nexus Architecture
- Aspect-Oriented Architecture?
- Applying the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
27. Orchestration Pattern
- How Should I Manage My Workflows?
- Applying the Pattern
  - The Case Where Everything Works
  - The Case Where Something Breaks
  - Hybrids
  - Implementing the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
  - Communication (Synchronous Versus Asynchronous)
    - Unchanged
    - Improved
    - Degraded
  - Atomicity (Data Consistency and Integrity)
    - Unchanged
    - Improved
    - Degraded
  - Architecture Quantum
- How to Govern This Pattern
  - Intraservice Communication
  - Granularity
- Related Patterns, Antipatterns, and Pitfalls
28. Overcentralization Antipattern
- When Should I Use Global Coupling?
- Why Is This an Antipattern?
- How to Avoid This Antipattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- Am I in This Antipattern?
- Related Patterns, Antipatterns, and Pitfalls
29. Read-Through/Write-Through Cache Pattern
- When Using Caching, How Do I Optimize Data Consistency?
- Applying the Pattern
  - Implementing the Pattern
  - Reads
  - Writes/Updates
  - Things of Note
    - Loader and store implementation
    - Cache in the critical path
  - Write-Behind Cache Pattern Variant
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
  - Caching Topology Comparison
    - Improved
    - Degraded
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
30. Service Sharding Pattern
- How Should I Implement Atomicity in My Distributed Architectures?
- Applying the Pattern
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
  - Service Granularity
  - Architecture Quantum
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
31. Stamp Coupling Antipattern
- How Specific Should My Contract Be?
- Why Is This an Antipattern?
  - Contract Management
  - Network Bandwidth Usage
- How to Avoid This Antipattern
  - Consumer-Driven Contracts
  - URL Filtering for Query Requests
  - Loose Contracts
  - GraphQL
  - Key-Based Payloads
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- Am I in This Antipattern?
  - Payload Size and Message Volumes
  - Rate of Contract Change
- Related Patterns, Antipatterns, and Pitfalls
32. Stovepipe Architecture Antipattern
- How Do I Iterate on an Architecture?
- Why Is This an Antipattern?
- How to Avoid This Antipattern
  - Greenfield Systems
  - Brownfield Systems
    - When changes require service orchestration
    - When changes involve new data requirements
    - When adding behavior to existing services
    - Repairing a monolithic stovepipe architecture
    - Repairing a distributed Stovepipe Architecture
  - Iterative Architecture and Residuality Theory
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- Am I in This Antipattern?
- Related Patterns, Antipatterns, and Pitfalls
33. Supervisor Consumer Pattern
- How Can I Improve Throughput and Scalability?
- Applying the Pattern
  - Consistent Response Time
  - Macro Variant
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
34. Thread Delegate Pattern
- How Can I Guarantee Message Processing Order?
- Applying the Pattern
  - Assign a Message to a Thread
  - Process Messages
  - Update the Allocation Map
  - Running Out of Threads
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
35. Workflow Event Pattern
- How Do I Handle Asynchronous Errors?
- Applying the Pattern
  - Workflow Event Processor
    - Using agentic AI in the Workflow Processor
    - Dead letter queue
  - Manual Intervention (Dashboard)
- Trade-Offs
  - Pros
  - Cons
  - Comparison Chart
    - Improved
    - Degraded
- Influences
- How to Govern This Pattern
- Related Patterns, Antipatterns, and Pitfalls
36. Build Your Own Pattern Analysis
- Evaluating Trade-Offs for Patterns
  - Choosing Capabilities
  - Identifying Influences
  - Stars and Other Icons
    - Five stars
    - When not to use stars
    - Reflect what you want to measure
  - Using a Zettelkasten (Slip Box)
  - Evaluating Your Own Patterns
    - Identify union of capabilities
    - Improved/degraded
- From Qualitative to Quantitative Analysis
- The Value of Patterns
37. Fundamental Definitions
- ACID Versus BASE
  - Atomicity
  - Consistency
  - Isolation
  - Durability
  - Faking Parts of ACID
- Architecture Quantum
  - Defined
  - Architecture Quantum Coupling
    - Three types of quantum coupling
    - Static coupling
    - Dynamic coupling
    - Atomic coupling
    - Composite types of coupling
      - Contract coupling
      - Temporal coupling
- Events Versus Messages
- Automating Architectural Governance: Fitness Functions
Index