Pith. sign in

REVIEW 6 major objections 6 minor 57 references

Detecting the Root Cause Code Lines in Bug-Fixing Commits by Heterogeneous Graph Learning

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

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

Pith's one-line read RC_Detector claims that a GRU-based cross-line semantic retention component, added to a heterogeneous graph transformer backbone, makes root-cause code lines in bug-fixing commits easier to rank, reporting Recall@1 of 0.813 and MFR of…

desk verdict An honest incremental extension of Neural SZZ — the gating ablation is genuinely informative, but the SOTA comparison is undercut by borrowed baselines and the headline MFR gain is arithmetically inconsistent with the paper's own table. read the letter →

arxiv 2505.01022 v3 pith:I7WBH3HH submitted 2025-05-02 cs.SE

Liguo Ji , Chenchen Li , Shenglin Wang , Furui Zhan This is my paper · ORCID
classification cs.SE
keywords just-in-timedefectpredictionrootcauselocalizationheterogeneousgraphlearningbug-fixingcommitsgatedrecurrentunittorankcross-linesemanticsSZZalgorithm
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

RC_Detector is a model for locating the code lines that actually caused a bug inside a bug-fixing commit, as opposed to lines changed for refactoring or unrelated feature work. The paper argues that prior graph-based methods such as Neural SZZ aggregate semantic information across code lines but let early local semantics be washed out by global context. RC_Detector adds a gated recurrent component that uses attenuation and reinforcement gates to decide how much old and new line semantics to keep, preserving cross-line dependencies during propagation. On 675 bug-fixing commits from 87 projects, the paper reports Recall@1 of 0.813, Recall@2 of 0.900, Recall@3 of 0.929, and MFR of 1.799, beating the best previous approach by 4.32%, 7.06%, 4.81%, and 34.82%. If these numbers hold, the contribution is a concrete architectural fix for cross-line semantic loss in just-in-time defect prediction.

What carries the argument

The cross-line semantic retention component, implemented as a gated recurrent unit, is the mechanism that carries the argument. Given the previous representation $H^{(l-1)}[t]$ of a code line and the freshly aggregated neighbor vector $\tilde{H}^{(l)}[t]$ from heterogeneous graph attention, it computes an attenuation gate $r = \sigma(W_{ir}\tilde{H}^{(l)}[t]+b_{ir}+W_{hr}H^{(l-1)}[t]+b_{hr})$, a reinforcement gate $z$ in the same form, a candidate state $n = \tanh(W_{in}\tilde{H}^{(l)}[t]+b_{in}+r\odot(W_{hn}H^{(l-1)}[t]+b_{hn}))$, and the final state $H^{(l)}[t]=(1-z)\odot n+z\odot H^{(l-1)}[t]$. This lets the model retain early local semantics while absorbing new contextual information, which is exactly what the paper claims was missing.

What would settle it

Run RF, LR, SVM, XGB, KNN, Bi-LSTM, Neural SZZ, and RC_Detector on the same graph-built dataset with identical fold splits and a comparable hyperparameter budget; if any baseline reaches or beats Recall@1 of 0.813 and MFR of 1.799 under those conditions, the claimed advantage over the state of the art is not established.

Watch

Extended reading notes

Core claim

The paper's central claim is that prior root-cause line detection fails not because of weak attention but because of information loss during propagation: as graph aggregation widens, the early local semantics of a code line are overshadowed by global context, making line representations homogeneous. RC_Detector counters this by inserting a GRU-based cross-line semantic retention component between aggregation steps, with an attenuation gate and a reinforcement gate that control how much old line semantics to discard and how much newly aggregated semantics to admit. The result is that deleted lines that are true root causes keep their individual semantic identity and rank higher under a pairwise ranking loss. In the paper's evaluation this yields Recall@1 of 0.813, Recall@2 of 0.900, Recall@3 of 0.929, and MFR of 1.799, with ablations attributing the gain to the gating component.

Load-bearing premise

The reported gains over the traditional baselines assume that the numbers quoted from the earlier Neural SZZ paper were produced under preprocessing, data splits, and settings comparable to RC_Detector's environment; only RC_Detector and the Neural SZZ reimplementation were actually trained in this paper's own setup.

Editorial extensions

If this is right

  • On the combined dataset, RC_Detector reports Recall@1 0.813, Recall@2 0.900, Recall@3 0.929, and MFR 1.799, beating the best published baselines by 4.32%, 7.06%, 4.81%, and 34.82%.
  • Adding the GRU retention component to the original Neural SZZ framework improves it on every metric, so the gating mechanism transfers beyond the HGT backbone.
  • Ablation variants missing either the semantic aggregation component or the retention component perform worse on most metrics, indicating that both components contribute and that the combination is what the paper claims is superior.
  • The model ranks the true bug-inducing line first in 81.3% of cases on this dataset, meaning a developer checking only the top recommendation would be right most of the time.
  • Cross-project results (training on two of the datasets and testing on the third) also favor RC_Detector over Neural SZZ, suggesting the improvement is not solely within-project memorization.

Reading between the lines

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

  • A testable corollary of the homogenization story is that the GRU's benefit should grow with patch size: LARGE patches with more than five deleted lines have more context to drown out early local semantics, so measuring Recall@1 separately on SMALL versus LARGE subsets would check the mechanism directly.
  • The same gate pattern could transfer to other line-level software tasks where graph aggregation dilutes local semantics, such as fault localization or code-review finding ranking; the paper itself does not claim this.
  • Because the largest relative gain is in MFR (34.82%) rather than Recall (4–7%), the component mostly improves the first correct hit in the ranking; follow-up work could measure whether this rank improvement translates into faster developer fixes, not just better metrics.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

6 major / 6 minor

Summary. The paper proposes RC_Detector, a heterogeneous graph learning approach for identifying root-cause code lines in bug-fixing commits. The model builds a heterogeneous graph from syntax trees and program dependency graphs of the pre- and post-fix versions, uses HGT-style heterogeneous attention to aggregate semantic information over code-line nodes, and adds a GRU-based cross-line semantic retention component with attenuation and reinforcement gates. A RankNet module ranks deleted lines, and performance is reported as Recall@1/2/3 and Mean First Rank (MFR). The central claim is that RC_Detector outperforms the previous best method, Neural SZZ, by 4.32%, 7.06%, 4.81%, and 34.82% on these four metrics, with the GRU gating mechanism as the key new contribution.

Significance. If the empirical claims are validated, the contribution is a useful incremental extension of Neural SZZ: the GRU-based retention component is simple, clearly described, and plausibly addresses the stated problem of local semantic information being diluted in deep graph aggregation. The paper also makes its code and dataset publicly available and reports a detailed experimental environment, which are strengths. However, the central comparison is not currently a controlled experiment: several baselines' numbers are borrowed from the prior Neural SZZ paper, the reported headline improvements are internally inconsistent, and the dataset description contains conflicting totals. The significance of the paper therefore depends on the authors re-running the comparison under identical conditions and correcting the reported arithmetic.

major comments (6)
  1. [§4.2, Table 3] The central claim that RC_Detector surpasses state-of-the-art approaches is not supported by a controlled comparison. Section 4.2 states that results for RF, LR, SVM, XGB, KNN, and Bi-LSTM were taken directly from the original Neural SZZ paper, and that for Neural SZZ the authors' own retraining deviated from the original numbers, so the original reported results were used in Table 3. RC_Detector, by contrast, was run under its own preprocessing, graph construction, and ten-fold split, with hyperparameters selected during the experiments. This contradicts the statement in §5.1 that "we reproduce their experiments and experimental settings." Any differences in tokenization, graph construction, or fold boundaries could account for the reported 4.32% Recall@1 margin over Neural SZZ. The authors should re-run all baselines in the same environment and on the same folds before claiming superiority.
  2. [Abstract, §1, §5.1, Table 3] The headline numbers are internally inconsistent. Table 3 gives Neural SZZ MFR 2.425 and RC_Detector MFR 1.799, so the relative improvement is (2.425 − 1.799)/2.425 ≈ 25.8%, not 34.82%. The abstract lists eight MFR improvement values (83.15%, 96.83%, 78.71%, 74.15%, 54.14%, 91.66%, 91.66%, 34.82%) that do not correspond to any comparison reported in Table 3. The four percentages in §5.1 (4.32%, 7.06%, 4.81%, 34.82%) also do not match computations from Table 3: e.g., Recall@1 improves by 4.36%, not 4.32%. The paper must present one consistent set of relative improvements and ensure the abstract matches a single table.
  3. [Table 2 vs. Abstract, §1] The dataset description is inconsistent. Table 2 lists 241 + 957 + 291 = 1,489 bug-fixing commits, while the abstract and introduction state 675 bug-fixing commits from 87 open-source projects; the project count implied by Table 2 (nominally 135 projects) also does not match 87. The experimental section does not explain how the 675-commit version was derived, which of the two totals is used in Tables 3–10, or why the project count differs. Since every reported metric depends on the dataset, the authors must clarify the filtering procedure and reconcile the stated totals.
  4. [§4.4, Table 7] Hyperparameters appear to be selected on the evaluation benchmark. Section 4.4 reports choosing the initial learning rate 5e-6 and 8 attention heads "based on the analysis of the impact of different learning rates on model performance during our experiments," and Table 7 then reports the best configuration as the final result. Without a held-out validation set or nested cross-validation, the reported numbers are likely optimistically biased. The authors should separate model selection from final evaluation, or use nested cross-validation, and report fold-level results.
  5. [§5.2, Table 4] The ablation conclusion is contradicted by the table. RC_Detector-g achieves better Recall@3 (0.935 vs. 0.929) and better MFR (1.693 vs. 1.799) than the full RC_Detector, yet the RQ2 conclusion states that RC_Detector "outperforms models composed of single components in terms of Recall@N and MFR." The text acknowledges the exceptions but still draws an unqualified conclusion. Moreover, the differences in Recall@1 and Recall@2 (1.7% and 2.5% over RC_Detector-g) are small and are reported without variance or significance tests, so the attribution of the improvement to the specific component combination is not yet established.
  6. [§5.1, Table 3; §5.2, Table 4] No measure of variance or statistical significance is reported for any comparison. The claim that RC_Detector reliably beats Neural SZZ rests on a single 10-fold average; margins as small as 4.32% (Recall@1 in RQ1) and 1.7% (RQ2) could easily be explained by fold variation. The authors should report standard deviations or confidence intervals and per-fold results for the main comparisons, and use a paired significance test (e.g., Wilcoxon signed-rank) for Recall@N and MFR.
minor comments (6)
  1. [§5.2, Table 4] The stated 23.8% improvement in MFR from adding GRU to Neural SZZ is ambiguous: (2.425 − 1.958)/2.425 ≈ 19.3% is the usual relative improvement, while 2.425/1.958 − 1 ≈ 23.85%. Please state which convention is used consistently across the paper.
  2. [§5.3.1, Table 5] The text says GRU outperforms all alternatives across "Recall@1, Recall@2, Recall@3, and MFR metrics," but Table 5 shows that RC_Detector_LSTM has a lower MFR (1.774 vs. 1.799). The conclusion should be qualified to reflect that LSTM is better on MFR.
  3. [§5.3.2, Table 6] The reported 45.64% MFR improvement over the worst alternative is computed as (2.620/1.799 − 1) = 45.6%, whereas the usual "lower is better" relative improvement would be (2.620 − 1.799)/2.620 ≈ 31.3%. Please report relative differences in one consistent direction.
  4. [§5.4, Table 7] The text quotes four-decimal values (0.7215, 0.8140, 0.8660, 2.3943) that differ from the three-decimal table entries (0.722, 0.814, 0.866, 2.394). Make the text and table consistent.
  5. [§4.3] The formulas for Recall@N and MFR refer to "Total Actual Defects" and "Defects," but the paper does not operationalize whether the denominator is the number of bug-inducing lines or bug-fixing commits. Clarify this, as it affects the interpretation of all reported values.
  6. [Throughout] Several equations contain non-mathematical glyphs (e.g., §3.3.3, Eq. (16) and §3.5, Eq. (27)) and there are numerous typographical and grammatical errors (e.g., "approches," missing punctuation). A careful copyedit is needed.

Circularity Check

0 steps flagged · score 0.0 of 10

No definitional circularity: the root-cause prediction target is externally labeled and the model components are standard independent techniques.

full rationale

The central claim—that RC_Detector with a GRU gating component outperforms baselines on externally defined root-cause-line labels—is not circular. The target labels come from externally constructed datasets (Wen et al., Song et al., Neto et al., processed by Tang et al.), not from RC_Detector's fitted constants; the HGT backbone, CodeBERT embeddings, and RankNet loss are standard, independently published components; and the contribution is evaluated by ablation against its own variants. The paper's own Section 4.2 ('we directly used the performance results reported in the original paper for all methods except Neural SZZ') and Section 6.1 ('The main threat to internal validity is the correctness of the NSZZ implementation and the reproduction of state-of-the-art methods') disclose a comparison-fairness limitation, but copying baseline numbers is an experimental-control issue, not a definitional reduction of the claimed prediction to its inputs. Section 4.4 ('we set the number of attention heads to 8 based on experimental results') is a hyperparameter-selection concern, not a fitted-parameter-renamed-as-prediction step. The abstract's eight MFR improvement percentages are arithmetically inconsistent with Table 3 (e.g., 34.82% vs Neural SZZ is not (2.425-1.799)/2.425), but arithmetic inconsistency is a reporting error, not circularity. No load-bearing self-citation chain, uniqueness theorem, or ansatz-smuggled-via-citation is present, so the derivation is self-contained as far as circularity is concerned.

Assumptions & free parameters 2 free parameters · 4 assumptions · 0 invented entities

RC_Detector contributes no new formal axioms or invented physical entities; it imports CodeBERT, HGT, GRU, RankNet, JavaParser, Joern, GumTree, and three externally curated datasets. The load-bearing empirical assumptions are about tool correctness, label quality, and comparability of borrowed baseline numbers. Free parameters are limited to a learning rate and attention head count, both selected from Table 7 on the evaluation set.

free parameters (2)
  • initial learning rate = 5e-06
    Selected by comparing model performance on the evaluation set for three learning rates (Table 7, Section 5.4); no separate validation split is described.
  • number of attention heads = 8
    Selected from Table 7 by comparing 8 vs 16 heads on the evaluation set; 8 heads at 5e-06 had the highest Recall@1.
assumptions (4)
  • domain assumption CodeBERT line vectors preserve enough code-line semantics for ranking root-cause lines.
    Section 3.2.2 initializes every graph node with CodeBERT embeddings; if this assumption fails, attention and gating cannot compensate.
  • domain assumption JavaParser, Joern, and GumTree correctly extract syntax trees, program dependency graphs, and line mappings.
    Section 3.2.1 builds the heterogeneous graph from these tools; incorrect edges would alter message passing and rankings.
  • domain assumption The root-cause line labels in DATASET1, DATASET2, and DATASET3 are accurate enough for evaluation.
    All Recall@N and MFR numbers depend on these labels. Section 6.1 concedes label noise is a threat to internal validity.
  • domain assumption The reported baseline results from the original Neural SZZ paper are comparable to this paper's runs.
    Section 4.2 uses published numbers for RF, LR, SVM, XGB, KNN, Bi-LSTM, and Neural SZZ instead of rerunning them; comparability is load-bearing.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Detecting the Root Cause Code Lines in Bug-Fixing Commits by Heterogeneous Graph Learning." pith.science (2026). https://pith.science/paper/I7WBH3HH

@misc{pith2026250501022,
  author       = {Pith},
  title        = {Pith review of: Detecting the Root Cause Code Lines in Bug-Fixing Commits by Heterogeneous Graph Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/I7WBH3HH}},
  note         = {Machine review of arXiv:2505.01022}
}
read the original abstract

With the continuous growth in the scale and complexity of software systems, defect remediation has become increasingly difficult and costly. Automated defect prediction tools can proactively identify software changes prone to defects within software projects, thereby enhancing software development efficiency. However, existing work in heterogeneous and complex software projects continues to face challenges, such as struggling with heterogeneous commit structures and ignoring cross-line dependencies in code changes, which ultimately reduce the accuracy of defect identification. To address these challenges, we propose an approach called RC_Detector. RC_Detector comprises three main components: the bug-fixing graph construction component, the code semantic aggregation component, and the cross-line semantic retention component. The bug-fixing graph construction component identifies the code syntax structures and program dependencies within bug-fixing commits and transforms them into heterogeneous graph formats by converting the source code into vector representations. The code semantic aggregation component adapts to heterogeneous data by using heterogeneous attention to learn the hidden semantic representation of target code lines. The cross-line semantic retention component regulates propagated semantic information by using attenuation and reinforcement gates derived from old and new code semantic representations, effectively preserving cross-line semantic relationships. Extensive experiments were conducted to evaluate the performance of our model by collecting data from 87 open-source projects, including 675 bug-fixing commits. The experimental results demonstrate that our model outperforms state-of-the-art approaches, achieving significant improvements of 83.15%,96.83%,78.71%,74.15%,54.14%,91.66%,91.66%, and 34.82% in MFR, respectively, compared with the state-of-the-art approaches.

Figures

Figures reproduced from arXiv: 2505.01022 by the authors.

Figure 1
Figure 1. The overall framework of RC_Detector 3 RC_DETECTOR MODEL In this section, we provide a detailed description of the entire model algorithm. Section 3.1 gives an overview of the RC_Detector model framework and the flow of the algorithm. Then, in Sections 3.2 to 3.5, we delve into the specific components of RC_Detector. 3.1 Overview To accommodate the heterogeneity of code commits while accurately capturing the semanti… view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

57 extracted references · 42 canonical work pages

  1. [1]

    Predicting crashing releases of mobile applications

    Xin Xia, Emad Shihab, Yasutaka Kamei, David Lo, and Xinyu Wang. Predicting crashing releases of mobile applications. In Proceedings of the 10th ACM/IEEE international symposium on empirical software engineering and measurement , pages 1–10, 2016

    work page 2016

  2. [2]

    Hassan, Audris Mockus, Anand Sinha, and Naoyasu Ubayashi

    Yasutaka Kamei, Emad Shihab, Bram Adams, Ahmed E. Hassan, Audris Mockus, Anand Sinha, and Naoyasu Ubayashi. A large-scale empirical study of just-in-time quality assurance. IEEE Transactions on Software Engineering , 39(6):757–773, 2013

    work page 2013

  3. [3]

    Audris Mockus and David M. Weiss. Predicting risk of software changes. Bell Labs Technical Journal, 5(2):169–180, 2000

    work page 2000

  4. [4]

    Making fault localization in online service systems more actionable and interpretable

    Ke Xv, Shikai Guo, Hui Li, Chenchen Li, Rong Chen, Xiaochen Li, and He Jiang. Making fault localization in online service systems more actionable and interpretable. ACM Trans. Softw. Eng. Methodol., January 2025. Just Accepted

    work page 2025

  5. [5]

    Benchmarking classification models for software defect prediction: A proposed framework and novel findings

    Stefan Lessmann, Bart Baesens, Christophe Mues, and Swantje Pietsch. Benchmarking classification models for software defect prediction: A proposed framework and novel findings. IEEE transactions on software engineering , 34(4):485–496, 2008

    work page 2008

  6. [6]

    Predicting faults using the complexity of code changes

    Ahmed E Hassan. Predicting faults using the complexity of code changes. In 2009 IEEE 31st international conference on software engineering, pages 78–88. IEEE, 2009

    work page 2009

  7. [7]

    Heterogeneous defect prediction

    Jaechang Nam and Sunghun Kim. Heterogeneous defect prediction. In Proceedings of the 2015 10th joint meeting on foundations of software engineering , pages 508–519, 2015

    work page 2015

  8. [8]

    Hydra: Massively compositional model for cross-project defect prediction

    Xin Xia, David Lo, Sinno Jialin Pan, Nachiappan Nagappan, and Xinyu Wang. Hydra: Massively compositional model for cross-project defect prediction. IEEE Transactions on software Engineering , 42(10):977–998, 2016

    work page 2016

Show all 57 references
  1. [9]

    Deepjit: an end-to-end deep learning framework for just-in-time defect prediction

    Thong Hoang, Hoa Khanh Dam, Yasutaka Kamei, David Lo, and Naoyasu Ubayashi. Deepjit: an end-to-end deep learning framework for just-in-time defect prediction. In 2019 IEEE/ACM 16th International Conference on Mining Software Repositories (MSR), pages 34–45. IEEE, 2019

    2019

  2. [10]

    When do changes induce fixes? ACM SIGSOFT Softw

    Jacek Sliwerski, Thomas Zimmermann, and Andreas Zeller. When do changes induce fixes? ACM SIGSOFT Softw. Eng. Notes, 30(4):1–5, 2005

    2005

  3. [11]

    Automatic identification of bug-introducing changes

    Sunghun Kim, Thomas Zimmermann, Kai Pan, E James Jr, et al. Automatic identification of bug-introducing changes. In 21st IEEE/ACM international conference on automated software engineering (ASE’06) , pages 81–90. IEEE, 2006

    2006

  4. [12]

    A framework for evaluating the results of the szz approach for identifying bug-introducing changes

    Daniel Alencar Da Costa, Shane McIntosh, Weiyi Shang, Uirá Kulesza, Roberta Coelho, and Ahmed E Hassan. A framework for evaluating the results of the szz approach for identifying bug-introducing changes. IEEE Transactions on Software Engineering, 43(7):641–657, 2016

    2016

  5. [13]

    The impact of refactoring changes on the szz algorithm: An empirical study

    Edmilson Campos Neto, Daniel Alencar Da Costa, and Uirá Kulesza. The impact of refactoring changes on the szz algorithm: An empirical study. In 2018 IEEE 25th international conference on software analysis, evolution and reengineering (SANER), pages 380–390. IEEE, 2018

    2018

  6. [14]

    On the nature of commits

    Lile P Hattori and Michele Lanza. On the nature of commits. In 2008 23rd IEEE/ACM international conference on automated software engineering-workshops, pages 63–71. IEEE, 2008. J. ACM, Vol. 1, No. 2, Article 3. Publication date: May 2024. 3:26 Ji et al

    2008

  7. [15]

    The impact of tangled code changes on defect prediction models.Empirical Software Engineering, 21:303–336, 2016

    Kim Herzig, Sascha Just, and Andreas Zeller. The impact of tangled code changes on defect prediction models.Empirical Software Engineering, 21:303–336, 2016

    2016

  8. [16]

    Neural szz algorithm

    Lingxiao Tang, Lingfeng Bao, Xin Xia, and Zhongdong Huang. Neural szz algorithm. In 2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE) , pages 1024–1035. IEEE, 2023

    2023

  9. [17]

    Hierarchical semantic-aware neural code representa- tion

    Yuan Jiang, Xiaohong Su, Christoph Treude, and Tiantian Wang. Hierarchical semantic-aware neural code representa- tion. Journal of Systems and Software , 191:111355, 2022

    2022

  10. [18]

    Understanding semantic impact of source code changes: an empirical study, 2008

    Danhua Shao, Sarfraz Khurshid, and Dewayne E Perry. Understanding semantic impact of source code changes: an empirical study, 2008

    2008

  11. [19]

    Line-level defect prediction by capturing code contexts with graph convolutional networks

    Shouyu Yin, Shikai Guo, Hui Li, Chenchen Li, Rong Chen, Xiaochen Li, and He Jiang. Line-level defect prediction by capturing code contexts with graph convolutional networks. IEEE Transactions on Software Engineering , 2024

    2024

  12. [20]

    Feature overcorrelation in deep graph neural networks: A new perspective

    Wei Jin, Xiaorui Liu, Yao Ma, Charu Aggarwal, and Jiliang Tang. Feature overcorrelation in deep graph neural networks: A new perspective. arXiv preprint arXiv:2206.07743, 2022

    2022 arXiv

  13. [21]

    Deeper insights into graph convolutional networks for semi-supervised learning

    Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In Proceedings of the AAAI conference on artificial intelligence , volume 32, 2018

    2018

  14. [22]

    https://github.com/hellojlg/RC_Detector, 2024

    Our replication package. https://github.com/hellojlg/RC_Detector, 2024. Accessed: 2023-08-30

    2024

  15. [23]

    Classifying software changes: Clean or buggy? IEEE Transactions on software engineering, 34(2):181–196, 2008

    Sunghun Kim, E James Whitehead, and Yi Zhang. Classifying software changes: Clean or buggy? IEEE Transactions on software engineering, 34(2):181–196, 2008

    2008

  16. [24]

    Cc2vec: Distributed representations of code changes

    Thong Hoang, Hong Jin Kang, David Lo, and Julia Lawall. Cc2vec: Distributed representations of code changes. In 2020 IEEE/ACM 42nd International Conference on Software Engineering (ICSE) , pages 518–529, 2020

    2020

  17. [25]

    Jitline: A simpler, better, faster, finer-grained just-in-time defect prediction

    Chanathip Pornprasit and Chakkrit Kla Tantithamthavorn. Jitline: A simpler, better, faster, finer-grained just-in-time defect prediction. In 2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR), pages 369–379. IEEE, 2021

    2021

  18. [26]

    Code comment inconsistency detection based on confidence learning

    Zhengkang Xu, Shikai Guo, Yumiao Wang, Rong Chen, Hui Li, Xiaochen Li, and He Jiang. Code comment inconsistency detection based on confidence learning. IEEE Transactions on Software Engineering , 50(3):598–617, 2024

    2024

  19. [27]

    Anomaly detection in streaming data using isolation forest

    Mohammed Shaker Kareem and Lamia AbedNoor Muhammed. Anomaly detection in streaming data using isolation forest. In 2024 Seventh International Women in Data Science Conference at Prince Sultan University (WiDS PSU) , pages 223–228, 2024

    2024

  20. [28]

    Context-based transfer learning for structuring fault localization and program repair automation

    Lehuan Zhang, Shikai Guo, Yi Guo, Hui Li, Yu Chai, Rong Chen, Xiaochen Li, and He Jiang. Context-based transfer learning for structuring fault localization and program repair automation. ACM Trans. Softw. Eng. Methodol., November

  21. [29]

    Attention is all you need

    A Vaswani. Attention is all you need. Advances in Neural Information Processing Systems , 2017

    2017

  22. [30]

    Empirical evaluation of gated recurrent neural networks on sequence modeling

    Junyoung Chung. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014

    2014 arXiv

  23. [31]

    From ranknet to lambdarank to lambdamart: An overview

    Christopher JC Burges. From ranknet to lambdarank to lambdamart: An overview. Learning, 11(23-581):81, 2010

    2010

  24. [32]

    https://javaparser.org/

    Tools for your java code. https://javaparser.org/. Accessed: 2023-04-01

    2023

  25. [33]

    Modeling and discovering vulnerabilities with code property graphs

    Fabian Yamaguchi, Nico Golde, Daniel Arp, and Konrad Rieck. Modeling and discovering vulnerabilities with code property graphs. In 2014 IEEE symposium on security and privacy , pages 590–604. IEEE, 2014

    2014

  26. [34]

    Control flow analysis

    Frances E Allen. Control flow analysis. ACM Sigplan Notices, 5(7):1–19, 1970

    1970

  27. [35]

    The program dependence graph and its use in optimization

    Jeanne Ferrante, Karl J Ottenstein, and Joe D Warren. The program dependence graph and its use in optimization. ACM Transactions on Programming Languages and Systems (TOPLAS) , 9(3):319–349, 1987

    1987

  28. [36]

    Constructing the call graph of a program

    Barbara G Ryder. Constructing the call graph of a program. IEEE Transactions on Software Engineering , (3):216–226, 1979

    1979

  29. [37]

    Fine-grained and accurate source code differencing

    Jean-Rémy Falleri, Floréal Morandat, Xavier Blanc, Matias Martinez, and Martin Monperrus. Fine-grained and accurate source code differencing. In Proceedings of the 29th ACM/IEEE international conference on Automated software engineering, pages 313–324, 2014

    2014

  30. [38]

    Heterogeneous graph transformer

    Ziniu Hu, Yuxiao Dong, Kuansan Wang, and Yizhou Sun. Heterogeneous graph transformer. In Proceedings of the web conference 2020, pages 2704–2710, 2020

    2020

  31. [39]

    Codebert: A pre-trained model for programming and natural languages

    Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, et al. Codebert: A pre-trained model for programming and natural languages. arXiv preprint arXiv:2002.08155, 2020

    2002 arXiv

  32. [40]

    On application of learning to rank for e-commerce search

    Shubhra Kanti Karmaker Santu, Parikshit Sondhi, and ChengXiang Zhai. On application of learning to rank for e-commerce search. In Proceedings of the 40th international ACM SIGIR conference on research and development in information retrieval, pages 475–484, 2017

    2017

  33. [41]

    Yahoo! learning to rank challenge overview

    Olivier Chapelle and Yi Chang. Yahoo! learning to rank challenge overview. In Proceedings of the learning to rank challenge, pages 1–24. PMLR, 2011

    2011

  34. [42]

    Adapting deep ranknet for personalized search

    Yang Song, Hongning Wang, and Xiaodong He. Adapting deep ranknet for personalized search. In Proceedings of the 7th ACM international conference on Web search and data mining , pages 83–92, 2014. J. ACM, Vol. 1, No. 2, Article 3. Publication date: May 2024. Detecting the Root ...

    2014

  35. [43]

    Exploring and exploiting the correlations between bug-inducing and bug-fixing commits

    Ming Wen, Rongxin Wu, Yepang Liu, Yongqiang Tian, Xuan Xie, Shing-Chi Cheung, and Zhendong Su. Exploring and exploiting the correlations between bug-inducing and bug-fixing commits. In Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference a...

    2019

  36. [44]

    Regminer: towards constructing a large regression dataset from code evolution history

    Xuezhi Song, Yun Lin, Siang Hwee Ng, Yijian Wu, Xin Peng, Jin Song Dong, and Hong Mei. Regminer: towards constructing a large regression dataset from code evolution history. InProceedings of the 31st ACM SIGSOFT International Symposium on Software Testing and Analysis , pages ...

    2022

  37. [45]

    Revisiting and improving szz implementations

    Edmilson Campos Neto, Daniel Alencar Da Costa, and Uirá Kulesza. Revisiting and improving szz implementations. In 2019 ACM/IEEE International Symposium on Empirical Software Engineering and Measurement (ESEM) , pages 1–12. IEEE, 2019

    2019

  38. [46]

    Defects4j: A database of existing faults to enable controlled testing studies for java programs

    René Just, Darioush Jalali, and Michael D Ernst. 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 analysis , pages 437–440, 2014

    2014

  39. [47]

    Estimation of prediction error by using k-fold cross-validation.Statistics and Computing, 21:137–146, 2011

    Tadayoshi Fushiki. Estimation of prediction error by using k-fold cross-validation.Statistics and Computing, 21:137–146, 2011

    2011

  40. [48]

    Data quality matters: A case study on data label correctness for security bug report prediction

    Xiaoxue Wu, Wei Zheng, Xin Xia, and David Lo. Data quality matters: A case study on data label correctness for security bug report prediction. IEEE Transactions on Software Engineering , 48(7):2541–2556, 2022

    2022

  41. [49]

    Long short-term memory

    Sepp Hochreiter and Jürgen Schmidhuber. Long short-term memory. Neural Computation, 9(8):1735–1780, 1997

    1997

  42. [50]

    Gate-variants of gated recurrent unit (gru) neural networks

    Rahul Dey and Fathi M Salem. Gate-variants of gated recurrent unit (gru) neural networks. In 2017 IEEE 60th international midwest symposium on circuits and systems (MWSCAS) , pages 1597–1600. IEEE, 2017

    2017

  43. [51]

    Neural machine translation by jointly learning to align and translate.arXiv preprint arXiv:1409.0473, 2014

    Dzmitry Bahdanau. Neural machine translation by jointly learning to align and translate.arXiv preprint arXiv:1409.0473, 2014

    2014 arXiv

  44. [52]

    Graph attention networks

    Petar Veličković, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017

    2017 arXiv

  45. [53]

    Skyformer: Remodel self-attention with gaussian kernel and nystr\" om method

    Yifan Chen, Qi Zeng, Heng Ji, and Yun Yang. Skyformer: Remodel self-attention with gaussian kernel and nystr\" om method. Advances in Neural Information Processing Systems , 34:2122–2135, 2021

    2021

  46. [54]

    Are sixteen heads really better than one?Advances in neural information processing systems, 32, 2019

    Paul Michel, Omer Levy, and Graham Neubig. Are sixteen heads really better than one?Advances in neural information processing systems, 32, 2019

    2019

  47. [55]

    Graphcodebert: Pre-training code representations with data flow

    Daya Guo, Shuo Ren, Shuai Lu, Zhangyin Feng, Duyu Tang, Shujie Liu, Long Zhou, Nan Duan, Alexey Svyatkovskiy, Shengyu Fu, et al. Graphcodebert: Pre-training code representations with data flow. arXiv preprint arXiv:2009.08366, 2020

    2009 arXiv

  48. [56]

    Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation

    Yue Wang, Weishi Wang, Shafiq Joty, and Steven CH Hoi. Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation. arXiv preprint arXiv:2109.00859, 2021

    2021 arXiv

  49. [57]

    Unixcoder: Unified cross-modal pre-training for code representation

    Daya Guo, Shuai Lu, Nan Duan, Yanlin Wang, Ming Zhou, and Jian Yin. Unixcoder: Unified cross-modal pre-training for code representation. arXiv preprint arXiv:2203.03850, 2022. J. ACM, Vol. 1, No. 2, Article 3. Publication date: May 2024

    2022 arXiv

Pith tools

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