Domain-driven Design Research Articles

Modernizing enterprise architecture: A guide to microservices migration and hybrid cloud integration

The migration from monolithic to microservices architecture represents a transformative journey in enterprise software development, complemented by the adoption of hybrid cloud technologies. This comprehensive article explores the strategic approaches, implementation patterns, and best practices for successful architectural transformation. The article examines key aspects, including preliminary analysis requirements, domain-driven design implementation, technical considerations for database and API management, and the integration of hybrid cloud technologies. Through a detailed examination of containerization, orchestration, and observability practices, this research provides organizations with a structured framework for modernizing their enterprise architecture while maintaining operational efficiency and system reliability. The article incorporates real-world implementation cases across various sectors, demonstrating measurable improvements in development agility, system performance, and business outcomes.

Increasing Accessibility and Scalability of Student Services Using Microservice Architecture: A Case Study on Developing a Timetable Service

This paper describes the development of a service for tracking the university schedule, implemented using a microservice architecture with a chat-bot as the client interface. During the development process, the needs of students and professors, as well as publicly available university data, were considered, allowing for the selection of an optimal platform and the creation of an interactive chat-bot interface. All stages of the project’s development are listed, starting from defining the main service objectives and ending with configuration and testing. Information is also provided about the chosen technologies and tools used during the development process, such as the Python and Java programming languages, the BeautifulSoup and Requests libraries, the Cloud Native and Domain-Driven Design architectural approaches, as well as containerization with Docker and orchestration with Kubernetes. The service is designed to help students stay informed about upcoming classes and events by providing information in an accessible and intuitive format. It serves as a convenient addition to traditional methods of information delivery

Development of a software architecture concept for solving singularly perturbed problems in semiconductor electronics

The software architecture for automated solving of singularly perturbed problems in semiconductor electronics is presented. The system is based on the boundary correction method and domain-driven design (DDD). The developed software architecture integrates an artificial neural network for analyzing types of mathematical subproblems and selecting the most suitable method for solving them. The use of modern information technologies such as parallelization, cloud computing, and symbolic computations enables a new level of automated modeling. The research results demonstrated the effectiveness of the proposed approach in solving complex mathematical problems with singular perturbations.

Domain-Driven Design in Microservices-Based Systems Development: A Systematic Literature Review and Thematic Analysis

Domain-Driven Design in Microservices-Based Systems Development: A Systematic Literature Review and Thematic Analysis

Blockchain Financial Statements: Innovating Financial Reporting, Accounting, and Liquidity Management

The complexity and interconnection within the financial ecosystem demand innovative solutions to improve transparency, security, and efficiency in financial reporting and liquidity management, while also reducing accounting fraud. This paper presents Blockchain Financial Statements (BFS), an innovative accounting system designed to address accounting fraud, reduce data manipulation, and misrepresentation of company financial claims, by enhancing availability of the real-time and tamper-proof accounting data, underpinned by a verifiable approach to financial transactions and reporting. The primary goal of this research is to design, develop, and validate a blockchain-based accounting prototype—the BFS system—that can automate transformation of transactional data, generated by traditional business activity into comprehensive financial statements. Incorporating a Design Science Research Methodology with Domain-Driven Design, this study constructs a BFS artefact that harmonises accounting standards with blockchain technology and business orchestration. The resulting Java implementation of the BFS system demonstrates successful integration of blockchain technology into accounting practices, showing potential in real-time validation of transactions, immutable record-keeping, and enhancement of transparency and efficiency of financial reporting. The BFS framework and implementation signify an advancement in the application of blockchain technology in accounting. It offers a functional solution that enhances transparency, accuracy, and efficiency of financial transactions between banks and businesses. This research underlines the necessity for further exploration into blockchain’s potential within accounting systems, suggesting a promising direction for future innovations in tamper-evident financial reporting and liquidity management.

ON THE MIGRATION OF DOMAIN DRIVEN DESIGN TO CQRS WITH EVENT SOURCING SOFTWARE ARCHITECTURE

The article addresses the issue of migrating applications, particularly those following the Domain-Driven Design (DDD) architecture, to the Command Query Responsibility Segregation (CQRS) paradigm with Event Sourcing. Long-standing systems often need help with problems related to inflexible, outdated architecture, and dependencies, leading to increased maintenance costs. The paper examines the advantages of DDD and proposes CQRS as a viable alternative, focusing on improving productivity and scalability. The main objective of the work is to assess a secure path for migrating a project from DDD architecture to the CQRS and Event Sourcing architecture and to determine the migration roadmap. The article conducts an experiment in which migration of a test project is performed, evaluating the time, effort, and results of the migration. The research methodology includes evaluating complexity using McCabe's Cyclomatic Complexity metric and assessing performance through the execution time of system methods. The experiment is conducted on a typical project – a task-tracking system. The results of implementing CQRS show a fourfold increase in the number of classes and a 50% increase in the number of lines of code. However, this increase is justified as it improves modularity, transparency, and manageability during development, ultimately facilitating system maintenance and significantly enhancing overall system productivity. It is worth noting that the overall cyclomatic complexity of the system remains almost unchanged. In summary, the article examines the assessment of migrating a project from DDD architecture to CQRS and Event Sourcing, combining theoretical findings with practical experimentation. It provides valuable insights into the advantages, disadvantages, and challenges of implementing CQRS architecture in complex information systems.

Domain-Driven Design for Microservices: An Evidence-Based Investigation

Domain-Driven Design for Microservices: An Evidence-Based Investigation

The impact of personality and self-efficacy on domain modeling productivity in graphical and textual notations

ContextSoftware development is a complex and human-intensive activity, where human factors can have a significant impact on productivity and quality of results. To address the complexity of software, domain modeling has gained much importance, mainly due to software methodologies such as Model-Driven Engineering and Domain-Driven Design. In particular, domain modeling is an essential task that allows developers to understand and effectively represent the problem domain. However, domain modeling productivity can be affected by several human factors, including developers' personality and self-efficacy. ObjectiveThe study aims to explore the influence of human factors, specifically developers' personality and self-efficacy, on domain modeling productivity in graphical and textual notations. MethodAn empirical controlled study was conducted with 134 third-year computer science students from the University of Alicante, guided by the definition of a theoretical model based on previous studies. The participants were tasked with creating domain models in both graphical and textual notations. The order in which the notations were used was randomized, and the participants were given different system specifications to model. After modeling, 98 participants completed questionnaires assessing their personality, self-efficacy, and notation satisfaction. The design and evaluation of the experiment employed the Goal, Question, and Metrics framework. Data analysis was performed using a stepwise selection method to select the most appropriate regression model. ResultsThe study indicates that personality and self-efficacy have a significant impact on the performance of junior domain model developers. Specifically, it was discovered that while neuroticism had a negative impact on efficiency in both notations, developers' ability belief and use of graphical notation had a positive influence on effectiveness and efficiency in creating domain models. ConclusionsThese findings highlight the importance of considering human factors and notation choice in software development. Developers' personality and self-efficacy emerge as critical considerations for enhancing both productivity and quality in domain modeling.

Domain-Driven Design (DDD)- Bridging the Gap between Business Requirements and Object-Oriented Modeling

Domain-Driven Design (DDD) has emerged as a powerful methodology for developing complex software systems by emphasizing a deep understanding of the business domain. By bridging the gap between business requirements and object-oriented modeling, DDD enables developers to create software solutions that are not only aligned with business needs but also maintainable, adaptable, and scalable. This research paper explores the principles, practices, and benefits of DDD, illustrating its effectiveness through case studies and examples. We discuss how DDD fosters collaboration between domain experts and developers, encourages the creation of a ubiquitous language, and enables the modeling of complex domains through bounded contexts, aggregates, and domain events. Additionally, we examine the role of strategic design in DDD, including context mapping, bounded context, and the use of tactical patterns such as entities, value objects, and repositories. Through this comprehensive analysis, we demonstrate how DDD serves as a bridge between business requirements and object-oriented modeling, facilitating the development of software systems that are both technically sound and aligned with the needs of the business.

Developing a Conceptual Model for Cross-Domain Microservices Using Event-Driven and Domain-Driven Design

The growing complexity of modern software systems necessitates architectural approaches that enhance scalability, flexibility, and maintainability. Microservices architecture has emerged as a leading solution, particularly for cross-domain applications. This paper presents a conceptual model for cross-domain microservices by integrating Event-Driven Design (EDD) and Domain-Driven Design (DDD) principles. The proposed model focuses on structuring microservices around distinct bounded contexts, enabling modular development and fostering a deep alignment between technical architecture and business objectives. By employing EDD, the model leverages asynchronous communication and event streaming to decouple microservices, ensuring resilience and real-time responsiveness across domains. DDD is utilized to define domain boundaries, prioritize business logic, and establish ubiquitous language, facilitating seamless collaboration between technical and non-technical stakeholders. The model also introduces a unified framework for orchestrating complex interactions across microservices, enhancing system coherence without compromising autonomy. Key components of the conceptual model include event sourcing for maintaining robust data consistency, CQRS (Command Query Responsibility Segregation) to separate read and write operations, and aggregate design to manage domain entities efficiently. The model emphasizes event choreography over centralized orchestration, promoting loose coupling and scalability. Integration challenges, such as data synchronization, eventual consistency, and cross-domain event propagation, are addressed with practical guidelines for implementing resilient patterns. A comparative analysis with traditional service-oriented architectures underscores the model's advantages in supporting diverse business needs and rapid adaptability to changing requirements. The proposed conceptual model is validated through case studies in e-commerce and financial services, demonstrating its potential to optimize operational workflows and enhance user experiences. This research contributes to the growing discourse on microservices by bridging the gap between technical and business domains, offering a robust framework for designing cross-domain systems. Future work will explore extending the model with advanced AI-driven decision-making and monitoring capabilities.

Microservices Boundary Determination Migration in DevOps: A Case Study

The microservice architecture (MSA) is a widely used and researched approach in industry and academia. However, designing the migration to MSA is a complex and challenging task, and there is a lack of clear guidelines on how to address both business and technical issues during the process. This paper presents a step-by-step method for determining the boundaries of microservices, which is a critical activity in MSA migration for both practitioners and academics.We conducted a case study of SHAMIM, a nationwide project serving over 120,000 students, to demonstrate the proposed method. The microservice boundaries were determined by utilizing both business and technical input types, including domain-driven design (DDD), business processes, service call numbers, and data access patterns in databases.Our findings suggest that MSA migration can be conducted more reliably by using change documents maintained by the DevOps team. The proposed method leads to clear improvements in the determination of each microservice boundary, and it can be useful for practitioners and academics involved in MSA migration.

Domain Driven Design Approaches in Cloud Native Service Architecture

With the proliferation of cloud native services, the need for efficient software design strategies has become of the utmost importance. The hypothesis of this article is that domain driven design approaches, when integrated into cloud native service architecture, provide a valuable methodology for building modular, scalable, and maintainable systems. The goal of the article is to analyse how these approaches can improve software design while also contributing to system availability, reliability, and resilience. The methodology employed in this study involves the analysis of domain-driven design approaches and their integration with cloud native technologies. The paper emphasizes the importance of clean domain models, well-defined bounded contexts, and the separation of concerns in enterprise-grade software. While focusing on foundational concepts, the paper suggests the potential for a future case study to illustrate the domain driven software development process in action. While the paper does not provide specific empirical results, it highlights the potential benefits of adopting domain-driven design and cloud native architectures. That is why the article examines the fundamental components of domain driven design, their integration with cloud native technologies, benefits, and challenges. In addition, the study sets the stage for further research in this area to help software architects and developers.

AGL: Incorporating behavioral aspects into domain-driven design

Domain-driven design (DDD) aims to iteratively develop software around a realistic domain model. Recent research in DDD has been focusing on using annotation-based domain-specific languages (aDSLs) to build the domain model. However, within current approaches behavioral aspects, that are often represented using UML Activity and State machine diagrams, are not explicitly captured in the domain model. The focus of this paper is to introduce a new approach for incorporating behavioral aspects into domain models within the Domain-Driven Design (DDD) approach. The proposed approach involves using a new activity graph language (AGL) as an aDSL for representing behavioral aspects within a unified domain model. This integration of AGL and the previously developed aDSL (DCSLto represent domain models) aims to achieve three important features of DDD: feasibility, productivity, and understandability. Our approach involves building a unified class model in DCSLwithin a domain-driven architecture, which uses the annotation attachment feature of the host programming language (such as Java) to attach AGL activity graphs directly to the activity class of the unified class model, resulting in a unified domain model. In this work, we define the abstract and concrete syntax of AGL. To demonstrate our method, we use a Java framework called jDomainApp and evaluate AGL through a case study to show that it is expressive and practical for real-world software. This paper presents two contributions. Firstly, it proposes a mechanism to include behavioral aspects in a unified domain model by introducing a new aDSL called AGL to represent domain behaviors. Secondly, it presents a unified modeling method for domain-driven software development. Our method significantly extends the state-of-the-art in DDD in two important fronts: constructing a unified domain model for both structural and behavioral aspects of domain models and bridging the gaps between model and code.

DOMICO: Checking conformance between domain models and implementations

AbstractAs a predominant design method for microsservices architecture (MSA), domain‐driven design (DDD) utilizes a series of standard patterns in both models and implementations to effectively support the design of architectural elements. However, an implementation may deviate from its original domain model that uses certain patterns. The deviation between a domain model and its implementation is a type of architectural drift, which needs to be detected promptly. This paper proposes an approach, namely DOMICO, to check the conformance between the domain model and its implementation, by which the conformance is formalized by defining eight common structural patterns of domain modeling and their representations in both models and the corresponding source code. Based on the formalization, our approach can not only identify the discrepancies (e.g., divergence, absence, and modification) with respect to pattern elements, but also detect possible violations of 24 compliance rules imposed by the patterns. To validate DOMICO, we performed a case study to investigate its use in a supply chain project and its performance. The results show that DOMICO can accurately identify 100% inconsistency issues in the cases examined. As the first conformance checking approach for DDD, DOMICO can be integrated into the regular domain modeling process and help ensure the conformity of microservice implementations to models.

Blockchain-based fine-grained digital twin sharing framework for social manufacturing

The lack of digitalization basis of social manufacturing resources has brought barriers to perform efficient production coordination in social manufacturing network. Digital twin can be a promising carrier for bridging this gap. However, the complexity of digital twin makes small and medium enterprises, and individual resource owners in social manufacturing hard to apply this technology. Benefiting from the convenience of sharing in social communities, this paper presents a blockchain-based fine-grained digital twin sharing framework to accelerate the popularization and iteration of digital twins in social manufacturing. A hybrid design method, called model–view–controller domain-driven design (MVC-DDD), is proposed to decompose and decouple complicated digital twin instances into small granules from software architecture perspective. Then, blockchain is introduced as the underlying infrastructure to innovate the specific sharing mechanisms using zero-knowledge proof for decentralized registering, authorizing, and extracting digital twin granules. Moreover, the sharing incentive mechanism is also explored to ensure the feasibility and sustainability for the whole sharing behaviors. Finally, different types of 3D printers are selected for implementing the referential digital twin architecture for generating the sharable granules. A series of experiments are conducted to show that our sharing mechanism has a good performance in terms of throughput, latency and network bandwidth. Additionally, the incentive mechanism is also analyzed generate the management implications to facilitate the digital twin providers with different scales for sharing.

Actor-Driven Decomposition of Microservices through Multi-level Scalability Assessment

The microservices architectural style has gained widespread acceptance. However, designing applications according to this style is still challenging. Common difficulties concern finding clear boundaries that guide decomposition while ensuring performance and scalability. With the aim of providing software architects and engineers with a systematic methodology, we introduce a novel actor-driven decomposition strategy to complement the domain-driven design and overcome some of its limitations by reaching a finer modularization yet enforcing performance and scalability improvements. The methodology uses a multi-level scalability assessment framework that supports decision-making over iterative steps. At each iteration, architecture alternatives are quantitatively evaluated at multiple granularity levels. The assessment helps architects to understand the extent to which architecture alternatives increase or decrease performance and scalability. We applied the methodology to drive further decomposition of the core microservices of a real data-intensive smart mobility application and an existing open-source benchmark in the e-commerce domain. The results of an in-depth evaluation show that the approach can effectively support engineers in (i) decomposing monoliths or coarse-grained microservices into more scalable microservices and (ii) comparing among alternative architectures to guide decision-making for their deployment in modern infrastructures that orchestrate lightweight virtualized execution units.

MODELING AND IMPLEMENTATION OF DOMAIN EVENTS IN THE DOMAIN-DRIVEN ARCHITECTURE ON THE .NET CORE PLATFORM

A software architecture centered on a domain model can provide significant advantages over other types of architectures in the long-term development and maintenance of systems with complex domain logic. At the same time, domain-driven design and approaches to software implementation of systems are relatively new concepts and continue to develop in application to various platforms, technologies and programming languages, and are of considerable interest to designers and developers. The presented work examines existing approaches to modeling and implementing domain events on the .NET Core platform in domain-driven architecture, which is one of the newest patterns. There are two approaches to implementing domain event behavior: immediate and delayed event propagation. These two approaches are analyzed and their features are described in detail. The implementation of instant propagation of domain events within a command execution transaction in the CQRS architecture is described. This implementation allows you to get rid of external dependencies, achieve purity of domain entities, as it eliminates the need to inject services, repositories in entities, and also prevents memory leaks and is safe for multithreaded use. Schematically depicts the abstract process of an external command entering a domain model, which causes a change in the state of an aggregate and the propagation of side effects with domain events. This process takes into account the capabilities of the Entity Framework object-relational mapping framework to retrieve context objects that have been changed during process. The entire stack of objects involved in this activity is located in the shared process memory, and the interaction occurs in synchronous mode. For the conceptual detection of events and aggregates, the event storming technique is used, the features of which are discussed in the article.

Refactoring with domain-driven design in an industrial context

ContextSoftware developers need to constantly work on evolving the structure and the stability of the code due to changing business needs of the product. There are various refactoring approaches in industry which promise improvements over source code composition and maintainability.ObjectiveIn our research, we want to improve the maintainability of an existing system through refactoring using Domain-Driven Design (DDD) as a software design approach. We also aim for providing empirical evidence on its effect on maintainability and the challenges as perceived by developers.MethodIn this study, we applied the action research methodology, which facilitates close academia-industry collaboration and regular presence in the studied product. We utilized focus groups to discover problems of the existing system with a qualitative approach. We reviewed the subject codebase to construct our own expert opinion as well and identified problems in the codebase and matched them with the ones raised by engineers in the team. We refactored the existing software system according to DDD principles. To measure the effects of our actions, we utilized Technology Acceptance Model (mTAM) questionnaire, and also semi-structured interviews with the development team for data collection, and card sorting methodology for qualitative analysis. For minimizing bias that might affect our results with the existing software engineers in the team, we extended our measurement with three new joiner software engineers in the team through the think aloud protocol.ResultsWe have identified that engineers mostly gave positive answers to our interview questions, which are mapped to software maintainability metrics defined by ISO/IEC 25010. Our DDD refactoring scored 85 in PU and 83 in PEU, leading to an overall mTAM score of 84. This means acceptable on the acceptability scale, B on the grade scale, and good on the adjective rating scale.ConclusionOur research led us to conclude that a powerful design approach, like DDD, is an effective tool for restructuring and resolving software issues in this situation. It offers standardization to the software and the refactoring efforts. We realized that DDD entails a certain degree of complexity and cognitive load, which is a barrier for software engineers, but they are aware of its benefits.

SEMGROMI-a semantic grouping algorithm to identifying microservices using semantic similarity of user stories.

Microservices is an architectural style for service-oriented distributed computing, and is being widely adopted in several domains, including autonomous vehicles, sensor networks, IoT systems, energy systems, telecommunications networks and telemedicine systems. When migrating a monolithic system to a microservices architecture, one of the key design problems is the "microservice granularity definition", i.e., deciding how many microservices are needed and allocating computations among them. This article describes a semantic grouping algorithm (SEMGROMI), a technique that takes user stories, a well-known functional requirements specification technique, and identifies number and scope of candidate microservices using semantic similarity of the user stories' textual description, while optimizing for low coupling, high cohesion, and high semantic similarity. Using the technique in four validation projects (two state-of-the-art projects and two industry projects), the proposed technique was compared with domain-driven design (DDD), the most frequent method used to identify microservices, and with a genetic algorithm previously proposed as part of the Microservices Backlog model. We found that SEMGROMI yields decompositions of user stories to microservices with high cohesion (from the semantic point of view) and low coupling, the complexity was reduced, also the communication between microservices and the estimated development time was decreased. Therefore, SEMGROMI is a viable option for the design and evaluation of microservices-based applications. The proposed semantic similarity-based technique (SEMGROMI) is part of the Microservices Backlog model, which allows to evaluate candidate microservices graphically and based on metrics to make design-time decisions about the architecture of the microservices-based application.

Creation of a Framework and a Corresponding Tool Enabling the Test-Driven Development of Microservices

Microservice architectures have emerged as counter design to traditional monolithic applications. While monoliths are single executable applications, microservice architectures consist of several smaller units. Advantages of microservice architectures are their development speed, lower costs of change, and dynamic scaling ability. However, this pattern requires an adaptation of quality assurance measures. In this research article, test-driven development is investigated in context of microservices that are developed according to established practices. Based on the systems development research methodology, recommendable practices and testing strategies are examined with a translation of that knowledge into an extensive artifact, enabling test-driven microservice development on local systems. Five design principles could be identified, including focusing small services, domain-driven design, striving for low-complexity networks, avoiding cyclic dependencies, and aiming for high connectivity performance. Integration, component, and contract tests could be integrated for automatic execution, showing that test-driven development for microservices is feasible, although with room for improvements.