Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Architecture Patterns with Python

Architecture Patterns with Python

Enabling Test-Driven Development, Domain-Driven Design, and Event-Driven Microservices
Make Python systems easier to test and change, while keeping business rules out of infrastructure.
by Harry Percival 2020 280 pages
4.40
497 ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Model business behavior before designing database tables

Start with the work. A domain model is a useful representation of the problem a business needs software to solve. The authors use furniture allocation: stock may be in a warehouse or on a ship expected months later, and the system must decide which batch can fulfill an order. Starting with tables risks treating the data as the problem, when the real job is deciding what the software should do.

Let rules shape storage. The first allocation rules are concrete: match the product SKU, do not allocate more than a batch contains, prefer warehouse stock, then choose the earliest arriving shipment. These rules describe behavior that stakeholders recognize. The database should support that model, rather than dictate it.

Analysis

The central distinction is between representing a business and merely recording its nouns. A stock table can store quantities, but it cannot by itself explain which shipment should satisfy an order or what counts as a valid allocation. Starting with behavior makes disagreements visible before they become migrations and production bugs. The approach is most valuable when rules change or interact. For a basic record-keeping app, the added modeling effort may buy little, so complexity should be earned by a real need.

Use the business's own language to name rules, objects, and failures

Share a working vocabulary. In Domain-Driven Design, the ubiquitous language is the common terminology used by business experts and developers. For the allocation system, a SKU identifies a product, an order contains lines, and batches hold stock. Tests named in those terms can describe the intended behavior to technical and nontechnical teammates alike.

Choose types by identity. A value object, such as an order line, is defined by its data and is usually immutable. An entity, such as a batch, has a durable identity even when its quantity or arrival date changes. A domain service is a business operation that does not naturally belong on either kind of object. In Python, that operation can simply be a function.

Analysis

Naming is a design tool, not decoration. When tests use the same distinctions stakeholders use, they can expose mismatched assumptions early: for example, whether an order line is identified by its values or by a separate durable identifier. That shared vocabulary also has limits. A familiar word can mean different things to purchasing and logistics, so a glossary is not enough by itself. Concrete examples and explicit business rules keep the language from becoming a polished label for unresolved ambiguity.

Keep business decisions pure and make infrastructure depend inward

Protect the decision-making core. The Dependency Inversion Principle says high-level business code should not depend on low-level details such as databases or web frameworks. The book’s filesystem synchronizer illustrates the payoff: instead of mixing directory scans, file changes, and decisions, it represents files as simple mappings and returns proposed actions. This Functional Core, Imperative Shell structure keeps the decision function separate from I/O.

Hide storage behind a repository. A Repository presents persistent data as though it were an in-memory collection. The domain code can ask for or add a batch without knowing whether data comes from SQLAlchemy, a fake in-memory set, or CSV files. The ORM maps to the domain model, not vice versa, so storage technology remains replaceable.

Analysis

This architecture treats infrastructure as an implementation choice and business policy as the reason the system exists. That reversal creates a useful test: can the central decision be exercised without booting a database, web server, or filesystem? A small fake repository is an especially practical check because a clumsy fake often reveals an abstraction that is too broad. Still, every boundary has a maintenance cost. The pattern is justified when a domain is difficult to change, not as a ceremonial layer around every database table.

Test use cases at the service boundary, not only through HTTP

Give workflows a clear entrance. The Service Layer defines application use cases, such as allocating a line, checking whether its SKU exists, and committing the result. A Flask endpoint can then focus on HTTP details: parse JSON, invoke the use case, and format the response. The same use case can serve a command-line tool or another adapter.

Match tests to the question. In one example, the suite has 15 unit tests, 8 integration tests, and 2 end-to-end tests. Most workflow cases use a fake repository and run quickly; a small number of HTTP tests verify that the pieces connect. The authors call it high gear to test routine changes at the service boundary, and low gear to test the domain model directly when shaping a new or difficult rule.

Analysis

A test suite is also a map of the system's public promises. Service-level tests capture what a user-facing operation does without binding every assertion to the model's internal arrangement. Low-level tests still matter: they give sharp feedback while a rule is being designed. The useful question is not whether tests should be high or low, but what uncertainty each test resolves. A service-only strategy can obscure faulty domain design, while too many implementation-specific tests can turn refactoring into a test-editing exercise.

Make each aggregate the smallest unit that must stay consistent

Draw a consistency boundary. An aggregate is a cluster of related domain objects that changes as one unit, with a root object responsible for enforcing their shared rules. In the example, a Product contains the batches for one SKU. Its allocation operation prevents the same order line from being assigned twice and keeps available stock from becoming negative. A repository should return aggregates, making the root the controlled entrypoint to its contents.

Commit the whole operation. The Unit of Work groups changes into an atomic update: it provides the repository, commits explicitly on success, and rolls back by default otherwise. For simultaneous allocations, a Product version number can let one transaction succeed and reject a conflicting update. The losing operation can retry against the newly committed state.

Analysis

Aggregate design joins business rules to database concurrency. Choosing one Product per SKU means two products can be updated independently, while competing allocations for the same product must be coordinated. That boundary is a deliberate performance and correctness decision, not a natural fact waiting to be discovered. If the chosen aggregate grows too large, or routinely creates contention, the boundary may need revision. Explicit commits reinforce a valuable default: unfinished work should not silently become permanent.

Turn secondary reactions into events instead of stuffing them into workflows

Record facts, route reactions. A domain event is a data object describing something that happened, such as stock being unavailable. The model records the event without sending email or knowing about an email service. A Message Bus maps event types to handlers, which can notify the buying team or initiate another operation. This keeps the allocation rule separate from optional reactions to it.

Use events to continue a process. When a batch quantity falls below what has already been allocated, the Product can release affected order lines and emit allocation requests. A handler can process each request in its own unit of work. This avoids one sprawling operation that must modify every related object at once, while making the workflow easier to extend with additional handlers.

Analysis

Events make causal links explicit without giving the original operation ownership of every consequence. That separation is useful when notifications or follow-up work should not determine whether the core transaction succeeds. It also shifts complexity rather than eliminating it: a workflow spread across handlers can be harder to trace than a single function. Event names, handler responsibilities, and observability therefore matter. The pattern earns its keep when several distinct reactions must respond to a business fact.

Treat commands as requests and events as facts with different failure rules

Separate intent from outcome. A command asks a specific handler to do something, so it uses an imperative name such as CreateBatch. The requester needs to know if it failed. An event reports a fact, such as a batch quantity having changed, and can be sent to every interested handler. Its name describes what happened, not what someone hopes will happen.

Let failures follow responsibility. A command handler fails noisily because the requested operation must either succeed or report an error. Event handlers can fail independently: the system logs the problem and may retry, without undoing a successfully completed command. In the book’s allocation example, creating an order is essential; sending a later notification is not allowed to block it.

Analysis

This distinction is a compact way to decide what must be atomic and what can recover separately. It also clarifies how a system communicates responsibility: commands have an initiator awaiting a result, while events have consumers that may not be known in advance. The separation is not automatic protection against failure. Retried handlers need careful behavior, and logs alone do not guarantee recovery. The model works when the business accepts that follow-up actions can lag or fail without invalidating the original transaction.

Integrate services through business events, not chains of synchronous calls

Model processes, not just nouns. Splitting an organization into a service for orders, another for batches, and another for warehouses can produce tangled dependencies. One workflow may call from Orders to Batches to Warehouse, while a damaged shipment triggers the reverse path. These synchronous chains also couple availability: one struggling service can prevent another from completing its work.

Decouple timing. Event-driven integration lets each service own a business process and publish facts for others to consume. Services can fail and recover separately, accepting eventual consistency between them. Domain-Driven Design calls a boundary around a distinct model a bounded context; the Product model in allocation need not match the ecommerce site's richer product model. The book warns that real brokers, message ordering, delivery, and replay require deliberate design.

Analysis

The important shift is from organizing services around database-shaped nouns to assigning ownership of business decisions. A message contract then couples services less tightly than an agreed call sequence, but it does not erase dependencies: consumers still rely on event names and fields, and delayed information changes user experience. Eventual consistency is therefore a product decision as well as a technical one. It suits workflows where independent recovery matters and temporary disagreement is tolerable, not every interaction.

Give reads a separate model when write logic makes queries clumsy

Separate questions from changes. Command-Query Separation says an operation should either change state or answer a question, not both. Command-Query Responsibility Segregation applies that idea to the system's read and write paths. The allocation model is built to enforce rules when assigning stock; it is awkward for a customer-facing view of all items in an order. A direct query or a dedicated read model can serve that view more simply.

Optimize for actual traffic. The example contrasts roughly 100 orders per hour with about 100 product views per second on a busy day. Reads may tolerate stale results, while allocation must check current stock before committing. An event handler can update a denormalized read table or Redis view, which can be rebuilt from the write-side state if necessary.

Analysis

Read and write paths answer different questions under different constraints. A write model protects invariants; a read model can be shaped for the screen or query people actually need. This is a reason to separate them, not a mandate to create a second database immediately. The book’s stale-stock example also shows why perfect freshness at page-render time cannot guarantee a later purchase. The write operation must remain authoritative, and the product experience must have a plan for unavailable stock.

Validate message shape at the edge, but leave business meaning in the domain

Validate the right thing in the right place. The book distinguishes syntax, semantics, and pragmatics. Syntax checks that a command has fields such as order ID, SKU, and positive quantity. Semantic preconditions check facts such as whether a product exists. Pragmatic rules determine whether the requested action is possible under current business conditions, such as whether enough stock remains. These concerns belong at the message boundary, in the handler, and in the domain model, respectively.

Read only what you need. The Tolerant Reader pattern means accepting the fields a service depends on while ignoring irrelevant additions. An allocation service should treat a SKU as an identifier, not reject a new naming format invented by procurement. Outbound messages should be carefully formed, but overly strict inbound schemas can make independently changing services brittle.

Analysis

Validation is often discussed as one large defensive wall, but separating structure, preconditions, and business rules makes each failure easier to explain. Tolerant reading is especially useful when teams deploy independently because one service can add an unused field without breaking its consumers. Its limit is equally important: leniency should not mean accepting malformed data or hiding contract violations. The right stance depends on who controls the interface and what the receiving system can safely ignore.

Assemble dependencies once, then pass configured handlers to the application

Make dependencies visible. A handler that receives a Unit of Work or notification sender as an argument depends on an abstraction, rather than silently importing a specific database or email implementation. Tests can supply fakes; production can supply real adapters. This avoids repeatedly patching imports in tests and ties fewer tests to implementation details.

Centralize assembly. A bootstrap script, also called a composition root, creates the real dependencies, performs initialization such as ORM setup, and builds a configured message bus. The book shows manual injection through closures or partial functions, while noting that a framework may be useful when dependency chains become more involved. Python does not require a large container to make dependencies explicit.

Analysis

Centralized assembly helps separate the question of what a handler needs from the question of which implementation the running application uses. That is particularly useful when tests, web entrypoints, and message consumers need different configurations. Manual wiring also keeps the dependency graph inspectable. The danger is building machinery before there is enough repetition to justify it. A small bootstrap module is a boundary; a home-grown injection framework can become a new system to maintain.

Refactor legacy systems one use case at a time, not by decree

Start with a specific pain. The epilogue recommends identifying a concrete problem, such as slow tests, risky changes, or an unclear workflow, then extracting one use case into a clearer service boundary. In an overgrown collaboration platform, introducing command handlers first made the system's operations visible, even though the initial handlers were still messy. The team could then separate data access, domain rules, and I/O in stages.

Replace without a big-bang rewrite. The Strangler Fig approach builds a new system around the old one, intercepts selected events, and gradually transfers responsibility. The authors describe replacing slow XML-RPC stock synchronization with an event-driven availability service; its read API reached 2 to 3 milliseconds in the reported case. These patterns are tools, not prerequisites for a simple CRUD app.

Analysis

Incremental refactoring is more than a compromise: it turns architecture into a sequence of testable bets. A team can demonstrate that one extracted workflow is easier to change before asking for a broad redesign. The case study also ties performance gains to a specific read model and workload, rather than claiming that event-driven systems are inherently faster. A migration still needs operational safeguards, clear ownership, and a way to compare old and new behavior. Architecture should follow the problem, not become the project.

Analysis

The book's unifying argument is that architecture is a way to manage the cost of change. Its patterns are not presented as a universal blueprint. They form a sequence of boundaries: domain objects separate business rules from infrastructure; repositories separate storage from the model; service layers name use cases; units of work define atomic updates; aggregates identify what must remain consistent; events connect work that need not happen in one transaction. The later move toward asynchronous services and separate read models extends the same logic across organizational and traffic boundaries.

The strongest practical insight is that these boundaries should correspond to real differences in responsibility. A Product aggregate is not useful because aggregates are fashionable, but because competing allocations for one SKU must respect shared stock. A dedicated read model is not automatically superior, but it can be when customer queries and transactional rules have sharply different needs. This makes the book's repeated attention to trade-offs essential: abstraction reduces some forms of coupling while adding code, concepts, and operational obligations.

There is also a subtle tension between architectural clarity and distributed-system visibility. Events allow independent failure and evolution, but a business process spread across handlers is harder to follow than a single call stack. The authors acknowledge this and emphasize logging, retries, replay, idempotency, and reliable brokers as production concerns. Those are not optional polish. They are part of the price of temporal decoupling.

The testing advice follows the same conditional logic. Service-level tests provide broad confidence with low infrastructure cost, while model tests offer sharper feedback during design. Neither level can substitute completely for integration checks. The most durable reading is therefore not to copy the example architecture wholesale, but to use its questions: What is the business rule? What must change atomically? Which details should be replaceable? What can fail independently? Where is the simplest test boundary? Those questions turn patterns into decisions rather than rituals.

Summary in 30 Seconds
Model business rules in the language stakeholders use, and keep them independent of databases and web frameworks. Put workflows behind service boundaries, test most use cases there, and use focused model tests for difficult rules. Define consistency around the smallest group of data that must change together. Events let secondary work proceed independently, but require retries, logging, and careful delivery design. Separate read models when query needs diverge from transactional rules.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.40 out of 5
Average of 497 ratings from Goodreads and Amazon.

Architecture Patterns with Python receives high praise for its practical approach to Domain-Driven Design and software architecture. Readers appreciate its clear explanations, real-world examples, and balanced perspective on different patterns. The book is commended for its focus on Test-Driven Development and its engaging writing style. Many find it valuable for both beginners and experienced developers, offering insights into building scalable and maintainable Python applications. Some readers note that the approach may be overly complex for certain situations, but overall, the book is highly recommended for those interested in improving their software design skills.

Your rating:
4.63
491 ratings
Want to read the full book?

Glossary

Domain Model

Business rules in code

A representation of the business problem and the rules that govern it. In the allocation example, the model describes batches, order lines, stock availability, and how an order line can be assigned. It is designed to express useful business behavior, rather than merely mirror database tables or external frameworks.

Ubiquitous Language

Shared domain vocabulary

The terminology used consistently by business experts and developers when discussing a domain. Terms such as SKU, batch, and allocation become names in tests and code, helping the software express agreed business rules. The vocabulary is developed through discussion and concrete examples, not simply imposed as a list of labels.

Value Object

Identity comes from values

A domain object whose attributes completely determine what it is. Two order lines with the same order ID, SKU, and quantity are equivalent; changing one of those values creates a different value object. Value objects are commonly immutable, which makes equality and their use in sets or dictionary keys easier to reason about.

Entity

Persistent identity over time

A domain object that remains the same identifiable thing even when its attributes change. A batch can receive a different ETA or have its stock allocated while remaining the batch identified by its reference. Entity equality should therefore be based on the attribute that defines its continuing identity, rather than every current field.

Repository pattern

Storage behind a collection-like API

An abstraction over persistent storage that lets application code retrieve and add domain objects without knowing how they are stored. Its interface can resemble an in-memory collection. A SQL-backed repository and a simple fake can satisfy the same contract, allowing tests and infrastructure choices to change without rewriting domain rules.

Service Layer pattern

Named application use cases

A layer that defines the operations an application offers and coordinates the steps needed to perform them. A service-layer allocation use case retrieves data, checks relevant preconditions, calls domain behavior, and commits changes. Web handlers can then remain focused on HTTP, while other entrypoints can invoke the same use cases.

Unit of Work pattern

Atomic group of changes

An abstraction that groups data access and modifications into one operation that can be committed or rolled back as a unit. It commonly provides access to repositories and manages a database session. In the book's design, explicit commit is required, while uncommitted work is rolled back when the context ends.

Aggregate

Domain consistency boundary

A cluster of associated domain objects treated as one unit for changes, with a root that controls access and enforces rules across the cluster. The allocation example uses a Product containing batches for one SKU. The aggregate boundary helps determine which data must be loaded and updated together and where concurrency must be managed.

Domain Event

A fact that happened

A data object recording an occurrence in the business domain, such as stock being unavailable or an order line being allocated to a batch. Events are named as facts, not instructions. A model or handler can record an event, after which interested handlers may perform notifications, follow-up work, or integration with other services.

Message Bus

Routes messages to handlers

A component that dispatches commands or events to the functions responsible for handling them. In the book's internal design, it uses message types to select handlers and can process new events emitted during a workflow. It coordinates routing, but the business meaning of each message belongs to the model and its handlers.

Command

A request for action

A message expressing an actor's intent for a specific operation, such as allocating stock or creating a batch. It is typically sent to one handler, and failure must be reported to the requester. Commands are named imperatively, distinguishing them from events, which describe facts that have already occurred.

Command-Query Responsibility Segregation

Separate read and write paths

An architectural approach that separates operations which change state from those that retrieve information. The write side can use a rich domain model to enforce rules, while the read side can use direct queries or a denormalized view shaped for particular requests. The two sides may differ in consistency requirements and storage design.

Functional Core, Imperative Shell

Pure decisions, explicit I/O

A design approach that keeps decision-making logic separate from operations that interact with external state. The functional core transforms simple inputs into decisions or actions; the imperative shell gathers data, invokes that logic, and applies its outputs through I/O. This structure makes central rules easier to test without setting up the external systems.

Tolerant Reader

Read only required fields

An integration approach in which a message consumer extracts the fields it needs and avoids rejecting harmless additional information. It supports independent evolution of communicating services, since a producer can add fields without breaking consumers that do not use them. It does not mean accepting malformed required data or ignoring errors that affect correctness.

FAQ

What's Architecture Patterns with Python about?

  • Focus on Software Architecture: The book delves into architectural patterns tailored for Python, emphasizing Test-Driven Development (TDD), Domain-Driven Design (DDD), and event-driven microservices.
  • Real-World Application: It uses practical examples from the authors' experiences at MADE.com to illustrate managing complexity in software systems.
  • Framework Agnostic: While discussing frameworks like Flask and SQLAlchemy, the principles are applicable across various technologies and languages.

Why should I read Architecture Patterns with Python?

  • Improve Software Design: The book offers insights into structuring applications for enhanced testability and maintainability, crucial for long-term software health.
  • Learn from Experts: Authored by experienced software architects Harry Percival and Bob Gregory, it provides practical advice grounded in real-world scenarios.
  • Comprehensive Coverage: It covers a range of architectural patterns, making it valuable for both beginners and experienced developers.

What are the key takeaways of Architecture Patterns with Python?

  • Understanding Architectural Patterns: Readers learn about patterns like Repository, Unit of Work, and Event-Driven Architecture, and their implementation in Python.
  • Emphasis on TDD and DDD: The book highlights the importance of TDD and DDD in managing complexity and ensuring accurate business logic representation.
  • Event-Driven Systems: It discusses building systems that respond to events, allowing for flexible and decoupled architectures.

What are the best quotes from Architecture Patterns with Python and what do they mean?

  • "Events are simple dataclasses...": This quote emphasizes the role of events in capturing and communicating changes within an event-driven architecture.
  • "We use events as our data structure...": It illustrates how events serve as both input data and a means to trigger internal processes, enhancing modularity.
  • "Our ongoing objective with these architectural patterns...": This underscores managing complexity in software design, ensuring applications remain manageable as they grow.

What is the Repository pattern as described in Architecture Patterns with Python?

  • Abstraction Over Data Storage: The Repository pattern abstracts data access, keeping the domain model independent of the underlying data storage technology.
  • Simplifies Testing: By using repositories, developers can easily mock data access in tests, leading to faster and more reliable unit tests.
  • Encourages Separation of Concerns: This pattern maintains a clean separation between domain logic and data access logic, making the codebase easier to manage.

How does the Unit of Work pattern work in Architecture Patterns with Python?

  • Atomic Operations: The Unit of Work pattern groups multiple operations into a single transaction, ensuring all changes are committed or rolled back together.
  • Context Manager: Implemented as a context manager in Python, it simplifies the management of database sessions and transactions.
  • Integration with Repositories: It collaborates with repositories to provide a cohesive interface for data access while maintaining transactional integrity.

What is Domain-Driven Design (DDD) and how is it applied in Architecture Patterns with Python?

  • Focus on Business Logic: DDD emphasizes modeling software based on the business domain, ensuring code reflects real-world processes and rules.
  • Ubiquitous Language: The book stresses using a common language between developers and domain experts to avoid misunderstandings and ensure clarity.
  • Aggregates and Consistency Boundaries: DDD introduces aggregates, clusters of related objects treated as a single unit for data changes, maintaining consistency.

What are Domain Events and how are they used in Architecture Patterns with Python?

  • Capturing State Changes: Domain Events represent changes in the system, allowing different application parts to react without tight coupling.
  • Event-Driven Architecture: The book illustrates using events to trigger workflows and actions across system components, promoting a decoupled architecture.
  • Integration with Message Bus: Events are published to a message bus, routing them to handlers, enabling clean separation of concerns and asynchronous processing.

How does Architecture Patterns with Python address testing strategies?

  • Test Pyramid Concept: The authors advocate for a healthy test pyramid, emphasizing a majority of unit tests, fewer integration tests, and minimal end-to-end tests.
  • Service Layer Testing: The book demonstrates testing service layer functions using fakes and mocks, allowing for fast and reliable tests focusing on business logic.
  • Encouraging Refactoring: By structuring tests around the service layer and using events, the book encourages developers to refactor code without fear of breaking functionality.

What are some best practices for implementing architectural patterns in Python according to Architecture Patterns with Python?

  • Start Simple: Begin with simple implementations of patterns and gradually refactor as the system grows in complexity.
  • Use Context Managers: For managing resources like database sessions, context managers are encouraged for their clarity and ease of use.
  • Decouple Components: Keep components loosely coupled, allowing for easier testing and maintenance, and enabling system evolution without significant rewrites.

What is the significance of event-driven architecture in Architecture Patterns with Python?

  • Decoupled Systems: Event-driven architecture promotes decoupled systems where components communicate through events, leading to greater flexibility and scalability.
  • Asynchronous Processing: It allows for asynchronous event processing, enabling systems to handle high loads and improve responsiveness.
  • Improved Maintainability: Using events to trigger actions makes the architecture more maintainable, as changes to one component do not directly impact others.

What are the challenges of using an event-driven architecture as discussed in Architecture Patterns with Python?

  • Complexity in Handling Events: Event-driven systems introduce complexity in managing event flows and ensuring correct system responses.
  • Potential for Circular Dependencies: The book warns about the risk of circular dependencies between event handlers, leading to difficult-to-debug issues.
  • Performance Considerations: The authors discuss trade-offs between synchronous and asynchronous processing, highlighting the need to balance responsiveness with complexity.

About the Author

Harry Percival is a software developer and author known for his expertise in Test-Driven Development (TDD) and Domain-Driven Design (DDD). He has gained recognition for his practical approach to teaching complex software development concepts. Percival's writing style is praised for being engaging, clear, and accessible to developers at various skill levels. He has authored multiple technical books, including "Test-Driven Development with Python" and "Architecture Patterns with Python." Percival's work focuses on helping developers build robust, maintainable software systems using best practices and modern design patterns. His contributions to the Python community have made him a respected figure in the field of software engineering.

Download PDF

To save this Architecture Patterns with Python summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.29 MB     Pages: 25

Download EPUB

To read this Architecture Patterns with Python summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.37 MB     Pages: 29
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
600,000+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...