adapt software frameworks

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 work addresses the challenge of automating library API migration in the absence of real-world migration examples. To overcome this limitation, the authors propose a novel unsupervised approach that leverages large language models (LLMs) to generate initial migration examples without requiring labeled data. These examples are then generalized by an intelligent agent into structured, testable code transformation rules, which are integrated into the PolyglotPiranha framework for execution. This study represents the first integration of LLMs’ zero-shot generation capabilities with programmatic code transformation tools. The method successfully synthesizes reusable and generalizable migration scripts across multiple Python library migration tasks, significantly enhancing the feasibility and practicality of API migration in fully unsupervised settings.

This study addresses the limited understanding of relationships between deprecated and replacement APIs across library versions. For the first time, it integrates source code definitions with raw invocation perspectives to investigate 830 deprecation mappings across 33 Python libraries. Through similarity ranking tracking, version-by-version execution testing, and source code analysis, this work systematically examines replacement locality, parameter discrepancies, and lifecycle states. The findings quantitatively reveal complex correlations between dependency granularity and release contexts, alongside distinct replacement distribution patterns. Ultimately, this research provides empirical foundations for evolution-aware API recommendation and automated migration.

Software maintenance remains heavily reliant on manual effort, resulting in high costs, low efficiency, and susceptibility to errors. This work proposes the first systematic research framework for transfer-based software maintenance, drawing inspiration from transfer learning. The framework establishes a comprehensive lifecycle model encompassing task identification, source system selection, cross-system data matching and adaptation, and validation of transferred outcomes. It explicitly delineates the core objectives and key challenges at each stage, integrating techniques from software engineering such as knowledge transfer, cross-project data alignment, and context-aware adaptation. By doing so, the framework introduces a novel paradigm for automating software maintenance and lays a solid theoretical foundation for the future development of supporting tools and methodologies.

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.

本文解决了细粒度代码重构自动化问题，通过形式化五种Move Statement重构方法，并结合现有技术实现更细粒度的表达式移动。

This study addresses the absence of benchmarks for evaluating behavior-preserving migrations of enterprise Java applications across frameworks such as Spring, Jakarta EE, and Quarkus. The authors introduce the first systematic benchmark comprising 34 applications, 102 variants, and 204 directed migration tasks, along with an end-to-end correctness validation mechanism based on executable oracles that ensures functional equivalence through compilation, containerized deployment, and interface behavior testing. Experimental results reveal that even the most advanced coding agents achieve only a 15.3% pass rate for single-layer migrations and 12.2% for full-application migrations, with merely one of the 204 tasks attaining complete behavioral equivalence. The study further uncovers significant asymmetries in migration difficulty across framework directions and architectural layers and identifies recurring failure patterns spanning build, deployment, and testing phases.

This study addresses the failure of repository-level code migration caused by large language models overlooking cross-file dependencies. We propose a dependency-aware incremental migration framework that transcends single-file limitations by constructing dependency graphs to group translation units into dependency-consistent batches. This approach integrates compilation- and test-driven iterative verification to ensure semantic consistency. Evaluated on an industrial system comprising 51,000 lines of code, the framework achieves 100% pass rates for both compilation and testing. It significantly outperforms traditional file-level methods with faster convergence, effectively resolving critical challenges regarding completeness and scalability in large-scale code migration tasks.

This work addresses the risk that automated Python refactoring tools may inadvertently introduce behavioral changes, thereby compromising software reliability. To tackle this issue, the authors propose a novel approach that leverages foundation models as semantic oracles, integrated with Git diff parsing and automated validation, to detect behavior-altering refactorings. Applying this method to 217 refactoring instances produced by the Rope tool, the study uncovers 13 previously unknown defects, 12 of which have been acknowledged and fixed by the developers. This demonstrates the effectiveness of the technique in enhancing the trustworthiness and practical utility of automated refactoring tools.

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.