program comprehension

This study addresses the critical gap in observability of code generated by large language models, which, despite being functionally correct, often lacks the instrumentation necessary to expose production-level failures. By deploying 200 microservices on Kubernetes and injecting 13 distinct fault types, this work systematically evaluates the ability of coding agents to recover observability artifacts at the source-code level, revealing a significant disconnect between runtime fault signals and diagnostic semantics embedded in the code. To bridge this gap, the authors propose a skill-guided, observability-oriented approach. Experimental results demonstrate that current agents can only partially reconstruct such artifacts, achieving a maximum fault exposure rate of 13.99%, underscoring the substantial challenge of generating observability code imbued with fault-specific semantic context.

This study addresses the longstanding fragmentation in software artifact traceability research, characterized by incomplete linkages, ambiguous techniques, and disconnected application contexts. Through a systematic literature review, it constructs the first comprehensive traceability landscape encompassing 22 artifact types and 23 relationship kinds, and introduces a technology decision map, a standardized evaluation benchmark, and a role-oriented dynamic path alignment framework. The work uncovers critical challenges: a pervasive code-centric bias, a reproducibility crisis stemming from only 37% of studies releasing open-source artifacts, and a significant adoption gap with 95% of proposed tools never deployed in industry. In response, it offers targeted strategies to bridge these gaps, establishing a unified knowledge foundation for future research and practical implementation in traceability.

This work addresses the challenge of determining whether a local recovery point is semantically valid when structured tool-using agents fail mid-execution, particularly in scenarios where downstream components have already committed to outputs from upstream stages. The paper introduces DART, a runtime system that formalizes the notion of “semantic recoverability” for the first time. DART enables safe and efficient partial recovery by identifying failure instances, verifying semantic boundaries, aligning checkpoints, and selecting legitimate recovery points under dependency and effect constraints. Its modular architecture incorporates explicit acceptability checks to prevent invalidation of already-committed downstream work. Empirical evaluation across three LLM-driven tasks and the LangGraph framework demonstrates that DART successfully recovers all commitment-sensitive cases where baseline methods fail, with no unsafe rollbacks detected in a five-domain safety audit.

This work addresses the limitation of existing large language model–based automated program repair approaches, which rely on end-to-end test feedback and struggle to precisely identify internal logical deviations. To overcome this, the authors propose SpecTune, a framework that inserts checkpoints along execution paths to generate localized postconditions and evaluates intermediate program behaviors against dynamic execution results, thereby providing fine-grained debugging signals. SpecTune introduces an intermediate behavior reasoning mechanism and designs two key signals—a specification validation signal (α) and a discriminative signal (β)—to substantially enhance the reliability of automatically generated specifications and the precision of repairs. Experimental results demonstrate that SpecTune significantly outperforms current baseline methods in both fault localization accuracy and repair success rate.

This work addresses the limitation of large language models (LLMs), which, trained solely on static code, lack the deep, long-horizon reasoning capabilities essential for real-world software development. To bridge this gap, the authors propose a novel “understanding through refactoring” paradigm that reconceptualizes the development process as a refactorable multi-agent trajectory. By inversely synthesizing high-quality reasoning trajectories—encompassing planning, debugging, and iterative refinement—from static code, and integrating dependency graph–guided trajectory generation with search-based chain-of-thought optimization, the method enables continuous pretraining. Experiments on Llama-3-8B demonstrate significant improvements in long-context comprehension, programming proficiency, and agent-like behavioral capabilities, effectively enhancing the model’s capacity for deep reasoning.

This work addresses the limitations of large language model (LLM)-generated fault explanations, which often suffer from ambiguous causal reasoning and limited actionability, thereby hindering effective debugging. The study introduces a novel framework that treats fault explanation as an independent evaluation target, employing context partitioning to systematically analyze how combinations of code snippets, test cases, and error messages influence explanation quality. Leveraging LLM-as-a-Judge for multidimensional scoring, experiments across 93 configurations and three mainstream models demonstrate that concise contexts enriched with fault evidence significantly enhance explanation clarity. High-quality explanations not only yield higher repair pass rates but also align more closely with minimal fix strategies, whereas low-quality explanations can perform worse than a no-explanation baseline.

This work addresses the degradation of repair correctness in existing code repair agents, which often lose valid patches during repetitive generate–test–revise cycles. The study introduces a novel decomposition of the repair process into five orthogonal dimensions: admission, retention, certification, capability, and liveness. It proposes an executable specification mechanism grounded in state-bound evidence and typed revision contracts, along with an auditable reference implementation. Through branch-freezing for bias control, execution trajectory tracking, and formal verification, experiments reveal that stale execution trajectories significantly reduce repair success rates. The proposed approach effectively mitigates this degradation; however, it does not enhance overall repair capability, thereby highlighting the critical influence of system component heterogeneity and underlying bottlenecks.

Existing debugging tools excel at verifying hypotheses but struggle to support hypothesis generation, as programmers must manually reconstruct the program’s state evolution. This work proposes a novel debugging paradigm centered on complete execution traces, leveraging program tracing techniques to record and temporally visualize the actual code paths executed, rather than relying on the static structure of the source code. By presenting runtime behavior in a chronological and contextualized manner, this approach significantly enhances the comprehensibility of program execution, thereby facilitating more efficient hypothesis generation during debugging. We implement a prototype system and conduct preliminary experiments that demonstrate its effectiveness in improving program understanding efficiency, while also uncovering key challenges and promising directions for future research.

Existing approaches to recovering code from program execution videos lack formal correctness guarantees. This work proposes the first program recovery framework with provable soundness: it employs a two-layer verification oracle combining static checking and render replay to ensure behavioral equivalence between the recovered program and the original video. The framework introduces lens-equivalence to precisely define behavioral consistency and, under partial-order independence quotient conditions, guarantees that the static checker never falsely accepts an incorrect program. Empirical evaluation demonstrates zero false acceptances across 246 annotated program pairs, static certificates for 80% of in-vocabulary programs with perfect frame-by-frame replay, and a 14% recovery rate on real-world projects—significantly outperforming current vision-language models.

Existing large code models struggle to generate executable intermediate formal specifications, limiting precise verification and repair of program behavioral errors. This work proposes SpecCoder, a novel framework that focuses on generating executable inline assertions at critical program locations, thereby transforming static annotations into verifiable evidence. SpecCoder employs verification-guided training, fine-tuning the Qwen2.5-Coder series models using correct programs, behavioral mutants, and multi-round specification refinement trajectories. Evaluated on the HumanExec benchmark, SpecCoder substantially improves the correctness (+55.8%), completeness (+358.1%), and assertion validity (+26.6%) of inline specifications, significantly enhancing program verification and repair capabilities.