c#

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

A reproducible software engineering benchmark tailored for C# is currently lacking, hindering rigorous evaluation and advancement of AI coding agents for enterprise-grade languages. Method: We introduce SWE-Sharp-Bench—the first C#-specific benchmark comprising 150 real-world bug-fixing tasks derived from 17 open-source repositories, rigorously aligned with the SWE-Bench protocol to ensure automated evaluation and full reproducibility. We publicly release the entire dataset construction pipeline and conduct cross-language evaluation under uniform model agent configurations. Contribution/Results: Experiments reveal that state-of-the-art models achieve only a 40% task-solving rate on C#—significantly lower than 70% on Python—quantifying, for the first time, a critical performance gap in C# code intelligence. This work bridges a key gap in multilingual code intelligence evaluation and establishes a standardized infrastructure for C# code generation, repair, and agent research.

Answer Set Programming (ASP) developers traditionally rely on external frontend technologies to construct user interfaces, creating a barrier to rapid prototyping and tight integration of declarative logic with interactive behavior. Method: This paper introduces Clinguin, the first system enabling native interactive UI modeling directly within ASP. It extends ASP with declarative UI predicates—such as `ui/2` for interface structure and `on_event/3` for event handling—unifying UI specification and interaction logic under ASP’s logical rule formalism. Built as an extension of Clingo, Clinguin compiles ASP source code directly into dynamic, browser-executable web interfaces. Contribution/Results: Clinguin significantly lowers the UI development threshold for ASP applications: interactive prototypes can be generated from just a few lines of ASP code. The system is fully integrated into the Clingo toolchain and publicly available as open-source software.

WebAssembly (Wasm) is expanding beyond the web due to its portability and low overhead, yet the absence of a standardized system interface severely hinders software reuse and ecosystem growth in general-purpose computing. Method: This paper introduces WALI (WebAssembly Linux Interface), the first user-space, lightweight virtualization layer that natively exposes Linux system calls to Wasm modules. WALI integrates control-flow integrity enforcement with capability-based API virtualization, enabling secure, dependency-free execution while preserving binary compatibility and layered robustness. Built atop modern Wasm runtimes and leveraging existing compiler backends, it supports capability-driven API abstraction and selective passthrough of critical syscalls. Contribution/Results: Evaluation shows that multiple real-world applications require only minimal modifications to run on WALI, with bounded performance overhead. WALI significantly enhances Wasm’s applicability and deployment efficiency in general-purpose computing environments.

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.

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

This study investigates whether large language models (LLMs) can efficiently construct and maintain large-scale, multi-module software systems using only natural language prompts, particularly in emerging programming language ecosystems lacking mature toolchains. Leveraging Claude Code (Opus 4.5), the authors employed a fully prompt-driven workflow to develop a 7,420-line terminal user interface (TUI) framework within three days—implementing production-grade features such as window management, event-driven architecture, and interactive components—without writing any code manually. The project was realized through 107 concise prompts, enabling highly iterative development. This work provides the first empirical evidence that LLMs can sustain architectural consistency throughout the construction of complex software systems, thereby validating prompt-driven development as a viable new paradigm in software engineering.