design service abstractions

Software architecture suffers from ambiguous abstraction concepts and inadequate tool support. Method: This work systematically reconstructs the seminal 1995 architectural model and proposes, for the first time, a practice-grounded conceptual framework for architectural abstraction—elevating component composition relationships to system-level abstractions that are formally modelable and verifiable. It integrates architectural description language (ADL) design, abstract modeling, prototype tool development, and diachronic historical analysis. Contribution/Results: The study establishes software architecture as an independent concern with rigorous theoretical foundations. Its outcomes catalyzed a surge in ADL research, laid the groundwork for model-based systems engineering (MBSE), and continue to inform the design of cloud-native, microservice, and AI-driven architectures. The framework significantly enhances the expressiveness, formal verifiability, and engineering applicability of architectural abstractions.

This work addresses the lack of a scalable, traceable, and systematic approach to modernizing large-scale legacy systems while preserving both functional and non-functional characteristics. The authors propose a four-phase model-driven method that leverages a semantically rich intermediate model to uniformly abstract a legacy system’s structure, dependencies, and metadata. By designing semantics-preserving transformation rules, the approach enables semi-automated migration to modern platforms such as web-based architectures. The method establishes an end-to-end model-driven pipeline that integrates semantic metadata modeling with automated code synthesis. Evaluated on an industrial-scale .NET system, it successfully migrated core UI components, significantly enhancing maintainability and scalability while reducing modernization risks and manual effort.

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.

To address the challenge of unified querying and modeling across heterogeneous software repositories (e.g., Git, Jira, CI logs), this paper proposes SEDA—a domain-specific data analytics framework for software engineering. Methodologically, SEDA introduces a multi-layer abstraction mechanism driven by Domain-Specific Operators (DSOs), integrating declarative DSL-based querying, semantics-aware modeling, and incremental data integration to achieve unified representation and efficient processing of cross-source software data. The framework enables flexible specification of analytical tasks while ensuring both high extensibility and low usability barriers. Evaluated on five real-world industrial case studies, SEDA achieves, on average, a 3.2× speedup in query execution time and a 27% improvement in modeling accuracy over conventional approaches. These gains significantly strengthen support for canonical software engineering tasks—including software evolution analysis and defect prediction—demonstrating SEDA’s practical efficacy and scalability.

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.

This study addresses the fragmentation of code and documentation generated by generative AI across the software development lifecycle, a consequence of the absence of a unified multi-layer architectural framework. To bridge this gap, the work proposes the first integrated architectural metamodel that spans business, system, and development layers, providing large language models (LLMs) with structured architectural context to enable a closed-loop transformation among code, documentation, and code. This metamodel establishes a semantic interface between human developers and LLMs, substantially improving the accuracy, stability, and reproducibility of AI-generated artifacts. Experimental results demonstrate that the approach consistently yields high-quality code and documentation while enhancing architectural consistency in AI-driven development, thereby laying a scalable foundation for intelligent software development lifecycle (SDLC) tools.

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.

While large language models (LLMs) can generate executable multi-service application environments, they often deviate from the architectural and security requirements essential for production deployment. This work proposes a method to automatically generate Dockerfiles and Docker Compose configurations solely from code repositories, evaluating deployment fidelity through end-to-end HTTP testing and structural comparison. It explicitly distinguishes between functional correctness and fidelity to deployment intent, deriving a minimal set of explicit deployment specifications that cannot be inferred automatically from source code alone. Experiments successfully reproduce the topology and dependencies of three heterogeneous multi-service systems, confirming functional feasibility; however, critical production-grade features—such as network isolation and multi-stage builds—are consistently absent, revealing fundamental limitations in current LLMs’ ability to model deployment intent.

This work addresses the challenge of maintaining up-to-date architectural documentation in microservice systems, which is exacerbated by polyglot implementations, multiple repositories, and rapid independent evolution. Existing static refactoring approaches are often limited to single-repository settings or homogeneous technology stacks. To overcome these limitations, we propose a distributed static architecture reconstruction framework that supports multi-language and multi-repository environments. The framework employs pluggable extractor modules for language-specific analysis and introduces mechanisms for cross-repository data propagation and fusion, enabling seamless interoperability with existing static analysis tools. To the best of our knowledge, this is the first framework to enable distributed, collaborative architecture reconstruction, significantly enhancing the scalability and usability of automated documentation generation and maintenance in complex microservice ecosystems.

This work addresses the lack of explicit modeling of abstraction mechanisms in existing interactive system design, which hinders actionable design guidance. Through a systematic review of 457 publications, the study proposes the first abstraction-centered design space for interactive systems, structured around six core dimensions. Leveraging this framework, it reconceptualizes the Gulf of Execution and Evaluation model to reveal the cognitive and design mechanisms by which users and systems bridge the abstraction gap. By explicitly integrating abstraction into the theoretical foundations of human–computer interaction, this research synthesizes prior work, establishes a coherent theoretical basis, and offers systematic practical guidance for designing and evaluating abstraction mechanisms in interactive systems, thereby charting new directions for future inquiry.