dotnet

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.

Prior studies lack dedicated benchmarks and clear understanding of large language models’ (LLMs) capabilities in automatically generating Web API integration code. Method: We introduce the first structured, API-call-oriented evaluation dataset and an end-to-end assessment pipeline, integrating API specification parsing, functional correctness verification, and real-world execution analysis. Experiments span major open-source LLMs across diverse API integration tasks. Contribution/Results: Our evaluation reveals severe deficiencies—endpoint identification, parameter binding, and request construction—yielding a maximum task success rate below 40%. Models frequently exhibit hallucination, parameter misuse, and protocol violations. This work establishes the first multidimensional, reproducible, quantitative benchmark for assessing LLMs’ Web API code generation capability, providing a foundational dataset, rigorous methodology, and empirical evidence to advance research in API-aware intelligent programming.

This work addresses the growing complexity of modern polyglot systems, which increasingly integrate three or more languages—such as JavaScript, WebAssembly, and Rust—posing significant challenges beyond the scope of existing program analysis techniques that primarily target bilingual settings. We present the first systematic formulation of the static analysis challenges inherent to N-language interoperability and introduce a scalable, language-agnostic analysis framework. Our approach leverages multilingual runtime environments like GraalVM to model cross-language interoperability semantics and integrates interprocedural control-flow and data-flow analyses across language boundaries. This yields a theoretical roadmap for static analysis of N-language programs, laying the foundation for general-purpose analysis tools and advancing the field from bilingual toward truly polyglot program analysis paradigms.

WebAssembly lacks efficient support for managed languages such as Python and Java, limiting its applicability in domains like machine learning and data processing. This work proposes WALL-E, a novel framework that introduces an external library linking mechanism requiring no modifications to language runtimes. By leveraging a client-server architecture, WALL-E enables WebAssembly modules to interoperate efficiently with native managed-language runtimes, eliminating the overhead of nested virtual machines. The approach supports ten mainstream managed languages and achieves significant performance gains—delivering speedups of up to several hundred times over conventional nested execution models—while preserving full language compatibility. Moreover, it incurs minimal communication overhead, making it well-suited for deploying heterogeneous, multi-language applications across cloud, edge, and endpoint environments.

Existing program comprehension tools struggle to balance scalability and precision in static analysis. This paper addresses C# programs by proposing an interactive, progressive analysis framework: developers first employ lightweight interprocedural data-flow analysis to rapidly identify critical code subregions; subsequently, high-precision symbolic execution is selectively applied to those regions. The framework introduces a novel composable analysis and visualization architecture—inspired by Moldable Development—that enables on-demand assembly of customized comprehension tools directly within Visual Studio. Evaluated on real-world industrial case studies, the approach maintains analytical efficiency while significantly improving precision, thereby enhancing reasoning about complex code behaviors. Key contributions include (1) a progressive, developer-guided analysis paradigm that bridges coarse-grained scalability and fine-grained accuracy; (2) a modular, extensible architecture supporting tool composition without recompilation; and (3) empirical validation demonstrating substantial precision gains—up to 3.2× improvement in path-sensitive defect detection—without compromising analysis throughput.

This work addresses the challenges in edge and embedded application development—namely, heterogeneous software stacks, multi-language runtimes, and difficult debugging—which lead to rigid deployment workflows and complex fault diagnosis. To overcome these limitations, the paper proposes a novel architecture enabling unified end-edge-cloud development. Its core components include a single programming language, a retargetable runtime system, a local recording and replay mechanism for distributed events, and a cross-platform deployment framework. This design breaks down traditional debugging barriers in edge–cloud collaborative development, facilitating seamless scalability, consistent testing, and flexible deployment across heterogeneous environments. Evaluation of the prototype system demonstrates that the proposed approach significantly simplifies deployment procedures and enhances fault diagnosis efficiency.

This study investigates how developers practically combine programming languages to uncover the latent structure and technological composition of software ecosystems. Leveraging hundreds of thousands of posts from Stack Overflow involving 186 languages, the research uniquely integrates FP-Growth frequent itemset mining, LDA topic modeling, and Louvain community detection to consistently reconstruct the same macro-level ecosystem structure from behavioral data, thereby enabling cross-method validation. The analysis reveals strongly coupled language pairs such as Shell/Bash and Swift/Objective-C, delineates 25 distinct developer expertise profiles, and identifies three major communities—Web/enterprise, Apple ecosystem, and systems/scientific computing—with Java emerging as the central hub bridging all three.

This work addresses the challenge of automatically translating APL code into C#, a task hindered by APL’s sparse syntax, scarcity of parallel corpora, and high domain-specific barriers. To overcome these limitations, the authors propose a large language model–based neural code translation framework that integrates natural language–mediated guidance, retrieval-augmented generation, and iterative refinement, complemented by a dual verification mechanism based on compilation and execution. The study introduces the first multi-level APL-to-C# equivalent code dataset and an automated functional validation evaluation pipeline, moving beyond conventional direct translation approaches. Experimental results demonstrate that the proposed method substantially improves both translation quality and functional correctness, successfully enabling accurate conversion of APL programs of varying complexity into idiomatic C#.

Existing benchmarks primarily assess language models on localized programming tasks, failing to capture their capability to construct complete software systems from scratch. This work introduces ProgramBench, the first end-to-end evaluation framework grounded in behavioral equivalence, which requires agents to autonomously design and implement full codebases based solely on program specifications and documentation, with correctness verified through behavioral test suites. The benchmark encompasses 200 real-world software tasks—including CLI tools, FFmpeg, and SQLite—supports unconstrained, open-ended code generation, and incorporates agent-driven fuzz testing to automatically produce behavioral test cases. Evaluation across nine prominent language models reveals that none can fully solve any task; the best-performing model passes 95% of tests on only 3% of tasks and tends to generate single-file implementations structurally divergent from human-written code.