implementation pattern design

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.

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.

Identifying design pattern instances in unfamiliar codebases remains challenging due to reliance on explicit annotations and rigid syntactic templates in traditional static analysis. Method: This paper pioneers the integration of large language models (LLMs) into design pattern detection, shifting focus from syntax-based matching to semantic role identification of classes. We propose a hybrid approach combining fine-tuning and prompt engineering, incorporating formal pattern role definitions, context-aware code slicing, and multi-turn reasoning for validation—adapted to CodeLlama and DeepSeek-Coder. Results: Evaluated on 12 open-source projects, our method achieves an average F1-score of 86.3%, substantially outperforming existing tools. It supports all 7 Gang-of-Four patterns and robustly detects implicit implementations, thereby enhancing software architecture comprehension, refactoring decision-making, and cross-project knowledge transfer.

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 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 lack of systematic understanding regarding the application domains, maintenance characteristics, and effective design practices of GitHub template repositories. Conducting the first large-scale empirical investigation, the work integrates data mining, statistical analysis, code quality assessment tools—detecting code smells, vulnerabilities, and security hotspots—and an LLM-as-a-judge classification approach to systematically uncover domain distributions, language-specific quality variations, and maintenance patterns. The findings reveal web development as the dominant application domain, with high-quality templates consistently adhering to software engineering best practices and offering comprehensive documentation. Through qualitative evaluation, the study distills actionable design guidelines and identifies common pitfalls, providing practical guidance for developers creating or using template repositories.

This work addresses the prevailing lack of systematic understanding of foundational formal theories in current AI compiler design, which hinders rigorous evaluation of the completeness and desirability of intermediate representations and compilation abstractions. For the first time, it systematically establishes precise correspondences between core mechanisms of MLIR—such as term rewriting systems, refinement calculi, and abstract interpretation—and classical formal theories. By grounding compiler abstractions in formal semantics, the paper clarifies the theoretical underpinnings of these constructs, articulates a precise notion of “design completeness,” and provides assessable criteria and guiding principles to navigate trade-offs between engineering pragmatism and theoretical ideals.

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 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.