apply software design patterns

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.

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 lack of empirical evidence and unclear practical efficacy of Domain-Driven Design (DDD) in complex system development. We conducted a systematic literature review (SLR), synthesizing 36 peer-reviewed studies using a mixed-methods approach combining quantitative statistical analysis and qualitative thematic coding. Our work provides the first quantitative validation that three core DDD practices—ubiquitous language, bounded contexts, and domain events—significantly improve system maintainability and business alignment. We further uncover synergistic mechanisms between DDD and microservices architecture, particularly in boundary definition and loose coupling. Key implementation barriers identified include scarcity of DDD expertise and high team competency requirements. Based on these findings, we propose a collaborative industry–academia–research pathway for pragmatic DDD adoption. The study establishes an empirical foundation and methodological framework for scientifically evaluating and engineering DDD at scale.

The academic positioning of low-code development relative to classical model-driven development remains ambiguous, and the relationship between their respective research communities lacks systematic clarification. Method: This paper conducts the first meta-scientific study, integrating bibliometric analysis, author-venue-topic network modeling, and cross-community comparative analysis to quantitatively characterize the low-code community’s scale, disciplinary diversity, publication venue distribution, and scholarly output characteristics—and to systematically compare them with those of the classical model-driven development community. Contribution/Results: We find that the low-code community exhibits strong interdisciplinarity and conference-centric publication patterns, and has significantly diverged from traditional modeling communities. These findings provide empirical grounding for conceptualizing low-code as an independent research trajectory, reveal opportunities for disciplinary integration, and identify critical interfaces for collaborative innovation—thereby informing the reconfiguration and convergence of the broader modeling research community.

In enterprise-grade GUI development, the Model-View-ViewModel (MVVM) pattern is frequently misapplied due to insufficient guidance on implementation details and architectural trade-offs. Method: This study conducts a multi-vocal literature review (MLR), systematically synthesizing academic papers, technical blogs, and monographs (i.e., white and gray literature) to comprehensively analyze MVVM practice. Contribution/Results: We identify and formalize 76 novel design constructs spanning 29 dimensions—extending beyond MVVM’s traditional monolithic definition—and explicitly characterize 16 new benefits and 15 new drawbacks. Based on this analysis, we construct an actionable MVVM design knowledge graph and a structured, context-sensitive guideline to support robust architectural decision-making. Empirical validation demonstrates that our framework significantly enhances maintainability and evolvability of complex GUI systems.

This work addresses the common neglect of software design principles in existing automated code generation approaches, which often results in mobile applications with poor architectural quality. To overcome this limitation, the authors propose a novel method that integrates software product line engineering with variability modeling of design patterns. For the first time, the Universal Variability Language (UVL) is employed to explicitly capture structural and behavioral variations of design patterns, enabling their integration as configurable assets within the code generation pipeline. Leveraging UVL models, the Jinja templating engine, and Swift-based code synthesis, the proposed system supports the customizable, automated generation of design patterns such as Singleton and Strategy. This approach not only preserves architectural integrity but also significantly enhances application maintainability and reusability.

This study addresses the challenge of automatically detecting software design patterns in source code to support architectural understanding and quality assessment. It presents the first systematic evaluation of four large language models—including NextCoder and Gemma 3—as well as two ensemble strategies combining three models, for recognizing five classic design patterns: Singleton, Adapter, Bridge, Composite, and Decorator. The work investigates the impact of three input modalities—raw source code, PlantUML diagrams, and textual descriptions—on detection performance. Experimental results demonstrate that NextCoder and Gemma 3 achieve the highest accuracy among individual models, while ensemble approaches further enhance performance, thereby confirming the effectiveness and potential of large language models in design pattern recognition tasks.

This study addresses the challenge that large language models (LLMs) often fail to consistently adhere to software design patterns during code generation, thereby compromising architectural quality. To mitigate this issue, the authors propose four prompting strategies—instructional prompting, binary automated feedback, detailed automated feedback, and feedback augmented with few-shot examples—and evaluate their effectiveness across 13 LLMs on 164 Java tasks from the HumanEval-X benchmark, focusing specifically on the Singleton pattern. Experimental results reveal substantial variation in how different models respond to these strategies, demonstrating that lightweight feedback mechanisms can effectively guide adherence to design patterns. Notably, Llama 3.3 achieves 100% structural compliance with the Singleton pattern under instructional prompting, yielding a 34.1 percentage point increase in test pass rate, while Qwen 3 (8B) attains 99.2% pattern alignment and 58.6% functional correctness using binary feedback.

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 lack of large-scale empirical evidence on the practical application, evolution, and impact on maintenance quality of Domain-Driven Design (DDD) in open-source projects. Through a pre-registered empirical approach combining the GitHub Search API, keyword filtering, manual assessment, and longitudinal commit history analysis, the work systematically investigates the distribution, co-occurrence, and evolution of DDD tactical building blocks, as well as violations of bounded context boundaries. It provides the first large-scale quantitative evidence of the prevalence of such boundary violations and establishes a temporal association between the evolution of DDD building blocks and software maintenance activities. These findings offer crucial empirical grounding for improving DDD tooling and refining its practical adoption.