cosmicpython/book

Features

• Clean Architecture Implementations - Provides a technical reference for implementing clean architecture using ports and adapters to isolate business logic.
• Domain-Driven Designs - Provides a comprehensive guide on aligning software architecture with complex business domains using DDD.
• CQRS Patterns - Applies architectural patterns that separate read and write operations to optimize data retrieval and performance.
• Data Access Abstractions - Implements interface layers that decouple application logic from specific underlying storage engines.
• Read-Write Splitting - Implements the separation of read and write models to optimize performance and simplify complex business logic.
• Storage-Agnostic Persistence Layers - Provides abstraction layers that allow application state to be persisted across different backends without changing business logic.
• Layered Architectures - Uses structural patterns to divide the application into distinct layers of responsibility, isolating business logic.
• Repository Pattern Abstractions - Implements the repository pattern to hide persistent storage details behind a collection-like interface for the domain model.
• Dependency Argument Injection - Implements passing external services as arguments to functions to ensure testability and modularity.
• API Adapters - Implements adapter classes to wrap external APIs and prevent third-party changes from leaking into the core business logic.
• Python Patterns - Supplies a library of Python-specific architectural patterns, including unit-of-work and dependency inversion.
• Command Query Responsibility Segregation - Provides a detailed implementation of the architectural pattern separating data modification commands from data retrieval queries.
• CQRS Patterns - Offers guidance on separating read and write models to optimize system performance and data retrieval.
• Domain Model Implementations - Guides the translation of complex business requirements into independent domain models for maintainability and testability.
• Enterprise Application Architectures - Provides a framework for structuring complex Python applications by separating business logic from external frameworks.
• Event Bus Architectures - Implements a domain-event message bus to communicate state changes and trigger secondary actions without tight coupling.
• Event-Driven Logic - Implements event-driven logic using domain events and message buses to handle secondary actions and state changes.
• Dependency Inversion Patterns - Demonstrates dependency inversion patterns to keep domain logic agnostic of specific infrastructure and database frameworks.
• Repository Pattern Implementations - Implements the repository pattern to decouple domain logic from specific database technologies and schemas.
• Logic And Infrastructure Decoupling - Demonstrates the decoupling of core domain rules from infrastructure concerns like database schemas and user interfaces.
• Service Layers - Provides a dedicated service layer to orchestrate domain objects and infrastructure adapters for primary use cases.
• Software Architecture Guides - Serves as a comprehensive guide for building enterprise Python applications by separating business logic from infrastructure.
• Command Query Separation - Implements architectural designs that strictly separate methods that modify state from those that return data.
• Logic Decoupling - Provides architectural patterns to separate core business rules from delivery mechanisms and database schemas.
• Coupling and Dependency Management - Provides guidance on minimizing inter-module reliance and managing how components interact via centralized mechanisms.
• Third-Party API Integrations - Provides adapter-based isolation to decouple business logic from the specifics of third-party API integrations.
• In-Memory Fakes - Shows how to create in-memory fakes of external services to ensure deterministic and fast unit tests.
• Event-Driven State Buses - Uses domain events and message buses to communicate state changes and trigger secondary actions across the system.
• Service Entrypoints - Defines system entrypoints via a service layer to decouple use case orchestration from specific delivery mechanisms.
• Component Registries - Implements a registry-based system to map identifiers to concrete implementations for decoupled component resolution.
• Circular Dependency Resolution - Employs techniques to resolve circular module dependencies by inverting control for a single direction of flow.
• Repository Patterns - Demonstrates architectural patterns that isolate the domain layer from data mapping and storage details.
• Unit of Work Patterns - Implements the unit-of-work pattern to ensure atomic database updates by tracking changes during a business transaction.
• Component Registries - Uses a centralized registry to map interfaces to concrete implementations for flexible runtime component resolution.

Star history