Pith. sign in

REVIEW 2 major objections 6 minor 68 references

Accelerating Automatic Program Repair with Dual Retrieval-Augmented Fine-Tuning and Patch Generation on Large Language Models

T0 review · 2 major / 6 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read SelRepair combines a dual retrieval module with full-parameter fine-tuning to reach 26.29% exact match on a Java repair benchmark, while also cutting inference time.

desk verdict Solid incremental APR paper whose headline SOTA margin is partly a test-set artifact; worth reviewing with a held-out threshold tuning requirement. read the letter →

arxiv 2507.10103 v1 pith:KTJRMGWK submitted 2025-07-14 cs.SE cs.CR

Hanyang Guo , Xiaoheng Xie , Hong-Ning Dai , Peng Di , Yu Zhang , Bishenghui Tao , Zibin Zheng This is my paper
classification cs.SEcs.CR
keywords automaticprogramrepairretrieval-augmentedgenerationlargelanguagemodelsfull-parameterfine-tuningabstractsyntaxtreeexactmatchcode-onlypromptsJavaandC/C++benchmarks
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

SelRepair is an automatic program repair method that combines full-parameter fine-tuning of a large code language model with a dual retrieval-augmented generation module. The paper claims that retrieving similar bug-fix pairs by both semantic similarity and abstract-syntax-tree structure similarity, then filtering those pairs through a similarity gate, yields higher exact-match repair rates than existing LLM-based APR methods on Java and C/C++ benchmarks while also cutting inference time by removing noisy context. A sympathetic reader would care because the result suggests that retrieval helps repair most when it is selective, and that a 7-billion-parameter code model fully fine-tuned on code-only prompts can outperform general-purpose LLMs and parameter-efficient tuning on method-level bug fixing.

What carries the argument

The load-bearing mechanism is the hybrid retriever paired with a selection gate. Each target method is parsed into an abstract syntax tree with Tree-Sitter; both the source text and the AST pre-order traversal sequence are embedded by UnixCoder, and the averaged embedding forms a hybrid vector. Candidate bug-fix pairs are ranked by cosine similarity $\kappa(V_{\text{CRBC}}, V_{\text{BC}})$ in Eq. (1), and the gate admits only pairs whose similarity exceeds a threshold, adding them in descending order until the context window fills. The fine-tuning prompt interleaves accepted pairs as $[\text{BUG}]\, RBC_i \, [\text{FIX}]\, RFC_i$ before the target $[\text{BUG}]\, BC \, [\text{FIX}]$, training the model to generate the fixed code.

What would settle it

Replace the gated retrieved pairs with an equal number of randomly selected bug-fix pairs from the same codebase, keeping context length identical. If exact match remains near 26.29%, 17.64%, and 25.46% on the three benchmarks, the retrieval signal is not what drives the gain; if it drops substantially, the similarity-ranking premise is supported. A complementary check is to bin test samples by the similarity score of the top retrieved pair and plot exact match per bin, which would reveal whether the gate threshold tracks a real performance gradient.

Watch

Extended reading notes

Core claim

The paper's central claim is that SelRepair achieves new state-of-the-art exact match scores of 26.29% on Tufano Subset 1 and 17.64% on Tufano Subset 2, and 25.46% on VulRepair, while the RAG selection gate reduces average input token length to 60.53, 133.16, and 992.25 tokens and cuts inference time by 6.42%, 13.77%, and 9.95%, respectively. The ablation study attributes the gain to both the semantic retriever and the AST-based structure-and-dependency retriever, with the structural side contributing most on short code. The paper also reports that without fine-tuning, the code-only prompt yields 0% exact match, and that LoRA fine-tuning underperforms full-parameter fine-tuning on the same design.

Load-bearing premise

The load-bearing premise is that cosine similarity between averaged code-and-AST embeddings ranks candidate bug-fix pairs by how useful they will be for repairing the target bug, so that pairs surviving the gate threshold are helpful context rather than noise.

Editorial extensions

If this is right

  • The selection gate makes RAG cheaper: a suitable threshold both improves exact match and reduces inference time, so selective context can be a general design choice for retrieval-augmented code tasks.
  • Full-parameter fine-tuning of a 7B code LLM on code-only prompts is viable and beats LoRA-based PEFT and prompt-only general LLMs on these benchmarks.
  • The AST structure-and-dependency retriever contributes most on short methods, implying structural context is especially valuable when there is little code to infer semantics from.
  • The method transfers across languages and settings: it reaches 25.46% EM on a C/C++ vulnerability repair dataset and produces 59 correct patches on the enterprise benchmark, versus one for RAP-Gen under the same beam search.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the ranking premise holds, the same gate could be adapted to other RAG-based generation tasks where retrieved context is sometimes harmful, not just program repair.
  • The paper does not report how exact match varies with the similarity score of the retrieved pair; plotting that curve would directly test whether the threshold is a real performance gradient or a proxy for something else.
  • Because the RAG codebase is randomly sampled per dataset, the approach's value may depend on codebase size and sampling; varying the sample size would show how much of the gain is simply having relevant pairs nearby.
  • The Defects4J comparison (35 vs 32 patches at beam size 10) is suggestive of cross-project generalization, but the authors note RAP-Gen's training data may leak project-specific code; a fully held-out replication would settle whether the gap is real.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 6 minor

Summary. This paper proposes SelRepair, an APR framework that combines full-parameter fine-tuning of StarCoder2-7B with a dual retrieval-augmented generation (RAG) module. The retriever encodes both source code and AST pre-order traversals with UniXcoder, averages the two vectors, and ranks bug-fix pairs by cosine similarity; a similarity gate then decides whether retrieved pairs are added to a code-only prompt. The authors evaluate on two Tufano Java subsets, the C/C++ VulRepair dataset, and an unreleased 200-sample enterprise benchmark, reporting exact-match scores of 26.29%, 17.64%, and 25.46% and inference-time reductions of 6.42%, 13.77%, and 9.95% under the selected gate thresholds. They also provide ablations of the semantic and structural retrievers, fine-tuning, and threshold settings.

Significance. If the reported numbers are taken at face value, the paper makes a credible incremental contribution: a code-specific hybrid retriever with a selection gate is a reasonable design for keeping RAG context concise, and the ablation study (Table 2) clearly attributes gains to both semantic and structural retrieval and to full fine-tuning. The work is also useful in showing that a 7B code LLM fine-tuned on code-only prompts can outperform much larger general-purpose models on method-level repair. The main strengths are the well-structured ablations, the cross-language evaluation (Java and C/C++), and the inclusion of a real-world case study, though the enterprise benchmark is not yet released and the RAP-Gen baseline numbers are only partially reproduced. An anonymous repository is provided for the public-dataset experiments.

major comments (2)
  1. [Section 4.4, Table 3] The RAG gate thresholds used for the headline results are selected on the same test sets used for the SOTA claim. For Tufano Subset 1, only the 0.9 row (26.29 EM) exceeds RAP-Gen (24.80); the adjacent 0.8 row is 24.43. For Tufano Subset 2, only 0.8 (17.64) clearly exceeds RAP-Gen (15.84), while 0.9 yields 14.72. For VulRepair, only 0.8 (25.46) clearly exceeds RAP-Gen (23.02), and 0.7 ties at 23.02. The reported advantage is therefore the maximum of a five-point test-set sweep, and small perturbations of the threshold erase the claimed margin. The thresholds should be chosen on a validation split (or pre-specified), frozen, and only then evaluated on the test set; Appendix G's discussion of coarse thresholds does not address this selection-on-test issue.
  2. [Section 4.2, Table 1] The comparison with RAP-Gen on the Tufano datasets uses EM numbers taken from the original RAP-Gen paper rather than a reproduction with the exact same training data, splits, prompt format, and decoding settings. Because the reported gains are small (1.49 and 1.80 EM points on Subsets 1 and 2), an independent rerun with the same evaluation protocol, ideally with multiple seeds or confidence intervals, is needed to confirm that the advantage is not an artifact of differing evaluation procedures. The same caution applies to the VulRepair comparison, where RAP-Gen is reproduced; report the number of test samples and the variance of the metric.
minor comments (6)
  1. [Section 4.2] The claim that SelRepairT5 outperforms RAP-Gen by 5.28% in Tufano Subset 2 is inconsistent with Table 1; 16.36 vs 15.84 is a 3.28% relative improvement (or +0.52 EM points).
  2. [Appendix E.1, Table 4] Appendix E.1 states that 2,000 samples are sampled for the VulRepair RAG codebase, while Table 4 lists 200; these numbers must be reconciled.
  3. [Appendix G] The threat-to-validity discussion should explicitly state that the thresholds in Table 3 were tuned on the test set and explain how the authors plan to avoid this in future work.
  4. [Table 3] The table reports inference-time reductions but not absolute inference times or decoding configurations; include wall-clock times, hardware, and beam settings for reproducibility.
  5. [Figure 5] The GPT-3.5 and GPT-4o prompts contain natural-language instructions and retrieved examples, whereas SelRepair uses a code-only prompt; this conflates prompt design with model capability and should be acknowledged as a confound.
  6. [Throughout] There are numerous small typographical issues (e.g., 'textitincreasing' in Section 1, 'R etrieval-Augmented G eneration' in the Introduction, 'comparision' in Appendix E.4); a careful proofread is needed.

Circularity Check

1 steps flagged · score 3.0 of 10

Test-set threshold sweep partially manufactures SelRepair's SOTA margin; no definitional circularity in the RAG/fine-tuning pipeline.

  1. fitted input called prediction [Section 4.4 (RQ3), Table 3; Section 4.2 (RQ1), Table 1; Appendix G]
    "To find the optimal setting for the RAG selection gate, we design an experiment to analyze the effect of different selection gate threshold settings (0.9, 0.8, 0.7, 0.5, and No Threshold). Table 3 reports the results, showing that SelRepair has the best performance in Tufano Subset 1 (< 50 tokens) when the threshold is 0.9. In Tufano Subset 2 (50-100 tokens) and VulRepair,SelRepair has the best performance when the threshold setting is 0.8. ..."

    The RAG selection-gate threshold is chosen by maximizing EM on the same test sets that are then used for the headline SoTA claim. The winning rows of Table 3 (0.9 for Tufano Subset 1, 0.8 for Tufano Subset 2 and VulRepair) are exactly the EM values reported in Table 1 as SelRepair's performance. Because the reported numbers are the maximum over the swept threshold values, the claimed advantage over RAP-Gen is partly a selection artifact: adjacent thresholds are much weaker (Subset 1 at 0.8 gives 24.43 vs RAP-Gen 24.80; Subset 2 at 0.9 gives 14.72; VulRepair at 0.7 ties RAP-Gen at 23.02). Appendix G acknowledges the threshold is coarse-grained but does not say it was chosen without test-set access.

full rationale

The core SelRepair pipeline is not circular by construction. The RAG codebase is sampled before the train/validation/test split (Appendix E.1: 'we random sample 1,000 samples as an RAG codebase. For the remaining samples, we split 80% of the dataset as a training set, 10% as a validation set, and 10% as a test set'), so retrieval candidates are disjoint from the test samples. The fine-tuning objective is standard language-model likelihood maximization, and the dual semantic/structural retrieval is an external similarity computation, not computed from the target output. There is no self-citation chain or imported uniqueness theorem; the method's novelty claims are evaluated against external baselines such as RAP-Gen. The only circularity-adjacent step is the RAG selection-gate threshold: Section 4.4 sweeps thresholds on the test sets and then Section 4.2 reports the best configuration's EM as SelRepair's SoTA performance. That is test-set hyperparameter selection rather than a derivation equivalent to its inputs, so the circularity score is low. The central fine-tuning and dual-RAG mechanism retains independent content, but the headline margin over RAP-Gen is fragile until the threshold is selected on a held-out set or via nested validation.

Assumptions & free parameters 6 free parameters · 5 assumptions · 0 invented entities

The main free parameter is the RAG gate threshold, selected on the test sets. The retrieval effectiveness is assumed rather than isolated against simpler baselines: the ablations remove SR or SSDR but never compare the hybrid average against BM25 or against source-only retrieval with the same gate.

free parameters (6)
  • RAG selection gate threshold t = 0.9 (Tufano Subset 1), 0.8 (Tufano Subset 2, VulRepair)
    Chosen by scanning t = no-threshold, 0.5, 0.7, 0.8, 0.9 on the test sets (Section 4.4, Table 3) and selecting the value with best EM, so it is effectively fitted to the test data.
  • Context window length = 512 (Subset 1), 1024 (Subset 2), 1500 (VulRepair) tokens
    Set per dataset in Appendix E.3; determines how many retrieved bug-fix pairs fit into the prompt and directly affects the input length and inference time reported.
  • RAG codebase size = 1000 (Tufano subsets), 2000 (VulRepair)
    Randomly sampled without a stated principled criterion (Appendix E.1); retrieval quality depends on this choice, which is not swept.
  • Fine-tuning epochs = 3 (StarCoder2, CodeLlama, LoRA), 50 (CodeT5)
    Adopted from prior work (Wang et al., 2024a; Wang et al., 2023b); affects model performance, not swept in this paper.
  • Learning rate = 5e-5
    Fixed for SFT (Appendix E.3); hyperparameter chosen by convention, not independently tuned.
  • Beam size = 10 (Defects4J and enterprise), 1 (Tufano/VulRepair evaluation)
    Beam search is used for real-world test, greedy for benchmark comparisons; affects patch count comparisons across methods.
assumptions (5)
  • domain assumption Cosine similarity between averaged UnixCoder source-code and AST-sequence embeddings is a valid relevance measure for retrieving helpful bug-fix pairs.
    Section 3.1, Eq. (1): the whole dual retrieval and the selection gate rest on this similarity scoring; no validation is provided that this ranking is better than source-only embedding or BM25.
  • ad hoc to paper UnixCoder embeddings of a source sequence and of an AST pre-order traversal can be averaged into one hybrid vector without loss of useful signal.
    Algorithm 1 lines 5-7 and 11-13: VBC = (VBCs + VBCa)/2; this averaging is introduced for this paper and not justified by prior results.
  • domain assumption Method-level bug-fix pairs from the same dataset are a sufficient external knowledge base for APR; retrieval from a different corpus or repository level would not be needed.
    Section 3.1 constructs the codebase from the training datasets; the authors contrast with repository-level retrieval (Zhang et al., 2024; Xia et al., 2024) but do not test whether cross-repository generalization holds.
  • domain assumption The code-only prompt with [BUG]/[FIX] markers is sufficient for the fine-tuned model to perform APR; no bug-type or location metadata is needed.
    Section 3.2 prompt format; the authors argue natural-language descriptions are redundant, and the poor GPT baseline performance indicates the prompt is not informative for general LLMs.
  • standard math Standard cross-entropy objective (Eq. 2) and fine-tuning procedure optimize patch generation.
    Eq. 2 is the standard language-modeling objective; not controversial.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Accelerating Automatic Program Repair with Dual Retrieval-Augmented Fine-Tuning and Patch Generation on Large Language Models." pith.science (2026). https://pith.science/paper/KTJRMGWK

@misc{pith2026250710103,
  author       = {Pith},
  title        = {Pith review of: Accelerating Automatic Program Repair with Dual Retrieval-Augmented Fine-Tuning and Patch Generation on Large Language Models},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/KTJRMGWK}},
  note         = {Machine review of arXiv:2507.10103}
}
read the original abstract

Automated Program Repair (APR) is essential for ensuring software reliability and quality while enhancing efficiency and reducing developers' workload. Although rule-based and learning-based APR methods have demonstrated their effectiveness, their performance was constrained by the defect type of repair, the quality of training data, and the size of model parameters. Recently, Large Language Models (LLMs) combined with Retrieval-Augmented-Generation (RAG) have been increasingly adopted in APR tasks. However, current code LLMs and RAG designs neither fully address code repair tasks nor consider code-specific features. To overcome these limitations, we propose SelRepair, a novel APR approach with integration of a fine-tuned LLM with a newly-designed dual RAG module. This approach uses a bug-fix pair dataset for fine-tuning and incorporates semantic and syntactic/structural similarity information through an RAG selection gate. This design ensures relevant information is retrieved efficiently, thereby reducing token length and inference time. Evaluations on Java datasets show SelRepair outperforms other APR methods, achieving 26.29% and 17.64% in terms of exact match (EM) on different datasets while reducing inference time by at least 6.42% with controlled input lengths.

Figures

Figures reproduced from arXiv: 2507.10103 by the authors.

Figure 1
Figure 1. The Workflow of SelRepair vant code. BM25 considers the code token fre￾quency as the relevance metric while code em￾bedding converts the code to vectors for similar￾ity calculation. However, these two features only consider the source code information as a refer￾ence for relevant information, though the source code only contains superficial semantics without including other programming language features, such as syn… view at source ↗
Figure 2
Figure 2. Performance on Real-world Enterprise Data [PITH_FULL_IMAGE:figures/full_fig_p008_2.png] view at source ↗
Figure 3
Figure 3. An Example of RAG in APR C Hybrid Retriever Algorithm Algorithm 1 depicts how the hybrid reviewer algo￾rithm works. Algorithm 1: Hybrid Retriever Input: C: Bug-fix pairs; T: Target buggy code; t: Similarity threshold. Output: BF: Retrieved bug-fix pair set 1 function hybrid_retriever(C,T,t) 2 BF ← [∅] 3 ASTT = AST_Parse(T) 4 ASTSeqT = AST_traversal(ASTT ) 5 VBCs = UnixCoder(T) 6 VBCa = UnixCoder(ASTSeqT ) 7 VBC = (V… view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: A Toy Example of AST Traversal E Details of Experiment Setup E.1 Details of Dataset Construction We consider two Java datasets, a C/C++ dataset and a software enterprise’s Java dataset to evaluate the performance of SelRepair. We firstly evaluate SelRepair on a public …
Figure 5
Figure 5. Figure 5: GPT-3.5 & GPT-4o Prompt Template E.3 Experiment Configuration The hyperparameter setting is shown as follows. Referring to (Wang et al., 2024a), we set the fine-tuning epochs as 3 for the large parameter (> 1B) LLM. We set the context window as 512 tokens for the Tufan…
Figure 6
Figure 6. Figure 6: Detailed Process of SelRepair for multimodal inputs and outputs. We design the same instruction-based prompt as GPT-3.5 to implement the APR task. • DeepSeek-R1-Distill: DeepSeek-R1 is a general-purpose inference model developed by DeepSeek AI company. DeepSeek-R1 uses…
Figure 7
Figure 7. Figure 7: Case Study G Threats to Validity The threats to validity include internal validity, ex￾ternal validity and construct validity. Internal validity addresses the correctness and reliability of our experiments and data processing. Issues can arise from errors in the bug-fi…

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

68 extracted references · 15 canonical work pages

  1. [1]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block STRING...

  2. [2]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

  3. [3]

    Fatmah Yousef Assiri and James M. Bieman. 2014. https://doi.org/10.1109/ICST.2014.40 An assessment of the quality of automated program operator repair . In 2014 IEEE Seventh International Conference on Software Testing, Verification and Validation, pages 273--282

    work page doi:10.1109/icst.2014.40 2014

  4. [4]

    Guru Bhandari, Amara Naseer, and Leon Moonen. 2021. https://doi.org/10.1145/3475960.3475985 Cvefixes: automated collection of vulnerabilities and their fixes from open-source software . In Proceedings of the 17th International Conference on Predictive Models and Data Analytics in Software Engineering, PROMISE 2021, page 30–39, New York, NY, USA. Associati...

    arXiv 2021

  5. [5]

    Tom Britton, Lisa Jeng, Graham Carver, and Paul Cheak. 2012. Quantify the time and cost saved using reversible debuggers. Cambridge Judge Business School, Tech. Rep

    work page 2012

  6. [6]

    Yizheng Chen, Zhoujie Ding, Lamya Alowain, Xinyun Chen, and David Wagner. 2023. https://doi.org/10.1145/3607199.3607242 Diversevul: A new vulnerable source code dataset for deep learning based vulnerability detection . In Proceedings of the 26th International Symposium on Research in Attacks, Intrusions and Defenses, RAID '23, page 654–668, New York, NY, ...

    arXiv 2023

  7. [7]

    Yuxiao Chen, Jingzheng Wu, Xiang Ling, Changjiang Li, Zhiqing Rui, Tianyue Luo, and Yanjun Wu. 2024. https://doi.org/10.1145/3639478.3647633 When large language models confront repository-level automatic program repair: How well they done? In Proceedings of the 2024 IEEE/ACM 46th International Conference on Software Engineering: Companion Proceedings, ICS...

    arXiv 2024

  8. [8]

    DeepSeek-AI, Daya Guo, Dejian Yang, Haowei Zhang, Junxiao Song, Ruoyu Zhang, Runxin Xu, Qihao Zhu, Shirong Ma, Peiyi Wang, Xiao Bi, Xiaokang Zhang, Xingkai Yu, Yu Wu, Z. F. Wu, Zhibin Gou, Zhihong Shao, Zhuoshu Li, Ziyi Gao, Aixin Liu, Bing Xue, Bingxuan Wang, Bochao Wu, Bei Feng, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, Damai D...

    arXiv 2025

Show all 68 references
  1. [9]

    Jiahao Fan, Yi Li, Shaohua Wang, and Tien N. Nguyen. 2020. https://doi.org/10.1145/3379597.3387501 A c/c++ code vulnerability dataset with code changes and cve summaries . In Proceedings of the 17th International Conference on Mining Software Repositories, MSR '20, page 508–51...

    2020

  2. [10]

    Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. 2020. https://doi.org/10.18653/v1/2020.findings-emnlp.139 C ode BERT : A pre-trained model for programming and natural languages . In Findings ...

    2020 doi

  3. [11]

    Markus Freitag and Yaser Al-Onaizan. 2017. https://doi.org/10.18653/v1/W17-3207 Beam search strategies for neural machine translation . In Proceedings of the First Workshop on Neural Machine Translation, pages 56--60, Vancouver. Association for Computational Linguistics

    2017 doi

  4. [12]

    Michael Fu, Chakkrit Tantithamthavorn, Trung Le, Van Nguyen, and Dinh Phung. 2022. https://doi.org/10.1145/3540250.3549098 Vulrepair: a t5-based automated software vulnerability repair . In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposiu...

    2022

  5. [13]

    Daya Guo, Shuai Lu, Nan Duan, Yanlin Wang, Ming Zhou, and Jian Yin. 2022. https://doi.org/10.18653/v1/2022.acl-long.499 U ni X coder: Unified cross-modal pre-training for code representation . In Proceedings of the 60th Annual Meeting of the Association for Computational Lingu...

    2022 doi

  6. [14]

    Daya Guo, Shuo Ren, Shuai Lu, Zhangyin Feng, Duyu Tang, Shujie LIU, Long Zhou, Nan Duan, Alexey Svyatkovskiy, Shengyu Fu, Michele Tufano, Shao Kun Deng, Colin Clement, Dawn Drain, Neel Sundaresan, Jian Yin, Daxin Jiang, and Ming Zhou. 2021. https://openreview.net/forum?id=jLoC...

    2021

  7. [15]

    Rahul Gupta, Soham Pal, Aditya Kanade, and Shirish Shevade. 2017. https://doi.org/10.1609/aaai.v31i1.10742 Deepfix: Fixing common c language errors by deep learning . Proceedings of the AAAI Conference on Artificial Intelligence, 31(1)

    2017 doi

  8. [16]

    Neil Houlsby, Andrei Giurgiu, Stanislaw Jastrzebski, Bruna Morrone, Quentin De Laroussilhe, Andrea Gesmundo, Mona Attariyan, and Sylvain Gelly. 2019. https://proceedings.mlr.press/v97/houlsby19a.html Parameter-efficient transfer learning for NLP . In Proceedings of the 36th In...

    2019

  9. [17]

    Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen

    Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2021. https://arxiv.org/abs/2106.09685 Lora: Low-rank adaptation of large language models . Preprint, arXiv:2106.09685

    2021 arXiv

  10. [18]

    Edward J Hu, yelong shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2022. https://openreview.net/forum?id=nZeVKeeFYf9 Lo RA : Low-rank adaptation of large language models . In International Conference on Learning Representations

    2022

  11. [21]

    Nan Jiang, Thibaud Lutellier, and Lin Tan. 2021. https://doi.org/10.1109/ICSE43902.2021.00107 Cure: Code-aware neural machine translation for automatic program repair . In 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE), pages 1161--1173

    2021

  12. [22]

    Ren\' e Just, Darioush Jalali, and Michael D. Ernst. 2014. https://doi.org/10.1145/2610384.2628055 Defects4j: a database of existing faults to enable controlled testing studies for java programs . In Proceedings of the 2014 International Symposium on Software Testing and Analy...

    2014

  13. [24]

    Kingma and Jimmy Ba

    Diederik P. Kingma and Jimmy Ba. 2015. http://arxiv.org/abs/1412.6980 Adam: A method for stochastic optimization . In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings

    2015 arXiv

  14. [25]

    Ryotaro Kou, Yoshiki Higo, and Shinji Kusumoto. 2016. https://doi.org/10.1109/IWESEP.2016.15 A capable crossover technique on automatic program repair . In 2016 7th International Workshop on Empirical Software Engineering in Practice (IWESEP), pages 45--50

    2016 doi

  15. [26]

    Anis Koubaa. 2023. https://doi.org/10.20944/preprints202303.0422.v1 Gpt-4 vs. gpt-3.5: A concise showdown . Preprints

    2023

  16. [27]

    Afshan Latif, Farooque Azam, Muhammad Waseem Anwar, and Amina Zafar. 2023. https://doi.org/10.1109/ICSTE61649.2023.00009 Comparison of leading language parsers – antlr, javacc, sablecc, tree-sitter, yacc, bison . In 2023 13th International Conference on Software Technology and...

    2023

  17. [28]

    Le, Ferdian Thung, David Lo, and Claire Le Goues

    Xuan-Bach D. Le, Ferdian Thung, David Lo, and Claire Le Goues. 2018. https://doi.org/10.1145/3180155.3182536 Overfitting in semantics-based automated program repair . In Proceedings of the 40th International Conference on Software Engineering, ICSE '18, page 163, New York, NY,...

    2018

  18. [29]

    Claire Le Goues, ThanhVu Nguyen, Stephanie Forrest, and Westley Weimer. 2012. https://doi.org/10.1109/TSE.2011.104 Genprog: A generic method for automatic software repair . IEEE Transactions on Software Engineering, 38(1):54--72

    2012 doi

  19. [30]

    Claire Le Goues, Michael Pradel, Abhik Roychoudhury, and Satish Chandra. 2021. https://doi.org/10.1109/MS.2021.3072577 Automatic program repair . IEEE Software, 38(4):22--27

    2021

  20. [31]

    Fengjie Li, Jiajun Jiang, Jiajun Sun, and Hongyu Zhang. 2024. https://arxiv.org/abs/2406.00992 Hybrid automated program repair by combining large language models and program analysis . Preprint, arXiv:2406.00992

    2024 arXiv

  21. [32]

    Raymond Li, Loubna Ben allal, Yangtian Zi, Niklas Muennighoff, Denis Kocetkov, Chenghao Mou, Marc Marone, Christopher Akiki, Jia LI, Jenny Chim, Qian Liu, Evgenii Zheltonozhskii, Terry Yue Zhuo, Thomas Wang, Olivier Dehaene, Joel Lamy-Poirier, Joao Monteiro, Nicolas Gontier, M...

    2023

  22. [33]

    B. P. Lientz, E. B. Swanson, and G. E. Tompkins. 1978. https://doi.org/10.1145/359511.359522 Characteristics of application software maintenance . Commun. ACM, 21(6):466–471

    1978

  23. [34]

    Xinyu Lin, Wenjie Wang, Yongqi Li, Shuo Yang, Fuli Feng, Yinwei Wei, and Tat-Seng Chua. 2024. https://doi.org/10.1145/3626772.3657807 Data-efficient fine-tuning for llm-based recommendation . In Proceedings of the 47th International ACM SIGIR Conference on Research and Develop...

    2024

  24. [35]

    Bissyand\' e

    Kui Liu, Anil Koyuncu, Dongsun Kim, and Tegawend\' e F. Bissyand\' e . 2019. https://doi.org/10.1145/3293882.3330577 Tbar: revisiting template-based automated program repair . In Proceedings of the 28th ACM SIGSOFT International Symposium on Software Testing and Analysis, ISST...

    2019

  25. [36]

    Anton Lozhkov, Raymond Li, Loubna Ben Allal, Federico Cassano, Joel Lamy-Poirier, Nouamane Tazi, Ao Tang, Dmytro Pykhtar, Jiawei Liu, Yuxiang Wei, Tianyang Liu, Max Tian, Denis Kocetkov, Arthur Zucker, Younes Belkada, Zijian Wang, Qian Liu, Dmitry Abulkhanov, Indraneil Paul, Z...

    2024 arXiv

  26. [37]

    Kai Lv, Yuqing Yang, Tengxiao Liu, Qinghui Gao, Qipeng Guo, and Xipeng Qiu. 2024. Full parameter fine-tuning for large language models with limited resources. In Proceedings of the 62st Annual Meeting of the Association for Computational Linguistics. Association for Computatio...

    2024

  27. [38]

    Ehsan Mashhadi and Hadi Hemmati. 2021. https://doi.org/10.1109/MSR52588.2021.00063 Applying codebert for automated program repair of java simple bugs . In 2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR), pages 505--509

    2021

  28. [39]

    Igor Melnyk, Vijil Chenthamarakshan, Pin-Yu Chen, Payel Das, Amit Dhurandhar, Inkit Padhi, and Devleena Das. 2023. https://proceedings.mlr.press/v202/melnyk23a.html Reprogramming pretrained language models for antibody sequence infilling . In Proceedings of the 40th Internatio...

    2023

  29. [41]

    Shervin Minaee, Tomas Mikolov, Narjes Nikzad, Meysam Chenaghlu, Richard Socher, Xavier Amatriain, and Jianfeng Gao. 2024. https://arxiv.org/abs/2402.06196 Large language models: A survey . Preprint, arXiv:2402.06196

    2024 arXiv

  30. [43]

    Hoang Duong Thien Nguyen, Dawei Qi, Abhik Roychoudhury, and Satish Chandra. 2013. https://doi.org/10.1109/ICSE.2013.6606623 Semfix: Program repair via semantic analysis . In 2013 35th International Conference on Software Engineering (ICSE), pages 772--781

    2013

  31. [44]

    Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. 2002. https://doi.org/10.3115/1073083.1073135 Bleu: a method for automatic evaluation of machine translation . In Proceedings of the 40th Annual Meeting on Association for Computational Linguistics, ACL '02, page 311...

    2002

  32. [45]

    Hammond Pearce, Benjamin Tan, Baleegh Ahmad, Ramesh Karri, and Brendan Dolan-Gavitt. 2023. https://doi.org/10.1109/SP46215.2023.10179324 Examining zero-shot vulnerability repair with large language models . In 2023 IEEE Symposium on Security and Privacy (SP), pages 2339--2356

    2023

  33. [46]

    Shuo Ren, Daya Guo, Shuai Lu, Long Zhou, Shujie Liu, Duyu Tang, Neel Sundaresan, Ming Zhou, Ambrosio Blanco, and Shuai Ma. 2020. https://arxiv.org/abs/2009.10297 Codebleu: a method for automatic evaluation of code synthesis . Preprint, arXiv:2009.10297

    2020 arXiv

  34. [47]

    Baptiste Rozière, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, Jérémy Rapin, Artyom Kozhevnikov, Ivan Evtimov, Joanna Bitton, Manish Bhatt, Cristian Canton Ferrer, Aaron Grattafiori, Wenhan Xiong...

    2024 arXiv

  35. [48]

    André Silva, Sen Fang, and Martin Monperrus. 2024. https://arxiv.org/abs/2312.15698 Repairllama: Efficient representations and fine-tuned adapters for program repair . Preprint, arXiv:2312.15698

    2024 arXiv

  36. [49]

    Dilara Soylu, Christopher Potts, and Omar Khattab. 2024. https://arxiv.org/abs/2407.10930 Fine-tuning and prompt optimization: Two great steps that work better together . Preprint, arXiv:2407.10930

    2024 arXiv

  37. [50]

    Tao Sun, Yang Yang, Xianfu Cheng, Jian Yang, Yintong Huo, Zhuoren Ye, Rubing Yang, Xiangyuan Guan, Wei Zhang, Hangyuan Ji, Changyu Ren, Mengdi Zhang, Xunliang Cai, and Zhoujun Li. 2024. https://openreview.net/forum?id=LaNCeNmoHR Repofixeval: A repository-level program repair b...

    2024

  38. [51]

    Weisong Sun, Chunrong Fang, Yudu You, Yun Miao, Yi Liu, Yuekang Li, Gelei Deng, Shenghan Huang, Yuchen Chen, Quanjun Zhang, Hanwei Qian, Yang Liu, and Zhenyu Chen. 2023. https://arxiv.org/abs/2305.12865 Automatic code summarization via chatgpt: How far are we? Preprint, arXiv:...

    2023 arXiv

  39. [52]

    Qwen Team. 2025. https://qwenlm.github.io/blog/qwen2.5-vl/ Qwen2.5-vl

    2025

  40. [53]

    Michele Tufano, Cody Watson, Gabriele Bavota, Massimiliano Di Penta, Martin White, and Denys Poshyvanyk. 2019. https://doi.org/10.1145/3340544 An empirical study on learning bug-fixing patches in the wild via neural machine translation . ACM Trans. Softw. Eng. Methodol., 28(4)

    2019 doi

  41. [54]

    Simon Urli, Zhongxing Yu, Lionel Seinturier, and Martin Monperrus. 2018. https://doi.org/10.1145/3183519.3183540 How to design a program repair bot?: insights from the repairnator project . In Proceedings of the 40th International Conference on Software Engineering: Software E...

    2018

  42. [55]

    Chong Wang, Jian Zhang, Yebo Feng, Tianlin Li, Weisong Sun, Yang Liu, and Xin Peng. 2024 a . https://arxiv.org/abs/2401.06391 Teaching code llms to use autocompletion tools in repository-level code generation . Preprint, arXiv:2401.06391

    2024 arXiv

  43. [56]

    Deze Wang, Boxing Chen, Shanshan Li, Wei Luo, Shaoliang Peng, Wei Dong, and Xiangke Liao. 2023 a . https://doi.org/10.1109/ICSE48619.2023.00013 One adapter for all programming languages? adapter tuning for code search and summarization . In 2023 IEEE/ACM 45th International Con...

    2023

  44. [57]

    Rongcun Wang, Senlei Xu, Yuan Tian, Xingyu Ji, Xiaobing Sun, and Shujuang Jiang. 2024 b . https://doi.org/10.1016/j.cose.2024.103994 Scl-cvd: Supervised contrastive learning for code vulnerability detection via graphcodebert . Computers & Security, 145:103994

    2024

  45. [58]

    Weishi Wang, Yue Wang, Shafiq Joty, and Steven C.H. Hoi. 2023 b . https://doi.org/10.1145/3611643.3616256 Rap-gen: Retrieval-augmented patch generation with codet5 for automatic program repair . In Proceedings of the 31st ACM Joint European Software Engineering Conference and ...

    2023

  46. [59]

    Yue Wang, Weishi Wang, Shafiq Joty, and Steven C.H. Hoi. 2021. https://doi.org/10.18653/v1/2021.emnlp-main.685 C ode T 5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation . In Proceedings of the 2021 Conference on Empirical Meth...

    2021 doi

  47. [60]

    Westley Weimer, ThanhVu Nguyen, Claire Le Goues, and Stephanie Forrest. 2009. https://doi.org/10.1109/ICSE.2009.5070536 Automatically finding patches using genetic programming . In 2009 IEEE 31st International Conference on Software Engineering, pages 364--374

    2009

  48. [61]

    Jules White, Quchen Fu, Sam Hays, Michael Sandborn, Carlos Olea, Henry Gilbert, Ashraf Elnashar, Jesse Spencer-Smith, and Douglas C. Schmidt. 2023. https://arxiv.org/abs/2302.11382 A prompt pattern catalog to enhance prompt engineering with chatgpt . Preprint, arXiv:2302.11382

    2023 arXiv

  49. [62]

    Chunqiu Steven Xia, Yinlin Deng, Soren Dunn, and Lingming Zhang. 2024. https://arxiv.org/abs/2407.01489 Agentless: Demystifying llm-based software engineering agents . Preprint, arXiv:2407.01489

    2024 arXiv

  50. [63]

    Chunqiu Steven Xia and Lingming Zhang. 2022. https://doi.org/10.1145/3540250.3549101 Less training, more repairing please: revisiting automated program repair via zero-shot learning . In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium o...

    2022

  51. [64]

    Kangwei Xu, Grace Li Zhang, Xunzhao Yin, Cheng Zhuo, Ulf Schlichtmann, and Bing Li. 2024. https://arxiv.org/abs/2407.03889 Automated c/c++ program repair for high-level synthesis via large language models . Preprint, arXiv:2407.03889

    2024 arXiv

  52. [65]

    Bissyandé, Claire Le Goues, and Shunfu Jin

    Boyang Yang, Haoye Tian, Jiadong Ren, Hongyu Zhang, Jacques Klein, Tegawendé F. Bissyandé, Claire Le Goues, and Shunfu Jin. 2024. https://arxiv.org/abs/2404.12636 Multi-objective fine-tuning for enhanced program repair with llms . Preprint, arXiv:2404.12636

    2024

  53. [66]

    He Ye, Matias Martinez, Xiapu Luo, Tao Zhang, and Martin Monperrus. 2023 a . https://doi.org/10.1145/3551349.3556926 Selfapr: Self-supervised program repair with test execution diagnostics . In Proceedings of the 37th IEEE/ACM International Conference on Automated Software Eng...

    2023

  54. [67]

    Junjie Ye, Xuanting Chen, Nuo Xu, Can Zu, Zekai Shao, Shichun Liu, Yuhan Cui, Zeyang Zhou, Chao Gong, Yang Shen, Jie Zhou, Siming Chen, Tao Gui, Qi Zhang, and Xuanjing Huang. 2023 b . https://arxiv.org/abs/2303.10420 A comprehensive capability analysis of gpt-3 and gpt-3.5 ser...

    2023 arXiv

  55. [68]

    Quanjun Zhang, Chunrong Fang, Tongke Zhang, Bowen Yu, Weisong Sun, and Zhenyu Chen. 2023. https://doi.org/10.1109/ASE56229.2023.00063 Gamma: Revisiting template-based automated program repair via mask prediction . In 2023 38th IEEE/ACM International Conference on Automated Sof...

    2023

  56. [69]

    Yuntong Zhang, Haifeng Ruan, Zhiyu Fan, and Abhik Roychoudhury. 2024. https://doi.org/10.1145/3650212.3680384 Autocoderover: Autonomous program improvement . In Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis, ISSTA 2024, page 1592–...

    2024

  57. [70]

    Zibin Zheng, Kaiwen Ning, Jiachi Chen, Yanlin Wang, Wenqing Chen, Lianghong Guo, and Weicheng Wang. 2023. https://arxiv.org/abs/2308.11396 Towards an understanding of large language models in software engineering tasks . Preprint, arXiv:2308.11396

    2023 arXiv

  58. [71]

    Zibin Zheng, Kaiwen Ning, Yanlin Wang, Jingwen Zhang, Dewu Zheng, Mingxi Ye, and Jiachi Chen. 2024. https://arxiv.org/abs/2311.10372 A survey of large language models for code: Evolution, benchmarking, and future trends . Preprint, arXiv:2311.10372

    2024 arXiv

  59. [72]

    Xin Zhou, Ting Zhang, and David Lo. 2024. https://doi.org/10.1145/3639476.3639762 Large language model for vulnerability detection: Emerging results and future directions . In Proceedings of the 2024 ACM/IEEE 44th International Conference on Software Engineering: New Ideas and...

    2024

  60. [73]

    Armin Zirak and Hadi Hemmati. 2024. https://doi.org/10.1145/3631972 Improving automated program repair with domain adaptation . ACM Trans. Softw. Eng. Methodol., 33(3)

    2024 doi

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.