====== Challenges of integrating static and dynamic models in DDD ======
By Rogoza Kirill (karogoza@edu.hse.ru)
====== Introduction ======
 
__Defining Domain-Driven Design (DDD)__

Domain-Driven Design (DDD) is a software development approach introduced by Eric Evans [4], designed to address complex software requirements by aligning system models with the core business domain. At its core, DDD emphasizes collaboration between developers and domain experts to capture the essential elements of a business’s unique environment. This collaboration is grounded in the principle of ubiquitous language — a common vocabulary used by both technical and non-technical stakeholders to discuss and model the domain accurately. Through concepts like bounded contexts, DDD helps define distinct areas within a software system, enabling more manageable and scalable applications by isolating complexities to specific, controlled areas.

__Significance of Static and Dynamic Models in DDD__

In DDD, models are divided into static and dynamic types [5], each serving a complementary function. Static models encapsulate the domain's structural elements — entities, aggregates, and value objects — that represent the state and integrity of business data. These elements provide a stable foundation that can evolve at a controlled pace, embodying long-term stability within the system. In contrast, dynamic models capture the behaviors and interactions within the system, particularly useful in event-driven or real-time systems, where responsiveness and adaptability are prioritized. Techniques such as Command Query Responsibility Segregation (CQRS) and Event Sourcing play a crucial role in managing these dynamic aspects by separating the system’s read and write operations.

__Thesis Statement__

The challenge of integrating static and dynamic models lies in achieving a balance between long-term structural stability and real-time adaptability. This balance is essential for maintaining consistent business rules while supporting flexibility in a dynamic environment. As systems scale, the integration becomes more complex, requiring solutions to manage interdependencies, bounded contexts, and eventual consistency. This essay explores these challenges in detail and presents strategies to address them effectively within DDD architectures.

====== Literature review ======

The integration of static and dynamic models in DDD often relies on two architectural patterns: CQRS [1] and Event Sourcing [2]. These architectural patterns help manage complexity by separating static business logic from dynamic behaviors.

CQRS divides the system’s commands (write operations) and queries (read operations) into separate models, which allows each to evolve independently. This separation enhances system performance and scalability, particularly in environments with high transactional loads. Meanwhile, Event Sourcing complements CQRS by logging every change as an event, providing a complete historical record. This approach supports auditability, compliance, and system recovery. However, large event logs can introduce performance challenges. To mitigate these issues, snapshotting is employed, which captures the state at specific intervals, reducing the overhead of replaying all past events.

These patterns are critical in modern, distributed systems because they provide both the flexibility needed to handle changing requirements and the stability required for consistent operations across microservices.

====== Challenges in Static and Dynamic Integration ======

__Consistency Management__

While CQRS separates read and write operations to enhance performance, it introduces eventual consistency issues. This lag between updates and their availability in query models complicates transactional guarantees across distributed microservices. Systems relying on event sourcing must carefully coordinate state changes to avoid inconsistencies when events are processed out of sequence or arrive late [6]. These problems are exacerbated as systems scale, where maintaining synchronization between static models (e.g., aggregates) and dynamic behaviors across microservices becomes increasingly complex.

__Schema Evolution__

As events are immutable, which means that once an event is created and added to the event log, it cannot be modified or deleted. Evolving business requirements can lead to issues when schema changes are needed [7]. Systems must maintain backward compatibility with previous versions of events while ensuring that new versions align with updated business logic. Solutions like event upcasting — modifying older events during replay — can help, but they add to the overall system complexity and maintenance burden.

__Operational and Debugging Complexity__

Distributed tracing is essential for managing operational complexity in microservice architectures. It tracks request flows across multiple services, providing visibility into asynchronous operations. However, implementing tracing poses challenges, such as the need for additional infrastructure and precise instrumentation. Debugging across multiple services becomes complex due to asynchronous communication, making it hard to correlate events effectively. Complexity of analyzing distributed trace data often necessitates additional manual processes, which increases the likelihood of bugs [9].

====== Approaches to Overcome Integration Challenges ======

Addressing the integration challenges between static and dynamic models in DDD requires a combination of architectural patterns and strategies to maintain consistency, evolve schemas, and manage operational complexity effectively.

__Compensating Transactions and Managing Asynchronous Consistency__

To address the challenges of eventual consistency, distributed systems often implement the saga pattern. In event-sourced architectures, sagas coordinate asynchronous operations by splitting transactions into smaller steps across multiple services. They  prevent the need for extended locking of resources and allow updating data in multiple services without using distributed transactions [3]. If a failure occurs during any step, compensating actions are triggered to roll back changes, ensuring that the system maintains a coherent state without locking resources. This pattern allows systems to operate efficiently even in failure-prone environments, improving fault tolerance

__Upcasting for Schema Evolution__

To handle the immutability of events and accommodate schema changes over time, systems use event upcasting. Upcasters modify older events when they are replayed to align with the latest business logic [10]. This strategy helps maintain compatibility with both old and new versions of events, mitigating issues related to evolving business requirements. Coupling upcasting with careful schema design ensures that schema evolution can be managed without compromising system stability

__Proxy-Based Distributed Tracing for Operational Visibility__

Transparent tracing offers an effective way to monitor operations by using proxies between microservices, eliminating the need for extensive code instrumentation [8]. These proxies intercept all inter-service communication, capturing relevant metadata (such as trace IDs) to ensure proper event correlation across multiple services. By injecting and propagating trace metadata, proxies facilitate causality tracking, which allows developers to link individual events and diagnose issues more effectively. This proxy-based approach aligns with best practices for non-intrusive monitoring by enabling distributed systems to remain responsive and efficient even as new services are added or scaled.

====== Conclusion ======

Integrating static and dynamic models within DDD is a complex yet essential endeavor for modern software systems. Static models offer long-term stability by maintaining business logic and data integrity, while dynamic models provide flexibility through responsiveness to real-time changes. However, balancing these models presents challenges, including managing consistency, evolving schemas, and operational complexity across distributed microservices.

By employing strategies such as the saga pattern for consistency, event upcasting for schema evolution, snapshotting for performance, and distributed tracing for operational visibility, organizations can overcome these integration challenges. These approaches ensure that systems remain scalable, resilient, and aligned with evolving business needs.

===== Reference list =====

1. .NET architecture documentation. Apply simplified CQRS and DDD patterns in a microservice. [[https://learn.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/apply-simplified-microservice-cqrs-ddd-patterns|Link]] 

2. AWS Prescriptive Guidance. Enabling data persistence in microservices. [[https://docs.aws.amazon.com/prescriptive-guidance/latest/modernization-data-persistence/service-per-team.html|Link]]
 
3. Dürr, K., Lichtenthäler, R., & Wirtz, G. (2022). Saga Pattern Technologies: A Criteria-based Evaluation. International Conference on Cloud Computing and Services Science. [[https://www.semanticscholar.org/paper/Saga-Pattern-Technologies%3A-A-Criteria-based-D%C3%BCrr-Lichtenth%C3%A4ler/bf5b18e9a9bf4a46e3f3c5f1ad8c6d04b4fc1fb7|Link]] 

4. Evans, E. (2004). Domain-driven design: tackling complexity in the heart of software. Addison-Wesley, Boston. [[https://www.semanticscholar.org/paper/Domain-driven-design-tackling-complexity-in-the-of/09a22ed7bd58677f466d54173a4139696e456002|Link]] 

5. Krause, A., Zirkelbach, C., Hasselbring, W., Lenga, S., & Kröger, D. (2020). Microservice Decomposition via Static and Dynamic Analysis of the Monolith. 2020 IEEE International Conference on Software Architecture Companion (ICSA-C), 9-16. [[https://www.semanticscholar.org/paper/Microservice-Decomposition-via-Static-and-Dynamic-Krause-Zirkelbach/c85f6acd6535fcf37922ffe4a6d534120443909e|Link]]  

6. Laigner, R., Almeida, A.C., Assunccao, W.K., & Zhou, Y. (2024). An Empirical Study on Challenges of Event Management in Microservice Architectures. ArXiv, abs/2408.00440. [[https://www.semanticscholar.org/paper/An-Empirical-Study-on-Challenges-of-Event-in-Laigner-Almeida/81392505f5df14020a04c606b8eaeae4967e0949|Link]] 

7. Overeem, M., Spoor, M., Jansen, S., & Brinkkemper, S. (2021). An Empirical Characterization of Event Sourced Systems and Their Schema Evolution - Lessons from Industry. Journal of Systems and Software, 178, 110970. [[https://www.semanticscholar.org/paper/An-Empirical-Characterization-of-Event-Sourced-and-Overeem-Spoor/664ddaf9f7abaf1b749a0f06a9908dcf11fbed75|Link]] 

8. Santana, M., Sampaio, A.R., Andrade, M., & Rosa, N.S. (2019). Transparent tracing of microservice-based applications. Proceedings of the 34th ACM/SIGAPP Symposium on Applied Computing. [[https://www.semanticscholar.org/paper/Transparent-tracing-of-microservice-based-Santana-Sampaio/7bb908aae84910bea733f39008908a423805c57d|Link]] 

9. Söylemez, M., Tekinerdogan, B., & Kolukısa Tarhan, A. (2022). Challenges and Solution Directions of Microservice Architectures: A Systematic Literature Review. Applied Sciences. [[https://www.semanticscholar.org/paper/Challenges-and-Solution-Directions-of-Microservice-S%C3%B6ylemez-Tekinerdogan/bd43ba8d9ae643b64d0d26c7788c10694733fb66|Link]] 

10. CQRS and Event Sourcing using Rust Documentation. [[https://doc.rust-cqrs.org/intro.html|Link]]