research software implementation

Poor code readability in scientific software severely hinders cross-team collaboration and research reproducibility—particularly among self-taught researchers, who typically lack formal training in readability best practices, resulting in opaque naming conventions and inadequate documentation. This study employs a mixed-methods approach—including surveys, in-depth interviews, and statistical analysis—across 57 interdisciplinary researchers to empirically investigate current practices. It reveals, for the first time, that in the absence of structured training, researchers heavily rely on informal, ad hoc commenting practices; further, it identifies large language models (LLMs) as an emerging paradigm for enhancing code quality. Results show that 57.9% of participants received no readability-specific instruction, with inconsistent naming and missing documentation identified as the two primary bottlenecks. Based on these findings, we propose a lightweight, human-centered code quality support framework tailored for scientific programmers—addressing a critical gap in the human factors literature on scientific code readability.

This work addresses the often-overlooked optimization potential in existing published algorithms, where manual refinement is typically costly and inefficient. The authors propose a two-stage AI-assisted pipeline: first, a research-capable large language model identifies recently published algorithms that meet predefined experimental criteria; second, a Claude Code agent automatically reproduces baseline implementations and iteratively optimizes the code. This study presents the first systematic application of embodied coding agents to automate performance improvements across diverse domains of published algorithms, while underscoring the indispensable human role in defining objectives, validating outcomes, and ensuring ethical transparency. Evaluated on eleven cross-domain tasks, the approach consistently achieves performance gains, with each optimization cycle completed within a single day.

Scientific software frequently suffers from poor robustness, low maintainability, and weak sustainability. To address these challenges, this work systematically integrates software engineering best practices with domain-specific research requirements, proposing a set of ten high-quality principles for building scientific software across its entire lifecycle. The principles cover critical phases—including project planning, readable coding, version control, automated testing, modular design, reproducibility assurance, performance optimization, and long-term maintenance—and are supported by technical enablers such as automated documentation generation, continuous integration, and performance profiling. Designed to be both broadly applicable and practically actionable, the framework has been empirically validated across multiple scientific domains. Results demonstrate significant improvements in software reliability, reusability, and collaborative efficiency within research communities, thereby enhancing the academic impact of scientific tools and advancing open science and reproducible research ecosystems.

Doctoral students in life sciences commonly lack formal software engineering training, hindering the development of robust, reproducible, and collaborative research software. Method: This study proposes ten pedagogical principles for research software development, establishing the first systematic framework centered on “research software pedagogy”—distinct from generic programming instruction. It integrates software engineering best practices (e.g., Git-based version control, CI/CD pipelines, unit testing, RESTful API design), learning science principles, and authentic research workflows, emphasizing the seamless embedding of automation, documentation, testing, and collaborative practices throughout the research lifecycle. Contribution/Results: The framework delivers a generalizable, plug-and-play pedagogical paradigm. Deployed across multiple Chinese universities’ life sciences PhD programs, it has demonstrably improved software deliverable quality, code reusability, and cross-team collaboration efficiency—bridging critical gaps between computational literacy and rigorous, team-based scientific software practice.

To bridge the knowledge gap between academia and industry in software engineering, this paper introduces ResearchBot: an end-to-end academic knowledge service system for developers. It leverages large language models to understand real-world programming queries, employs query rewriting and semantic ranking to enhance retrieval precision, and invokes the CrossRef API to identify relevant scholarly publications. ResearchBot then generates structured, practice-oriented summaries and answers grounded in retrieved literature. Its novel modular architecture systematically addresses the semantic gap between the software engineering community and academic corpora—a first-of-its-kind solution. Evaluation on Stack Overflow–style questions demonstrates that ResearchBot significantly improves developers’ efficiency in accessing credible academic evidence. Crowdsourced assessment confirms high accuracy and practical utility of its generated summaries. This work establishes a reusable technical pathway and empirically validated paradigm for translating academic research into industrial practice.

This paper addresses the challenge of establishing performance guarantees for dynamic programming (DP) parsing algorithms in natural language processing. We present the first automated analysis system that unifies program analysis and complexity inference within a DP framework. Our approach integrates static analysis, type inference, abstract interpretation, and dependency graph modeling to enable formal verification and synthesis of efficient data structures. Key contributions include: (1) a unified formal model capturing DP control flow, data flow, and recurrence structure; (2) automatic inference of precise types, detection of dead code, and identification of redundant computations; and (3) generation of tight, parameterized upper bounds on time and space complexity. We evaluate our system on canonical parsing algorithms—including CKY, Earley, and Neural PCFG—demonstrating substantial improvements in both the automation level and precision of complexity analysis.

This work proposes a hybrid concrete-symbolic interpretation method to efficiently verify semantic equivalence between original and optimized programs in MLIR, ensuring the correctness of optimization transformations. The approach supports diverse syntactic, scheduling, and memory representations and theoretically achieves linear-time complexity for equivalence checking. Building upon this method, the authors develop a formal verifier for a subset of MLIR and successfully apply it to the AMD MLIR-AIR and MLIR-AIE toolchains as well as the standard mlir-opt infrastructure. Evaluation across hundreds of benchmark variants demonstrates the verifier’s effectiveness in validating optimization pipelines, significantly enhancing the reliability of compiler optimizations within the MLIR ecosystem.

Automatically reproducing executable bug-fix code pairs from unstructured developer Q&A posts is hindered by ambiguous descriptions and missing dependencies. This work proposes Reprodgen, the first end-to-end automated framework that leverages large language models to jointly model code intent (CI), functional requirements (FR), and structured chains of thought (SCoT) to generate semantically consistent and executable bug-fix code pairs. The approach incorporates an LLM-based iterative review mechanism coupled with real execution validation to ensure correctness. Evaluated on Stack Overflow and GitHub Issues across seven widely used data science libraries, the study introduces the first expert-validated, runnable benchmark of bug-fix pairs. Experimental results demonstrate that Reprodgen reliably reproduces code pairs exhibiting clear behavioral differences between buggy and fixed versions.

This work addresses the inefficiency and steep learning curve researchers often encounter when trying to map academic papers to their corresponding implementation code. To bridge this gap, the authors propose an automated tool powered by large language models (LLMs) that achieves cross-modal semantic alignment between scholarly texts and source code for the first time. By integrating program analysis techniques, the method automatically identifies code segments that implement specific research ideas described in a paper and generates high-quality traceability mappings. This approach substantially reduces the manual effort required for alignment, enhances the comprehensibility of research software, and improves reproducibility. Preliminary experiments demonstrate the tool’s practicality and effectiveness in real-world scenarios.