framework development

Programming language extensibility has long been neglected under traditional design paradigms, impeding adaptation to diverse programming paradigms and domain-specific requirements. Method: Through a systematic literature review, we analyze four core extensibility mechanisms—macros, modules, type systems, and reflection—examining their parametrization capabilities, first-class status, and cross-mechanism composability. Contribution/Results: We propose the first integrative conceptual framework that clarifies design trade-offs and interaction semantics among these mechanisms, challenging the prevailing “closed-by-default” assumption in mainstream language design. Our analysis establishes extensibility as a fundamental language design goal, yielding principled guidelines for constructing highly adaptable languages. This work advances both theoretical modeling and engineering practice by introducing a novel paradigm and methodology grounded in extensibility-first principles.

This work addresses the challenges posed by microservice architectures—such as missing documentation, difficulty in understanding system structure, and architectural drift—stemming from decentralized, multi-repository development practices. Existing refactoring approaches struggle to generalize across projects due to their lack of modularity and technology-stack dependency. To overcome these limitations, we propose ModARO, a modular and technology-agnostic architecture reconstruction method that leverages reusable “extractors” to automatically analyze distributed codebases and reconstruct system architectures across projects. ModARO seamlessly integrates into CI/CD pipelines, enabling continuous architectural awareness. Empirical evaluation demonstrates its successful application to ten open-source systems, and a user study with eight industry practitioners confirms its significant superiority over existing baselines in terms of practicality and usability.

Existing software architecture frameworks inadequately model machine learning (ML) systems, as they overlook the needs of emerging stakeholders—such as data scientists and data engineers—and lack expressive support for ML-specific characteristics, including component uncertainty, heterogeneity, and collaborative behavior. Method: Through an empirical study involving interviews and surveys with 61 domain experts from 25 organizations across 10 countries, we systematically identified ML-relevant stakeholders and their concerns for the first time. Contribution/Results: We propose novel, ML-adapted architectural viewpoints and views, extending traditional frameworks to enable unified modeling of both ML and non-ML components. This yields the *ML-Enhanced Systems Architecture Framework Extension Guide*, which has been preliminarily adopted in industry for intelligent system architecture governance. Our work bridges a critical theoretical and practical gap in stakeholder modeling and viewpoint systematization for ML system architecture design.

Current micro-frontend architectures heavily rely on specific bundlers (e.g., Webpack), leading to inflexible module composition, constrained cross-team collaboration, and bottlenecks in error detection, runtime observability, and loading performance. To address these limitations, we propose Bundler-Independent Module Federation (BIMF)—the first runtime module federation framework decoupled from build-time bundlers. BIMF enables dynamic module loading, type-safe inter-module collaboration, and cross-team dependency sharing. It integrates runtime dependency resolution, distributed tracing, server-side rendering (SSR), and intelligent prefetching to significantly enhance observability and first-contentful-paint (FCP) performance. Experimental evaluation of a prototype implementation demonstrates: (1) full preservation of TypeScript type contracts across modules; (2) 100% dependency deduplication; (3) a 37% reduction in average module loading latency; and (4) a 42% improvement in parallel development efficiency across distributed teams.

This paper investigates validity threats arising from toolchain selection in quantitative empirical software engineering. We formally replicate three high-impact studies by extracting identical project data using four widely adopted mining tools—Git, JIRA, GitHub API, and BIC—and conduct both quantitative and qualitative comparative analyses. Results demonstrate that subtle technical discrepancies across tools—including data modeling assumptions, event definitions, and temporal window handling—propagate and significantly undermine consistency in baseline datasets, statistical outcomes, and ultimately research conclusions. To our knowledge, this is the first systematic study to reveal the critical impact of tool choice on the robustness of empirical findings. We propose a practical framework comprising enhanced tool reusability, improved analytical transparency, and mandatory cross-tool validation. This work advances methodological rigor in software evolution research by highlighting and mitigating tool-induced validity threats.

This study addresses the challenges in software architecture education—such as high abstraction, demanding prerequisite knowledge, lack of authentic project contexts, and limited resources—that hinder students’ practical competencies. To overcome these issues, the authors propose and empirically validate a reusable catalog of software architecture training patterns, collaboratively developed by universities in Colombia and Argentina. The approach integrates instructional patterns, a collaborative learning framework, and curriculum alignment strategies to orchestrate cross-institutional, industry-simulated development projects. Evaluation grounded in the Technology Acceptance Model (TAM) demonstrates that this method significantly enhances students’ architectural decision-making and design capabilities. The findings confirm its practicality and scalability under resource-constrained conditions, offering a novel paradigm for high-quality, inter-institutional software architecture education.

This work addresses the lack of a unified semantic foundation in current software systems, which creates comprehension gaps among development, usage, and governance due to deficiencies in usability, modularity, and accountability. To bridge this divide, the paper proposes grounding software semantics in domain behavioral phenomena—specifically individuals, actions, and facts—as a shared conceptual vocabulary for stakeholders. This approach systematically integrates phenomenon-based modeling into software development by organizing behaviors into conceptual units, leveraging large language models (LLMs) to map semantics to modular, readable code, and establishing agent accountability through behavior-oriented norms. Empirical evaluation demonstrates that the proposed method significantly enhances the quality of usability design, improves the modularity and readability of LLM-generated code, and strengthens the accountability of autonomous agent behaviors.

In the open-source CI ecosystem, tool functionality exhibits severe redundancy—approximately 65% of newly published CI Actions replicate existing capabilities within six months. Method: To address the extension decision problem for CI Actions on GitHub Marketplace, we propose a functional temporal graph modeling framework that integrates version history mining, dynamic graph construction, and time-aware clustering, yielding an evolutionary map covering 3,869 vendors and 6,983 tools. We innovatively define a “functional debut time” annotation mechanism to identify dominant propagation paths from pioneering tools to subsequent forks and quantify redundancy diffusion patterns. Contribution/Results: Our analysis reveals that functional replication is temporally concentrated in early phases and exhibits vendor convergence. The findings provide data-driven guidance for developers on optimal entry timing and strategic differentiation. We publicly release the complete dataset and evolutionary graph to support empirical research on software ecosystem innovation and competitive strategy.

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.

The integration of machine learning (ML) components into software product lines (SPLs) suffers from a lack of systematic variability modeling and reuse mechanisms for ML artifacts. Method: This paper proposes the first structured framework unifying SPL engineering and ML component development, grounded in feature modeling. It supports systematic variability modeling of ML functionality, component substitution, hyperparameter tuning, and cross-configuration reuse within SPLs. A prototype implementation is realized via the VariaMos tool. Contribution/Results: Empirical evaluation across multiple product configurations demonstrates improved consistency in ML component modeling, enhanced development efficiency, and strengthened decision support capabilities. The work bridges a critical theoretical and practical gap at the intersection of SPL and ML engineering, delivering a scalable, data-driven methodology for product line engineering.

To address the challenges of simultaneously generating semantically consistent yet stylistically diverse multi-artifact programming exercises—namely source code, test specifications, and natural language descriptions—this paper proposes a compositional generation framework grounded in abstract syntax building blocks. The framework defines reusable syntactic abstractions and integrates templated mapping with multi-objective instantiation to ensure intent preservation and cross-modal co-generation. Its key innovations include: (i) enabling style-controllable, diverse outputs while guaranteeing semantic consistency; and (ii) providing a highly configurable generation interface that substantially reduces customization effort for new tasks. Experimental evaluation demonstrates that the approach outperforms existing baselines across three critical dimensions: generation quality, output diversity, and system extensibility.