software architecture and design

This study addresses the lack of systematic guidance for enterprise software teams in choosing between monolithic and microservices architectures. The work proposes a decision-making framework that integrates technical and organizational factors, evaluating the trade-offs of each architecture across dimensions such as scalability, reliability, deployment efficiency, and organizational complexity. The assessment is grounded in system scale, business requirements, operational maturity, and long-term maintainability. Through architectural pattern analysis, a structured evaluation model, and multiple case studies, the authors develop a practical selection methodology tailored to real-world engineering contexts. This approach offers enterprises clear architectural evolution pathways and actionable guidelines aligned with their developmental stages, thereby significantly enhancing the rationality and sustainability of system design decisions.

Microservices achieve physical isolation but fail to prevent the proliferation of logical coupling, undermining module independence. This paper proposes a novel modularization paradigm based on universal interface boundaries, constructs a quantifiable model for assessing module independence, and designs a runtime mechanism supporting dynamic loading, unloading, and hot updates within a single process. Its core contributions are: (1) reframing module independence as a formal, modelable, and measurable system property—moving beyond qualitative assertions; (2) replacing implicit dependencies with explicit interface contracts to fundamentally block coupling propagation; and (3) implementing the EIGHT platform prototype, which achieves microservice-level module autonomy within a monolithic process. Experimental results demonstrate that the approach significantly reduces the impact scope of cross-module changes, enhancing system maintainability and evolutionary efficiency. It provides both theoretical foundations and practical pathways for next-generation architectures transcending the monolith–microservice dichotomy.

To address performance overhead escalation and transaction boundary degradation arising from process decomposition during monolith-to-microservices migration, this paper proposes a lightweight, trace-based what-if analysis method. The approach comprises three stages: execution trace collection and rewriting, performance-sensitive call-chain simulation, and abstract modeling of transaction boundaries—enabling rapid, quantitative assessment of non-functional property changes induced by service decomposition alternatives. Its core innovation lies in introducing the first trace-rewriting analysis paradigm prioritizing usability and speed, requiring neither source-code modification nor deployment in production-like environments. Evaluated on industrial case studies, the method completes each scenario assessment in seconds—achieving two orders-of-magnitude improvement in analysis efficiency—and thereby significantly facilitates high-frequency, low-friction iteration over service boundaries and informed trade-off decisions.

In software design, paradigm-implied semantic expectations—such as data abstraction consistency and feedback-control closed-loop behavior—are often left implicit, leading to design deviations and verification challenges. To address this, we introduce the concept of *design obligations*: explicit, logically formalizable, and verifiable specifications that codify such implicit constraints inherent to design paradigms. Leveraging formal modeling and paradigm semantics analysis, we establish two obligation frameworks—one for data-abstraction-based systems and another for feedback-driven adaptive systems—precisely capturing their core semantic requirements. We demonstrate that common design flaws stem from obligation violations and show how these obligations enable rigorous compliance verification and pedagogical application. This work bridges the semantic gap between design intent and implementation, providing both theoretical foundations and a methodological framework for paradigm-driven design assurance.

Microservice system developers lack empirical evidence regarding the types, root causes, and remediation strategies of recurring issues. Method: We adopt a mixed-methods approach—quantitatively analyzing 2,641 open-source issues, qualitatively interviewing 15 practitioners, and conducting a global survey with 150 practitioners. Contribution/Results: We introduce the first comprehensive, domain-specific three-level taxonomy (“Issue–Cause–Solution”) for microservices. We identify five high-frequency issue domains—including technical debt, CI/CD pipeline failures, and exception handling—and three predominant root causes, notably generic programming errors. From our analysis, we distill 177 actionable, context-aware remediation strategies. This work establishes an empirical foundation for microservice fault diagnosis and mitigation, delivers practical guidance for industry practitioners, and pinpoints critical research directions for next-generation microservice engineering.

This study addresses the frequent misalignment between software modularity and organizational structure in microservice architectures, stemming from a lack of quantitative understanding of how developer activities relate to service boundaries. The work proposes the concept of “organizational cohesion,” extending the classic principle of “high cohesion, low coupling” to the organizational level, and introduces metrics such as Pairwise Team Cohesion (PTC) and Average Organizational Coupling (AOC). Through a longitudinal case study and multi-project replication, the research reveals systematic differences in organizational cohesion between core and peripheral services. Notably, PTC and AOC exhibit only weak correlation, indicating that team-level cohesion and cross-service development reflect distinct organizational dynamics. These findings empirically validate the decoupling between technical architecture and organizational structure in microservice systems.

Migrating monolithic systems to microservices faces a critical challenge: the lack of systematic, code-level guidance for identifying and decoupling inter-component dependencies—existing research predominantly addresses architectural concerns while neglecting actionable, refactor-driven practices. To bridge this gap, we propose a code-level refactoring methodology tailored for microservice migration. Our approach introduces the first comprehensive refactoring catalog for migration, comprising seven empirically grounded patterns that address key scenarios—including service boundary identification, cross-service call extraction, and data decoupling. Integrating literature analysis with industrial practice, the method leverages dependency graph analysis, semantics-aware refactoring, and a hierarchical classification strategy to enable standardized and automatable migration. Experimental evaluation demonstrates that our approach significantly reduces refactoring decision complexity, improves service extraction accuracy and long-term maintainability, and delivers the first production-ready, extensible code-level migration framework for microservice evolution.

This work addresses the lack of unified and reproducible evaluation criteria for service boundary identification in the migration from monolithic systems to microservices. It presents the first systematic comparison of mainstream microservice decomposition approaches—static, dynamic, and hybrid—within a consistent experimental framework. Using standardized metric computation procedures and multiple benchmark systems (JPetStore, AcmeAir, DayTrader, Plants), the study evaluates key dimensions including structural modularity (SM), interface count (IFN), inter-component communication (ICP), and non-extreme distribution (NED). Experimental results demonstrate that HDBScan with hierarchical clustering consistently yields highly cohesive and loosely coupled microservice partitions across benchmarks, achieving an optimal trade-off between modularity strength and communication overhead, thereby significantly enhancing the objectivity and reproducibility of microservice decomposition evaluation.

This study addresses the proliferation of functional redundancy in service-oriented architectures caused by heterogeneous clients, which undermines system evolvability and maintainability. To mitigate this issue, the authors propose a novel reference architecture that synergistically integrates metadata-driven mechanisms with pattern languages. By leveraging metadata management and a plugin-based design, the approach effectively constrains service redundancy while enhancing reuse capabilities. The work innovatively combines metadata mechanisms and pattern languages in architectural construction and validates its efficacy through a triangulated evaluation method incorporating scenario-based assessment and real-world case studies. Empirical results demonstrate that the majority of system changes during evolution require no code modifications—only configuration adjustments or the addition of pluggable components—thereby significantly improving architectural stability and reuse efficiency.

This study addresses the challenge of quantifying the complexity and cost induced by external requirement changes when detailed knowledge of a system’s internal logic is unavailable. To this end, the authors propose a black-box assessment method based on a directed graph of component coupling. By analyzing component interfaces and integrating multi-view modeling—graphical, algebraic, and tabular—the approach uniquely links interface characteristics to cost factors, enabling computable bounded estimates of change-induced complexity and associated costs. The method was validated through a large-scale integration case in a retail banking platform, demonstrating its effectiveness and providing architects and operations teams with actionable, quantitative insights for system design and maintenance.