Pith. sign in

REVIEW 3 major objections 6 minor 85 references

Continuously Learning Bug Locations

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

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

Pith's one-line read Continual learning agents localize buggy changesets more accurately than deep learning baselines when software code evolves, while training up to five times faster.

desk verdict CL bug localization beats DL baselines only because the baselines never see non-stationary data; retrained baselines are the missing control. read the letter →

arxiv 2412.11289 v1 pith:ARDMRG5U submitted 2024-12-15 cs.SE

Paulina Stevia Nouwou Mindom , Leuson Da Silva , Amin Nikanjam , Foutse Khomh This is my paper · ORCID
classification cs.SE
keywords ContinuallearningBuglocalizationDeepreinforcementConceptdriftCatastrophicforgettingChangesetsBug-inducingfactorsSoftwaremaintenance
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

The paper sets out to show that continual learning (CL) agents can keep locating buggy changesets accurately when software code evolves between the time a bug is reported and the time it is fixed, a situation the authors call non-stationary data. They train two deep reinforcement learning agents, CLEAR and EWC, cyclically on stationary and non-stationary changeset-files and hunks from seven Apache projects, and compare them with deep learning baselines. The reported result is that the CL agents beat the FLIM and RLOCATOR baselines in the non-stationary setting by up to 61 percent in MRR, 44 percent in MAP, 83 percent in top@1, 56 percent in top@5, and 66 percent in top@10, while needing up to five times less training time; against the BERT-based FBL-BERT baseline, they win on top@5 and top@10 but trail on MRR and top@1. Augmenting the reward function with a logistic regression score built from bug-inducing factors improves the CL agents on several projects and reduces forgetting. A sympathetic reader would take away that continual learning is a cheap way to keep bug localization useful as code drifts.

What carries the argument

The central machinery is a deep reinforcement learning formulation of bug localization. The agent's state is a concatenation of CodeBERT embeddings for a bug report and for up to 31 changeset-files or hunks retrieved by an Elasticsearch index; its action is picking one item to move into a ranked list, and its reward is based on the rank of relevant changesets and the distance between them in the list. Continual learning comes from two mechanisms: CLEAR, a rehearsal method that mixes new and replayed experiences and corrects off-policy drift with V-Trace importance weights, and EWC, a regularization method that penalizes changes to weights important for previous tasks via the Fisher information matrix. A third component, the logistic regression model over bug-inducing factors, produces a scalar bug-probability that is added into the reward function.

What would settle it

Retrain FLIM, RLOCATOR, and FBL-BERT on the same non-stationary training stream, the commits between bug report and fix, given to CLEAR and EWC, and check whether their MRR, top@1, and top@5 on the non-stationary test split still trail by the reported margins.

Watch

Extended reading notes

Core claim

The central claim is that rehearsal- and regularization-based continual learning agents can handle concept drift in bug localization without the performance collapse seen in deep learning models trained on stationary, fix-time data. CLEAR, an experience-replay method that uses V-Trace off-policy correction, and EWC, a weight-consolidation method that uses the Fisher information matrix, are trained in sequence on stationary and non-stationary changeset-files and hunks. On non-stationary data the authors report large gains over FLIM and RLOCATOR, as summarized in the abstract, and they report that the agents mitigate catastrophic forgetting across the two tasks. They further report that adding a logistic regression score over bug-inducing factors, reduced to churn and pre-release bugs, improves performance on four of seven projects at the changeset-file level and three of seven at the hunk level, and lowers forgetting values. The paper also acknowledges that the BERT-based FBL-BERT baseline retains an advantage in MRR and top@1, while the CL agents lead on top@5 and top@10.

Load-bearing premise

The comparison assumes that the correct baselines are deep learning models trained only on stationary, fix-time data; if those baselines were retrained or incrementally updated on the non-stationary data the CL agents receive, the reported advantage might shrink or disappear.

Editorial extensions

If this is right

  • Bug localization tools built on CL agents can keep ranking relevant changesets as code evolves, without full retraining from scratch on every new version.
  • Developers can train CL agents for a new project with up to five times less compute than the deep learning baselines, making continuous updates practical on smaller infrastructure.
  • Adding cheap bug-inducing signals such as churn and pre-release bug history to the reward function improves ranking and reduces catastrophic forgetting, so prior project knowledge can be folded into the agent at no extra training-data cost.
  • Because CL agents mitigate forgetting across stationary and non-stationary tasks, the same mechanism can carry over to other software engineering tasks that suffer from concept drift, such as defect prediction, malware detection, and test-case prioritization, which the paper lists as recommended applications.

Reading between the lines

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

  • An implication the authors leave implicit is that the reported advantage is measured against baselines that were not retrained on the non-stationary stream; if FLIM, RLOCATOR, or FBL-BERT were periodically updated on the same evolving data, the gap could be materially smaller.
  • A testable extension would be to replace the logistic regression reward component with an online-learned bug-proneness estimator, so the prior knowledge adapts to the same drift the agent is learning from.
  • The CL agents' lower top@1 relative to FBL-BERT suggests a hybrid design that uses FBL-BERT's retrieval refinement for the first result and CL ranking for the full list could combine both strengths.
  • Because the evaluation covers seven Java projects, a natural next test is whether the same CL setup transfers across programming languages or across projects with different commit densities.
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

3 major / 6 minor

Summary. The paper proposes applying two continual-learning agents, CLEAR (experience replay) and EWC (elastic weight consolidation), to bug localization over changeset-files and hunks, and augments their reward function with a logistic-regression model of bug-inducing factors. The authors evaluate the agents on seven open-source Java projects against three DL baselines (FLIM, RLOCATOR, FBL-BERT), reporting MRR, MAP, top@1/5/10, forgetting, and training time. The headline claims are that CL agents outperform DL baselines in non-stationary settings by up to 61% in MRR (and correspondingly in other metrics), reduce catastrophic forgetting, and require up to 5x less training effort.

Significance. Timely and practically motivated: concept drift is a real threat to DL-based bug localization, and the idea of adapting CL/DRL agents to ranking buggy changesets is interesting. The paper covers two distinct CL mechanisms, two granularities, seven projects, and provides a replication package; it also reports a forgetting metric and repeated runs. If the empirical claims were established under a fair comparison, the result would be a useful step toward adaptive bug localization. At present, however, the central comparison is confounded by a training-distribution asymmetry, and the regression-based reward appears to use oracle information from the fix commit. The contribution is therefore not yet demonstrated.

major comments (3)
  1. [§5.1–5.2 (Tables 3–10)] The RQ2 comparison is confounded by a training-distribution asymmetry. Section 5.1 states that 'FLIM and RLOCATOR baseline studies trained and evaluated their proposed approaches on changeset-files collected when bugs are fixed only,' while the CL agents are 'sequentially trained on both stationary and non-stationary data' (Section 5.2 Method). The CL agents are therefore exposed at training time to the same kind of non-stationary stream on which they are later evaluated, whereas the DL baselines are not. The paper itself (Section 1) identifies retraining and incremental updating as the standard remedies for concept drift, yet neither is included as a baseline. As a result, the headline improvements in the abstract and Finding 2 (up to 61% MRR, 44% MAP, etc.) may simply reflect different training distributions rather than the replay/EWC mechanisms. The same issue affects the FBL-BERT comparisons in Tables 9–10, where CL scores are averaged over stationary and non-stationary data but no retrained or incrementally updated FBL-BERT variant is supplied. Please add retrained/incremental baselines, or at minimum evaluate all techniques under identical training-data conditions.
  2. [§4.1.3, Table 1, Eq. (5)] The logistic-regression reward appears to leak the bug-fixing oracle. The retained features Churn and PRE are defined using the fix commit: PRE is computed 'based on the set of files updated when fixing a given bug,' and Churn uses 'the diff associated with the bug commit under analysis' (Section 4.1.3, Table 1). Adding the fitted model's output to the reward in Eq. (5) thus rewards actions according to properties of the very commit that the technique is supposed to predict. Even if the logistic regression is fit only on training bugs, applying it to a test bug requires computing these features from that test bug's fix diff, which is the localization target. This likely inflates the '+Reg' results in RQ3 (Finding 3) and the Section 5.4 ablation, and it also affects the RLOCATOR+Reg variants. The features must be redefined using only information available before the fix (e.g., the latest pre-fix version), or the regression-enhanced results should be presented as an oracle upper bound.
  3. [§5.2, Tables 19–20] The 'up to 5x less computational effort' claim is not an apples-to-apples comparison. Table 19 reports one-time training costs for FLIM/RLOCATOR on stationary fix-time data, while the CL agents are trained cyclically on both stationary and non-stationary tasks (Section 4.1). The cost of retraining or incrementally updating the DL baselines on the non-stationary stream—the standard remedies the paper motivates in Section 1—is not measured. Without that reference point, the training-time advantage cannot be attributed to continual learning rather than to the different training protocol, and the abstract's '5x less' claim is not established.
minor comments (6)
  1. [§3, Figure 1] The text reports a performance drop of '9% to 194%' in top@1, top@5, and MRR, but for metrics bounded by [0,1] a relative decrease cannot exceed 100%; please clarify the calculation or the reference value.
  2. [§4.2] The list of Apache projects is given as '(AspectJ, Birt, JDT, PDE, Eclipse, Zxing, Tomcat, and Birt)', with Birt listed twice; since JDT is excluded, the resulting seven projects should be named consistently with Table 2.
  3. [§5.1] The text appears to cite 'FLIM [13] and RLOCATOR [37]', but in the reference list [13] is RLocator and [37] is FLIM; the citations should be swapped.
  4. [Tables 13–22] Several captions repeat 'In bold are the best average performances' (e.g., Table 13); please remove the duplicate phrase.
  5. [§4.1.2] Equation (2) and the surrounding text define Fisher information in terms of parameters learned on task A; the phrase 'the learned parameters θ*_A of a task B' should say 'of task A'.
  6. [§5] The paper repeatedly states that differences are statistically significant, but the tables do not report p-values or effect sizes; a compact significance summary should be included in the paper itself, not only in the replication package.

Circularity Check

1 steps flagged · score 6.0 of 10

The enhanced-CL reward is built from the bug-fix commit's diff, so the logistic-regression 'bug probability' is the ground truth in disguise.

  1. self definitional [Section 4.1.3 (bug-inducing factors, Table 1 bullets) and Section 4.1.4 (Eq. 5)]
    "In this model, the independent variables correspond to the bug-inducing factor metrics, while the dependent variable is a binary variable indicating whether a file contains one or more bugs. ... Code Churn (Churn): We compute the number of lines of code added, modified, or deleted. We get the diff associated with the bug commit under analysis and get the required information. ... R(𝑜,𝑎) =R(𝑜,𝑎)+ 𝑏𝑢𝑔𝑝𝑟𝑜𝑏𝑎𝑏𝑖𝑙𝑖𝑡𝑦𝑖𝑛𝑑𝑖𝑐𝑎𝑡𝑜𝑟 (5)"

    After removing insignificant and collinear variables, the regression's inputs are Churn and PRE (Section 4.1.3). Churn is the diff of 'the bug commit under analysis' and PRE is computed from 'the set of files updated when fixing a given bug'. In the benchmark, those files are exactly the ground-truth buggy changeset-files. Hence the independent variables are nonzero precisely for the dependent-variable positives: the logistic model is a function of the label it claims to predict. The output is then added to the DRL reward (Eq. 5), so the agent is trained with an oracle-derived 'bug probability indicator'.

full rationale

The strongest CL-vs-DL comparison (RQ2) is not circular: test bugs are held out by date and the CL agents do not observe the test labels, although the comparison is confounded because FLIM and RLOCATOR are not trained on non-stationary data. That is a baseline-fairness and validity issue, not a definitional reduction. Self-citations such as [42] are not load-bearing, and the CLEAR/EWC mechanisms are adopted from external work. The concrete circularity is in RQ3 and the ablation: the 'bug-inducing factors' Churn and PRE are computed from the bug-fixing commit, i.e., from the ground-truth label. The logistic regression's remaining inputs therefore encode the outcome, and adding its output to the reward (Eq. 5) injects the answer into the training signal. Because this affects a central contribution—the enhanced CL agents—rather than only a marginal claim, the paper earns a partial-circularity score of 6. The unenhanced CL results and the computational-effort comparison retain independent content.

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

The central empirical claims rest on the ES retrieval bound, the oracle-defined bug/fix linkage, and the choice of non-stationary task boundaries. No new theoretical entities are introduced. The main free parameters are inherited from the RLOCATOR environment and a small logistic regression reward model.

free parameters (5)
  • k (candidate changesets from Elasticsearch) = 31
    Set to RLOCATOR's value to limit the action space; all ranking is bounded by ES top-k recall.
  • Reward scale constant M = 3
    From the baseline study by Chakraborty et al.; not re-tuned for CL agents.
  • Logistic regression coefficients (intercept, Churn, PRE) = not reported
    Fitted on bug-inducing factor data; the fitted probability is added to the reward in Eq. 5.
  • VIF threshold = 2.5
    Used to remove collinear variables in logistic regression, following Taba et al.
  • p-value threshold = 0.05
    Used to remove statistically insignificant variables in the logistic regression model.
assumptions (3)
  • domain assumption Elasticsearch BM25 top-k retrieval retrieves most relevant changeset-files and hunks.
    All subsequent ranking is restricted to the top 31 candidates; if a relevant file is not retrieved, no method can rank it.
  • domain assumption Commits between the bug report date and the fix date fully characterize non-stationary versions of buggy changesets.
    Non-stationary tasks are constructed from these intermediate commits; incorrect interval or commit mapping would mislabel the task.
  • domain assumption The benchmark oracle mapping bugs to fixed files and hunks is correct.
    Evaluation metrics and ground truth depend entirely on this oracle.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Continuously Learning Bug Locations." pith.science (2026). https://pith.science/paper/ARDMRG5U

@misc{pith2026241211289,
  author       = {Pith},
  title        = {Pith review of: Continuously Learning Bug Locations},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ARDMRG5U}},
  note         = {Machine review of arXiv:2412.11289}
}
read the original abstract

Automatically locating buggy changesets associated with bug reports is crucial in the software development process. Deep Learning (DL)-based techniques show promising results by leveraging structural information from the code and learning links between changesets and bug reports. However, since source code associated with changesets evolves, the performance of such models tends to degrade over time due to concept drift. Aiming to address this challenge, in this paper, we evaluate the potential of using Continual Learning (CL) techniques in multiple sub-tasks setting for bug localization (each of which operates on either stationary or non-stationary data), comparing it against a bug localization technique that leverages the BERT model, a deep reinforcement learning-based technique that leverages the A2C algorithm, and a DL-based function-level interaction model for semantic bug localization. Additionally, we enhanced the CL techniques by using logistic regression to identify and integrate the most significant bug-inducing factors. Our empirical evaluation across seven widely used software projects shows that CL techniques perform better than DL-based techniques by up to 61% in terms of Mean Reciprocal Rank (MRR), 44% in terms of Mean Average Precision (MAP), 83% in terms of top@1, 56% in terms of top@5, and 66% in terms of top@10 metrics in non-stationary setting. Further, we show that the CL techniques we studied are effective at localizing changesets relevant to a bug report while being able to mitigate catastrophic forgetting across the studied tasks and require up to 5x less computational effort during training. Our findings demonstrate the potential of adopting CL for bug localization in non-stationary settings, and we hope it helps to improve bug localization activities in Software Engineering using CL techniques.

Figures

Figures reproduced from arXiv: 2412.11289 by the authors.

Figure 1
Figure 1. Performance of state-of-art baseline studies on Eclipse project. [PITH_FULL_IMAGE:figures/full_fig_p005_1.png] view at source ↗
Figure 2
Figure 2. Illustration of the CL framework [PITH_FULL_IMAGE:figures/full_fig_p008_2.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

85 extracted references · 72 canonical work pages

  1. [1]

    Link for Bug - 384108

    2012. Link for Bug - 384108. https://bugs.eclipse.org/bugs/show_bug.cgi?id=384108

    2012

  2. [2]

    Link for Bug - 420210

    2013. Link for Bug - 420210. https://bugs.eclipse.org/bugs/show_bug.cgi?id=420210

    2013

  3. [3]

    Alliance

    2017. Alliance. https://docs.alliancecan.ca/wiki/Cedar

    2017

  4. [4]

    scc tool

    2018. scc tool. https://github.com/boyter/scc

    2018

  5. [5]

    Eclipse Apache project

    2022. Eclipse Apache project. https://github.com/eclipse-platform/eclipse.platform.ui.git

    2022

  6. [6]

    Replication Package

    2024. Replication Package. https://zenodo.org/records/14271134

    work page arXiv 2024

  7. [7]

    David Abel, André Barreto, Benjamin Van Roy, Doina Precup, Hado P van Hasselt, and Satinder Singh. 2024. A definition of continual reinforcement learning. Advances in Neural Information Processing Systems 36 (2024)

    work page 2024

  8. [8]

    Takuya Akiba, Shotaro Sano, Toshihiko Yanase, Takeru Ohta, and Masanori Koyama. 2019. Optuna: A next-generation hyperparameter optimization framework. In Proceedings of the 25th ACM SIGKDD international conference on knowledge discovery & data mining . 2623–2631

    work page 2019

Show all 85 references
  1. [9]

    Rafi Almhana, Marouane Kessentini, and Wiem Mkaouer. 2021. Method-level bug localization using hybrid multi-objective search. Information and Software Technology 131 (2021), 106474

    2021

  2. [10]

    Giuliano Antoniol and Y-G Guéhéneuc. 2005. Feature identification: a novel approach and a case study. In 21st IEEE International Conference on Software Maintenance (ICSM’05). IEEE, 357–366

    2005

  3. [11]

    Mojtaba Bagherzadeh, Nafiseh Kahani, and Lionel Briand. 2021. Reinforcement learning for test case prioritization. IEEE Transactions on Software Engineering 48, 8 (2021), 2836–2856

    2021

  4. [12]

    Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. 2013. The arcade learning environment: An evaluation platform for general agents. Journal of Artificial Intelligence Research 47 (2013), 253–279

    2013

  5. [13]

    Partha Chakraborty, Mahmoud Alfadel, and Meiyappan Nagappan. 2023. RLocator: Reinforcement Learning for Bug Localization. arXiv preprint arXiv:2305.05586 (2023)

    2023 arXiv

  6. [14]

    Xiaoyu Chen, Xiangming Zhu, Yufeng Zheng, Pushi Zhang, Li Zhao, Wenxue Cheng, Peng Cheng, Yongqiang Xiong, Tao Qin, Jianyu Chen, et al

  7. [15]

    Xue-Wen Chen and Xiaotong Lin. 2014. Big data deep learning: challenges and perspectives. IEEE access 2 (2014), 514–525

    2014

  8. [16]

    Shyam R Chidamber and Chris F Kemerer. 1994. A metrics suite for object oriented design. IEEE Transactions on software engineering 20, 6 (1994), 476–493

    1994

  9. [17]

    Agnieszka Ciborowska and Kostadin Damevski. 2022. Fast changeset-based bug localization with BERT. In Proceedings of the 44th International Conference on Software Engineering . 946–957

    2022

  10. [18]

    Christopher S Corley, Kostadin Damevski, and Nicholas A Kraft. 2018. Changeset-based topic modeling of software repositories. IEEE Transactions on Software Engineering 46, 10 (2018), 1068–1080

    2018

  11. [19]

    Domenico Cotroneo, Roberto Pietrantuono, Stefano Russo, and Kishor Trivedi. 2016. How do bugs surface? A comprehensive study on the characteristics of software bugs manifestation. Journal of Systems and Software 113 (2016), 27–43

    2016

  12. [20]

    Léuson Da Silva, Paulo Borba, Toni Maciel, Wardah Mahmood, Thorsten Berger, João Moisakis, Aldiberg Gomes, and Vinícius Leite. 2024. Detecting semantic conflicts with unit tests. Journal of Systems and Software 214 (2024), 112070

    2024

  13. [21]

    Léuson Da Silva, Paulo Borba, and Arthur Pires. 2022. Build conflicts in the wild. Journal of Software: Evolution and Process 34, 4 (2022), e2441. Manuscript submitted to ACM 34 Mindom et al

    2022

  14. [22]

    Yali Du and Zhongxing Yu. 2023. Pre-training code representation with semantic flow graph for effective bug localization. In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering . 579–591

    2023

  15. [23]

    Jayalath Ekanayake, Jonas Tappolet, Harald C Gall, and Abraham Bernstein. 2009. Tracking concept drift of software projects using defect prediction quality. In 2009 6th IEEE International Working Conference on Mining Software Repositories . IEEE, 51–60

    2009

  16. [24]

    Lasse Espeholt, Hubert Soyer, Remi Munos, Karen Simonyan, Vlad Mnih, Tom Ward, Yotam Doron, Vlad Firoiu, Tim Harley, Iain Dunning, et al

  17. [25]

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

    2020 arXiv

  18. [26]

    Paul A Games and John F Howell. 1976. Pairwise multiple comparison procedures with unequal n’s and/or variances: a Monte Carlo study. Journal of Educational Statistics 1, 2 (1976), 113–125

    1976

  19. [27]

    Arvind Kumar Gangwar and Sandeep Kumar. 2023. Concept Drift in Software Defect Prediction: A Method for Detecting and Handling the Drift. ACM Transactions on Internet Technology 23, 2 (2023), 1–28

    2023

  20. [28]

    O’Reilly Media, Inc

    Clinton Gormley and Zachary Tong. 2015. Elasticsearch: the definitive guide: a distributed real-time search and analytics engine . " O’Reilly Media, Inc. "

    2015

  21. [29]

    Xuan Huo, Ferdian Thung, Ming Li, David Lo, and Shu-Ting Shi. 2019. Deep transfer bug localization. IEEE Transactions on software engineering 47, 7 (2019), 1368–1380

    2019

  22. [30]

    Jeff Johnson, Matthijs Douze, and Hervé Jégou. 2019. Billion-scale similarity search with GPUs. IEEE Transactions on Big Data 7, 3 (2019), 535–547

    2019

  23. [31]

    Dongsun Kim, Yida Tao, Sunghun Kim, and Andreas Zeller. 2013. Where should we fix this bug? a two-phase recommendation model. IEEE transactions on software Engineering 39, 11 (2013), 1597–1610

    2013

  24. [32]

    James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. 2017. Overcoming catastrophic forgetting in neural networks. Proceedings of the national academy of...

    2017

  25. [33]

    Richard Kurle, Botond Cseke, Alexej Klushyn, Patrick Van Der Smagt, and Stephan Günnemann. 2019. Continual learning with bayesian neural networks for non-stationary data. In International Conference on Learning Representations

    2019

  26. [34]

    An Ngoc Lam, Anh Tuan Nguyen, Hoan Anh Nguyen, and Tien N Nguyen. 2017. Bug localization with combination of deep learning and information retrieval. In 2017 IEEE/ACM 25th International Conference on Program Comprehension (ICPC) . IEEE, 218–229

    2017

  27. [35]

    Jaehyung Lee, Kisun Han, and Hwanjo Yu. 2022. A light bug triage framework for applying large pre-trained language model. In Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering . 1–11

    2022

  28. [36]

    Yuxi Li. 2017. Deep reinforcement learning: An overview. arXiv preprint arXiv:1701.07274 (2017)

    2017 arXiv

  29. [37]

    Hongliang Liang, Dengji Hang, and Xiangyu Li. 2022. Modeling function-level interactions for file-level bug localization. Empirical Software Engineering 27, 7 (2022), 186

    2022

  30. [38]

    Jie Lu, Anjin Liu, Fan Dong, Feng Gu, Joao Gama, and Guangquan Zhang. 2018. Learning under concept drift: A review. IEEE transactions on knowledge and data engineering 31, 12 (2018), 2346–2363

    2018

  31. [39]

    Thomas Mccabe. 1996. Cyclomatic complexity and the year 2000. IEEE Software 13, 3 (1996), 115–117

    1996

  32. [40]

    Michael McCloskey and Neal J Cohen. 1989. Catastrophic interference in connectionist networks: The sequential learning problem. In Psychology of learning and motivation. Vol. 24. Elsevier, 109–165

    1989

  33. [41]

    Chris Mills, Jevgenija Pantiuchina, Esteban Parra, Gabriele Bavota, and Sonia Haiduc. 2018. Are bug reports enough for text retrieval-based bug localization?. In 2018 IEEE International Conference on Software Maintenance and Evolution (ICSME) . IEEE, 381–392

    2018

  34. [42]

    Paulina Stevia Nouwou Mindom, Amin Nikanjam, and Foutse Khomh. 2022. A comparison of reinforcement learning frameworks for software testing tasks. arXiv preprint arXiv:2208.12136 (2022)

    2022 arXiv

  35. [43]

    Nima Miryeganeh, Sepehr Hashtroudi, and Hadi Hemmati. 2021. GloBug: Using global data in fault localization. Journal of Systems and Software 177 (2021), 110961

    2021

  36. [44]

    Kevin Moran, Mario Linares-Vásquez, Carlos Bernal-Cárdenas, Christopher Vendome, and Denys Poshyvanyk. 2016. Automatically discovering, reporting and reproducing android application crashes. In 2016 IEEE international conference on software testing, verification and validation...

    2016

  37. [45]

    Raimund Moser, Witold Pedrycz, and Giancarlo Succi. 2008. A comparative analysis of the efficiency of change metrics and static code attributes for defect prediction. In Proceedings of the 30th international conference on Software engineering . 181–190

    2008

  38. [46]

    Aiswarya Munappy, Jan Bosch, Helena Holmström Olsson, Anders Arpteg, and Björn Brinne. 2019. Data management challenges for deep learning. In 2019 45th Euromicro Conference on Software Engineering and Advanced Applications (SEAA) . IEEE, 140–147

    2019

  39. [47]

    Vijayaraghavan Murali, Lee Gross, Rebecca Qian, and Satish Chandra. 2021. Industry-scale ir-based bug localization: A perspective from facebook. In 2021 IEEE/ACM 43rd International Conference on Software Engineering: Software Engineering in Practice (ICSE-SEIP) . IEEE, 188–197

    2021

  40. [48]

    Mathieu Nayrolles and Abdelwahab Hamou-Lhadj. 2018. Clever: Combining code metrics with clone detection for just-in-time fault prevention and resolution in large industrial projects. In Proceedings of the 15th international conference on mining software repositories . 153–164

    2018

  41. [49]

    Anh Tuan Nguyen, Tung Thanh Nguyen, Jafar Al-Kofahi, Hung Viet Nguyen, and Tien N Nguyen. 2011. A topic-based approach for narrowing the search space of buggy files from a bug report. In 2011 26th IEEE/ACM International Conference on Automated Software Engineering (ASE 2011) ....

    2011

  42. [50]

    Doriane Olewicki, Sarra Habchi, Mathieu Nayrolles, Mojtaba Faramarzi, Sarath Chandar, and Bram Adams. 2023. Towards Lifelong Learning for Software Analytics Models: Empirical Study on Brown Build and Risk Prediction. arXiv preprint arXiv:2305.09824 (2023)

    2023 arXiv

  43. [51]

    Doriane Olewicki, Sarra Habchi, Mathieu Nayrolles, Mojtaba Faramarzi, Sarath Chandar, and Bram Adams. 2024. On the Costs and Benefits of Adopting Lifelong Learning for Software Analytics - Empirical Study on Brown Build and Risk Prediction. In Proceedings of the 46th Internati...

    2024

  44. [52]

    Doriane Olewicki, Mathieu Nayrolles, and Bram Adams. 2022. Towards language-independent brown build detection. In Proceedings of the 44th International Conference on Software Engineering . 2177–2188

    2022

  45. [53]

    German I Parisi, Ronald Kemker, Jose L Part, Christopher Kanan, and Stefan Wermter. 2019. Continual lifelong learning with neural networks: A review. Neural networks 113 (2019), 54–71

    2019

  46. [54]

    Fabio Petrillo, Zéphyrin Soh, Foutse Khomh, Marcelo Pimenta, Carla Freitas, and Yann-Gaël Guéhéneuc. 2016. Towards understanding interactive debugging. In 2016 IEEE International Conference on Software Quality, Reliability and Security (QRS) . IEEE, 152–163

    2016

  47. [55]

    Sam Powers, Eliot Xing, Eric Kolve, Roozbeh Mottaghi, and Abhinav Gupta. 2022. Cora: Benchmarks, baselines, and metrics as a platform for continual reinforcement learning agents. In Conference on Lifelong Learning Agents . PMLR, 705–743

    2022

  48. [56]

    Michael Rath, David Lo, and Patrick Mäder. 2018. Analyzing requirements and traceability information to improve bug localization. In Proceedings of the 15th International Conference on Mining Software Repositories . 442–453

    2018

  49. [57]

    Tobias Roehm, Nigar Gurbanova, Bernd Bruegge, Christophe Joubert, and Walid Maalej. 2013. Monitoring user interactions for supporting failure reproduction. In 2013 21st International Conference on Program Comprehension (ICPC) . IEEE, 73–82

    2013

  50. [58]

    David Rolnick, Arun Ahuja, Jonathan Schwarz, Timothy Lillicrap, and Gregory Wayne. 2019. Experience replay for continual learning. Advances in neural information processing systems 32 (2019)

    2019

  51. [59]

    Christoffer Rosen, Ben Grawi, and Emad Shihab. 2015. Commit guru: analytics and risk prediction of software commits. In Proceedings of the 2015 10th joint meeting on foundations of software engineering . 966–969

    2015

  52. [60]

    Derek C Sauder and Christine E DeMars. 2019. An updated recommendation for multiple comparisons. Advances in Methods and Practices in Psychological Science 2, 1 (2019), 26–44

    2019

  53. [61]

    Tony Savor, Mitchell Douglas, Michael Gentili, Laurie Williams, Kent Beck, and Michael Stumm. 2016. Continuous deployment at Facebook and OANDA. In Proceedings of the 38th International Conference on software engineering companion . 21–30

    2016

  54. [62]

    Daniel L Silver, Qiang Yang, and Lianghao Li. 2013. Lifelong machine learning systems: Beyond learning algorithms. In2013 AAAI spring symposium series

    2013

  55. [63]

    Anshuman Singh, Andrew Walenstein, and Arun Lakhotia. 2012. Tracking concept drift in malware families. InProceedings of the 5th ACM workshop on Security and artificial intelligence . 81–92

    2012

  56. [64]

    Richard S Sutton and Andrew G Barto. 1998. Reinforcement learning: an introduction MIT Press. Cambridge, MA 22447 (1998)

    1998

  57. [65]

    Seyyed Ehsan Salamati Taba, Foutse Khomh, Ying Zou, Ahmed E Hassan, and Meiyappan Nagappan. 2013. Predicting bugs using antipatterns. In 2013 IEEE International Conference on Software Maintenance . IEEE, 270–279

    2013

  58. [66]

    Bei Wang, Ling Xu, Meng Yan, Chao Liu, and Ling Liu. 2020. Multi-dimension convolutional neural network for bug localization. IEEE Transactions on Services Computing 15, 3 (2020), 1649–1663

    2020

  59. [67]

    Di Wang, Matthias Galster, and Miguel Morales-Trujillo. 2023. A systematic mapping study of bug reproduction and localization. Information and Software Technology (2023), 107338

    2023

  60. [68]

    Shaohua Wang, Foutse Khomh, and Ying Zou. 2013. Improving bug localization using correlations in crash reports. In 2013 10th Working Conference on Mining Software Repositories (MSR) . IEEE, 247–256

    2013

  61. [69]

    Bernard L Welch. 1947. The generalization of ‘STUDENT’S’problem when several different population varlances are involved. Biometrika 34, 1-2 (1947), 28–35

    1947

  62. [70]

    Ming Wen, Rongxin Wu, and Shing-Chi Cheung. 2016. Locus: Locating bugs from software changes. InProceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering . 262–273

    2016

  63. [71]

    W Eric Wong, Vidroha Debroy, and Byoungju Choi. 2010. A family of code coverage-based heuristics for effective fault localization. Journal of Systems and Software 83, 2 (2010), 188–208

    2010

  64. [72]

    W Eric Wong, Ruizhi Gao, Yihao Li, Rui Abreu, and Franz Wotawa. 2016. A survey on software fault localization. IEEE Transactions on Software Engineering 42, 8 (2016), 707–740

    2016

  65. [73]

    W Eric Wong, Joseph R Horgan, Saul London, and Hiralal Agrawal. 1997. A study of effective regression testing in practice. In PROCEEDINGS The Eighth International Symposium On Software Reliability Engineering . IEEE, 264–274

    1997

  66. [74]

    Rongxin Wu, Ming Wen, Shing-Chi Cheung, and Hongyu Zhang. 2018. Changelocator: locate crash-inducing changes based on crash reports. Empirical Software Engineering 23 (2018), 2866–2900

    2018

  67. [75]

    Yan Xiao, Jacky Keung, Kwabena E Bennin, and Qing Mi. 2019. Improving bug localization with word embedding and enhanced convolutional neural networks. Information and Software Technology 105 (2019), 17–29

    2019

  68. [76]

    Xin Ye, Razvan Bunescu, and Chang Liu. 2014. Learning to rank relevant files for bug reports using domain knowledge. In Proceedings of the 22nd ACM SIGSOFT international symposium on foundations of software engineering . 689–699. Manuscript submitted to ACM 36 Mindom et al

    2014

  69. [77]

    Xin Ye, Razvan Bunescu, and Chang Liu. 2015. Mapping bug reports to relevant files: A ranking model, a fine-grained benchmark, and feature evaluation. IEEE Transactions on Software Engineering 42, 4 (2015), 379–402

    2015

  70. [78]

    Tingting Yu, Tarannum S Zaman, and Chao Wang. 2017. DESCRY: reproducing system-level concurrency failures. In Proceedings of the 2017 11th Joint Meeting on Foundations of Software Engineering . 694–704

    2017

  71. [79]

    Jie Zhang, Xiaoyin Wang, Dan Hao, Bing Xie, Lu Zhang, and Hong Mei. 2015. A survey on bug-report analysis. Sci. China Inf. Sci. 58, 2 (2015), 1–24

    2015

  72. [80]

    Zhuo Zhang, Yan Lei, Xiaoguang Mao, and Panpan Li. 2019. CNN-FL: An effective approach for localizing faults using convolutional neural networks. In 2019 IEEE 26th International Conference on Software Analysis, Evolution and Reengineering (SANER) . IEEE, 445–455

    2019

  73. [81]

    Jian Zhou, Hongyu Zhang, and David Lo. 2012. Where should the bugs be fixed? more accurate information retrieval-based bug localization based on bug reports. In 2012 34th International conference on software engineering (ICSE) . IEEE, 14–24

    2012

  74. [82]

    Thomas Zimmermann, Rahul Premraj, and Andreas Zeller. 2007. Predicting defects for eclipse. In Third International Workshop on Predictor Models in Software Engineering (PROMISE’07: ICSE Workshops 2007) . IEEE, 9–9

    2007

  75. [83]

    Weiqin Zou, David Lo, Zhenyu Chen, Xin Xia, Yang Feng, and Baowen Xu. 2018. How practitioners perceive automated bug report management techniques. IEEE Transactions on Software Engineering 46, 8 (2018), 836–862. Manuscript submitted to ACM

    2018

  76. [2018]

    In International conference on machine learning

    Impala: Scalable distributed deep-rl with importance weighted actor-learner architectures. In International conference on machine learning . PMLR, 1407–1416

  77. [2022]

    Advances in Neural Information Processing Systems 35 (2022), 35449–35461

    An adaptive deep rl method for non-stationary environments with piecewise stable context. Advances in Neural Information Processing Systems 35 (2022), 35449–35461

    2022

Pith tools

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