Learning Domain-Driven Design Vlad Khononov

Learning Domain-Driven Design Vlad Khononov - okladka książki

Autor:: Vlad Khononov
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:: 342
Dostępne formaty:: ePub

Mobi

Ebook 194,65 zł najniższa cena z 30 dni

~~229,00 zł~~ (-15%)
194,65 zł

Dodaj do koszyka lub Kup na prezent Kup 1-kliknięciem

194,65 zł najniższa cena z 30 dni

Przenieś na półkę

Do przechowalni

Building software is harder than ever. As a developer, you not only have to chase ever-changing technological trends but also need to understand the business domains behind the software. This practical book provides you with a set of core patterns, principles, and practices for analyzing business domains, understanding business strategy, and, most importantly, aligning software design with its business needs.

Author Vlad Khononov shows you how these practices lead to robust implementation of business logic and help to future-proof software design and architecture. You'll examine the relationship between domain-driven design (DDD) and other methodologies to ensure you make architectural decisions that meet business requirements. You'll also explore the real-life story of implementing DDD in a startup company.

With this book, you'll learn how to:

Analyze a company's business domain to learn how the system you're building fits its competitive strategy
Use DDD's strategic and tactical tools to architect effective software solutions that address business needs
Build a shared understanding of the business domains you encounter
Decompose a system into bounded contexts
Coordinate the work of multiple teams
Gradually introduce DDD to brownfield projects

Wybrane bestsellery

O autorze książki

Vladik (Vlad) Khononov jest inżynierem oprogramowania od ponad 15 lat. Specjalizuje się w projektowaniu dziedzinowym dla firm z wielu branż i chętnie dzieli się swoim bogatym doświadczeniem. Często występuje podczas branżowych konferencji, takich jak O’Reilly Software Architecture, DDD Europe i NDC, a także działa na rzecz grup Domain-Driven Design Israel i Tel Aviv Software Architecture. Mieszka w północnym Izraelu z żoną i (prawie) rozsądną liczbą kotów.

Ebooka "Learning Domain-Driven Design" 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: Learning Domain-Driven Design Vlad Khononov

(0)

Szczegóły książki

ISBN Ebooka:: 978-10-981-0008-7, 9781098100087
Data wydania ebooka :: 2021-10-08 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:: 1
Rozmiar pliku ePub:: 11.3MB
Rozmiar pliku Mobi:: 19.7MB

Zgłoś erratę

Kategorie

Kliknij, aby zgłosić błędnie przypisaną kategorię »

Informatyka » Programowanie » Techniki programowania

Spis treści książki

Foreword
Preface
- Why I Wrote This Book
- Who Should Read This Book
- Navigating the Book
- Example Domain: WolfDesk
- Conventions Used in This Book
- Using Code Examples
- OReilly Online Learning
- How to Contact Us
- Acknowledgments
Introduction
I. Strategic Design
1. Analyzing Business Domains
- What Is a Business Domain?
- What Is a Subdomain?
  - Types of Subdomains
    - Core subdomains
      - Complexity
      - Sources of competitive advantage
    - Generic subdomains
    - Supporting subdomains
  - Comparing Subdomains
    - Competitive advantage
    - Complexity
    - Volatility
    - Solution strategy
  - Identifying Subdomain Boundaries
    - Distilling subdomains
    - Subdomains as coherent use cases
    - Focus on the essentials
- Domain Analysis Examples
  - Gigmaster
    - Business domain and subdomains
      - Core subdomains
      - Generic subdomains
      - Supporting subdomains
    - Design decisions
  - BusVNext
    - Business domain and subdomains
      - Core subdomains
      - Generic subdomains
      - Supporting subdomains
    - Design decisions
- Who Are the Domain Experts?
- Conclusion
- Exercises
2. Discovering Domain Knowledge
- Business Problems
- Knowledge Discovery
- Communication
- What Is a Ubiquitous Language?
- Language of the Business
  - Scenarios
  - Consistency
    - Ambiguous terms
    - Synonymous terms
- Model of the Business Domain
  - What Is a Model?
  - Effective Modeling
  - Modeling the Business Domain
  - Continuous Effort
  - Tools
  - Challenges
- Conclusion
- Exercises
3. Managing Domain Complexity
- Inconsistent Models
- What Is a Bounded Context?
  - Model Boundaries
  - Ubiquitous Language Refined
  - Scope of a Bounded Context
- Bounded Contexts Versus Subdomains
  - Subdomains
  - Bounded Contexts
  - The Interplay Between Subdomains and Bounded Contexts
- Boundaries
  - Physical Boundaries
  - Ownership Boundaries
- Bounded Contexts in Real Life
  - Semantic Domains
  - Science
  - Buying a Refrigerator
- Conclusion
- Exercises
4. Integrating Bounded Contexts
- Cooperation
  - Partnership
  - Shared Kernel
    - Shared scope
    - Implementation
    - When to use shared kernel
- CustomerSupplier
  - Conformist
  - Anticorruption Layer
  - Open-Host Service
- Separate Ways
  - Communication Issues
  - Generic Subdomains
  - Model Differences
- Context Map
  - Maintenance
  - Limitations
- Conclusion
- Exercises
II. Tactical Design
5. Implementing Simple Business Logic
- Transaction Script
  - Implementation
  - Its Not That Easy!
    - Lack of transactional behavior
    - Distributed transactions
    - Implicit distributed transactions
  - When to Use Transaction Script
- Active Record
  - Implementation
  - When to Use Active Record
- Be Pragmatic
- Conclusion
- Exercises
6. Tackling Complex Business Logic
- History
- Domain Model
  - Implementation
    - Complexity
    - Ubiquitous language
  - Building Blocks
    - Value object
      - Ubiquitous language
      - Implementation
      - When to use value objects
    - Entities
    - Aggregates
      - Consistency enforcement
      - Transaction boundary
      - Hierarchy of entities
      - Referencing other aggregates
      - The aggregate root
      - Domain events
      - Ubiquitous language
    - Domain services
  - Managing Complexity
- Conclusion
- Exercises
7. Modeling the Dimension of Time
- Event Sourcing
  - Search
  - Analysis
  - Source of Truth
  - Event Store
- Event-Sourced Domain Model
  - Advantages
  - Disadvantages
- Frequently Asked Questions
  - Performance
  - Deleting Data
  - Why Cant I Just?
- Conclusion
- Exercises
8. Architectural Patterns
- Business Logic Versus Architectural Patterns
- Layered Architecture
  - Presentation Layer
  - Business Logic Layer
  - Data Access Layer
  - Communication Between Layers
  - Variation
    - Service layer
    - Terminology
  - When to Use Layered Architecture
- Ports & Adapters
  - Terminology
  - Dependency Inversion Principle
  - Integration of Infrastructural Components
  - Variants
  - When to Use Ports & Adapters
- Command-Query Responsibility Segregation
  - Polyglot Modeling
  - Implementation
    - Command execution model
    - Read models (projections)
  - Projecting Read Models
    - Synchronous projections
    - Asynchronous projections
  - Challenges
  - Model Segregation
  - When to Use CQRS
- Scope
- Conclusion
- Exercises
9. Communication Patterns
- Model Translation
  - Stateless Model Translation
    - Synchronous
    - Asynchronous
  - Stateful Model Translation
    - Aggregating incoming data
    - Unifying multiple sources
- Integrating Aggregates
  - Outbox
    - Fetching unpublished events
  - Saga
    - Consistency
  - Process Manager
- Conclusion
- Exercises
III. Applying Domain-Driven Design in Practice
10. Design Heuristics
- Heuristic
- Bounded Contexts
- Business Logic Implementation Patterns
- Architectural Patterns
- Testing Strategy
  - Testing Pyramid
  - Testing Diamond
  - Reversed Testing Pyramid
- Tactical Design Decision Tree
- Conclusion
- Exercises
11. Evolving Design Decisions
- Changes in Domains
  - Core to Generic
  - Generic to Core
  - Supporting to Generic
  - Supporting to Core
  - Core to Supporting
  - Generic to Supporting
- Strategic Design Concerns
- Tactical Design Concerns
  - Transaction Script to Active Record
  - Active Record to Domain Model
  - Domain Model to Event-Sourced Domain Model
  - Generating Past Transitions
  - Modeling Migration Events
- Organizational Changes
  - Partnership to CustomerSupplier
  - CustomerSupplier to Separate Ways
- Domain Knowledge
- Growth
  - Subdomains
  - Bounded Contexts
  - Aggregates
- Conclusion
- Exercises
12. EventStorming
- What Is EventStorming?
- Who Should Participate in EventStorming?
- What Do You Need for EventStorming?
- The EventStorming Process
  - Step 1: Unstructured Exploration
  - Step 2: Timelines
  - Step 3: Pain Points
  - Step 4: Pivotal Events
  - Step 5: Commands
  - Step 6: Policies
  - Step 7: Read Models
  - Step 8: External Systems
  - Step 9: Aggregates
  - Step 10: Bounded Contexts
- Variants
- When to Use EventStorming
- Facilitation Tips
  - Watch the Dynamics
  - Remote EventStorming
- Conclusion
- Exercises
13. Domain-Driven Design in the Real World
- Strategic Analysis
  - Understand the Business Domain
    - Core subdomains
    - Generic subdomains
    - Supporting subdomains
  - Explore the Current Design
    - Evaluate the tactical design
    - Evaluate the strategic design
- Modernization Strategy
  - Strategic Modernization
  - Tactical Modernization
  - Cultivate a Ubiquitous Language
    - Strangler pattern
    - Refactoring tactical design decisions
- Pragmatic Domain-Driven Design
- Selling Domain-Driven Design
  - Undercover Domain-Driven Design
    - Ubiquitous language
    - Bounded contexts
    - Tactical design decisions
    - Event-sourced domain model
- Conclusion
- Exercises
IV. Relationships to Other Methodologies and Patterns
14. Microservices
- What Is a Service?
- What Is a Microservice?
  - Method as a Service: Perfect Microservices?
  - Design Goal
  - System Complexity
  - Microservices as Deep Services
  - Microservices as Deep Modules
- Domain-Driven Design and Microservices Boundaries
  - Bounded Contexts
  - Aggregates
  - Subdomains
- Compressing Microservices Public Interfaces
  - Open-Host Service
  - Anticorruption Layer
- Conclusion
- Exercises
15. Event-Driven Architecture
- Event-Driven Architecture
- Events
  - Events, Commands, and Messages
  - Structure
  - Types of Events
    - Event notification
      - Security
      - Concurrency
    - Event-carried state transfer
    - Domain event
    - Domain events versus event notification
    - Domain events versus event-carried state transfer
    - Event types: Example
- Designing Event-Driven Integration
  - Distributed Big Ball of Mud
  - Temporal Coupling
  - Functional Coupling
  - Implementation Coupling
  - Refactoring the Event-Driven Integration
  - Event-Driven Design Heuristics
    - Assume the worst
    - Use public and private events
    - Evaluate consistency requirements
- Conclusion
- Exercises
16. Data Mesh
- Analytical Data Model Versus Transactional Data Model
  - Fact Table
  - Dimension Table
  - Analytical Models
- Analytical Data Management Platforms
  - Data Warehouse
  - Data Lake
  - Challenges of Data Warehouse and Data Lake Architectures
- Data Mesh
  - Decompose Data Around Domains
  - Data as a Product
  - Enable Autonomy
  - Build an Ecosystem
  - Combining Data Mesh and Domain-Driven Design
- Conclusion
- Exercises
Closing Words
- Problem
- Solution
- Implementation
- Further Reading
  - Advanced Domain-Driven Design
  - Architectural and Integration Patterns
  - Modernization of Legacy Systems
  - EventStorming
- Conclusion
A. Applying DDD: A Case Study
- Five Bounded Contexts
  - Business Domain
  - Bounded Context #1: Marketing
    - A kind of magic
    - Our early understanding of domain-driven design
  - Bounded Context #2: CRM
    - More aggregates!
    - Solution design: Take two
    - Tower of Babel 2.0
    - A broader understanding of domain-driven design
  - Bounded Context #3: Event Crunchers
  - Bounded Context #4: Bonuses
    - Design: Take two
    - Ubiquitous language
    - A classic understanding of domain-driven design
  - Bounded Context #5: The Marketing Hub
    - Micro what?
    - The real problem
- Discussion
  - Ubiquitous Language
  - Subdomains
    - Mapping design decisions to subdomains
    - Dont ignore pain
  - Boundaries of Bounded Contexts
- Conclusion
B. Answers to Exercise Questions
- Chapter 1
- Chapter 2
- Chapter 3
- Chapter 4
- Chapter 5
- Chapter 6
- Chapter 7
- Chapter 8
- Chapter 9
- Chapter 10
- Chapter 11
- Chapter 12
- Chapter 13
- Chapter 14
- Chapter 15
- Chapter 16
References
Index