module extraction

This work addresses the limited reusability and evolvability of existing software product line (SPL) engineering approaches, which are typically tied to specific technology stacks and integrated development environments (IDEs). To overcome this constraint, the authors propose a workspace-agnostic protocol that incrementally extracts feature models from lightweight dependency units called “atoms.” The approach introduces a configuration and generation architecture comprising a generic SPL server and pluggable clients—each combining a universal frontend with a specialized backend. This design decouples SPL engineering from underlying technical spaces, enabling flexible, cross-language and cross-IDE component substitution. A prototype implementation, with a Go/Prolog-based server, a Java backend, and a JavaScript frontend, was validated on Neverlang language artifacts, demonstrating the protocol’s generality, reusability, and independence from specific development workspaces.

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.

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.

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.

Detecting design patterns and modeling code refactoring in large-scale, complex software systems remains challenging due to difficulties in representation learning and low computational efficiency. Method: This paper proposes Analytical Software Engineering (ASE), a novel design paradigm. Its core innovations include: (1) a language-agnostic, compact code abstraction—Behavior-Structure Sequence (BSS); (2) an Optimized Design Refactoring (ODR) framework integrating heuristic search with software metric encoding to eliminate iterative computation overhead inherent in conventional refactoring; and (3) a unified design balancing abstraction, tool accessibility, compatibility, and extensibility. Results: Experiments demonstrate that ASE significantly improves both design pattern detection accuracy and refactoring efficiency, validating its effectiveness for maintainability assessment and sustainable optimization. It establishes a new theoretical foundation and a scalable framework for automated analysis of complex software metrics.

Existing package managers suffer from semantic fragmentation due to language- and operating system-specific differences, making it difficult to precisely express cross-language dependencies, versioned system or hardware requirements, and hindering effective security vulnerability tracking. To address these challenges, this work proposes Package Calculus—the first unified formal model that captures the core mechanisms of mainstream package managers through semantic reduction. Serving as an intermediate representation, Package Calculus enables translation and resolution of dependencies across heterogeneous ecosystems. The model facilitates cross-language and cross-platform dependency interoperability and supports global analysis, thereby establishing a rigorous theoretical foundation and practical pathway for dependency resolution and security research.

This work addresses the challenge of automating code clone refactoring in C#, particularly the absence of behavior parameterization—a feature commonly supported in Java but lacking in non-Java languages. We propose the first language-specific “Extract Method” refactoring technique for C# that leverages lambda expressions. Our approach integrates clone detection (using NiCad), static analysis, lambda abstraction modeling, and semantic equivalence verification to achieve clone merging and behavior parameterization. Evaluated on 22 open-source C# projects comprising 2,217 clone pairs, our method safely refactors 35.0% of clones, with 28.9% successfully undergoing end-to-end automated refactoring. This work breaks from the Java-centric paradigm in clone refactoring research and pioneers lambda-driven behavior parameterization for C# clone consolidation. By jointly considering C#-specific syntactic features and rigorous refactoring feasibility assessment, it establishes a novel, multi-language–aware pathway for clone governance.

Modular control-flow handling in abstract interpretation and supporting multiple analysis strategies—such as path- vs. flow-sensitivity, forward vs. backward directionality, and upper vs. lower approximations—traditionally relies on complex monad transformers, leading to implementation brittleness and poor composability. Method: This paper introduces the *cumulative abstract semantics* framework, the first to incorporate *scoped effects* into abstract interpretation. It decouples syntactic structure from semantic behavior via two classes of effect handlers: *syntax-resolving* and *domain-semantics-introducing*. A single syntax-driven interpreter suffices to generate diverse dynamic evaluators and static analyzers. Contribution/Results: The framework eliminates heavyweight data structures, preserving expressiveness while drastically reducing implementation complexity for multi-strategy analyses. It enhances maintainability, composability, and modularity—providing a concise, unified, and extensible theoretical and practical foundation for modular program analysis.

This work addresses the challenge of undefined attribute accesses introduced by attribute grammar extensions in language frameworks that support modular, separate compilation—issues that compromise artifact reuse and trigger runtime errors. To mitigate this, we present nlgcheck, a static analysis tool designed for the Neverlang language workbench that, for the first time, enables static soundness checking of attribute grammar extensions in a separately compilable language composition system. Leveraging data-flow analysis, nlgcheck verifies the legality of attribute accesses at compile time, thereby reconciling modularity, flexibility, and static safety. Experimental evaluation demonstrates that nlgcheck effectively enhances system robustness while incurring performance overhead that remains acceptable for typical development workflows.

This study addresses the challenges of high cost, error-proneness, and defect propagation in cross-repository code and test reuse during software refactoring. Through action research, the authors conduct bidirectional empirical analyses on real-world cases such as Soot/SootUp and FindBugs/SpotBugs, identifying for the first time the bidirectional reuse requirements and semantic reuse patterns inherent in refactoring scenarios. They propose a semantic alignment–based code mapping approach coupled with a hierarchical, extensible clone detection mechanism. Experimental results demonstrate that their method reduces irrelevant clones by 33%–99% on average and achieves a benchmark precision of 86%. The practical impact is further evidenced by five reported issues and ten pull requests submitted to open-source communities, eight of which have already been merged, confirming the approach’s effectiveness and applicability.