Xin Xia, David Lo, Xingen Wang et al. · 2014
Bug localization refers to the process of identifying source code files that contain defects from textual descriptions in bug reports. Existing bug localization techniques work on the assumption that bug reports, and identifiers and comments in source code files, are written in the same language (i.e., English). However, software users from non-English speaking countries (e.g., China) often use their native languages (e.g., Chinese) to write bug reports. For this setting, existing studies on bug localization would not work as the terms that appear in the bug reports do not appear in the source code. We refer to this problem as cross-language bug localization. In this paper, we propose a cross-language bug localization algorithm named CrosLocator, which is based on language translation.
Cited by 35
Xuan Huo, Ferdian Thung, Ming Li et al. · IEEE Transactions on Software Engineering · 2019
Many projects often receive more bug reports than what they can handle. To help debug and close bug reports, a number of bug localization techniques have been proposed. These techniques analyze a bug report and return a ranked list of potentially buggy source code files. Recent development on bug localization has resulted in the construction of effective supervised approaches that use historical data of manually localized bugs to boost performance. Unfortunately, as highlighted by Zimmermann et al., sufficient bug data is often unavailable for many projects and companies. This raises the need for cross-project bug localization - the use of data from a project to help locate bugs in another project. To fill this need, we propose a deep transfer learning approach for cross-project bug localization. Our proposed approach named TRANP-CNN extracts transferable semantic features from source project and fully exploits labeled data from target project for effective cross-project bug localization. We have evaluated TRANP-CNN on curated high-quality bug datasets and our experimental results show that TRANP-CNN can locate buggy files correctly at top 1, top 5, and top 10 positions for 29.9, 51.7, 61.3 percent of the bugs respectively, which significantly outperform state-of-the-art bug localization solution based on deep learning and several other advanced alternative solutions considering various standard evaluation metrics.
Cited by 83
Пословская Элеонора Дмитриевна, Poslovskaa Eleonora Dmitrievna · Research Repository Saint Petersburg State University (Saint Petersburg State University) · 2021
Задача автоматизации поиска ошибок в исходном коде программ с ростом технологического прогресса и объема написанного программистами кода становится все более актуальной. В данной работе предпринят подход, позволяющий по исходному коду методов и стека вызовов после падения программы определить метод, содержащий в себе некорректный код. Рассмотрены существующие подходы в этой области, выбраны наиболее полезные и новые подходы к решению близких задач.\nПредоставленные для работы реальные данные были предоставлены компанией JetBrains и содержат в себе стеки вызовов и репозиторий с кодом IDE IntelliJ IDEA. Они были приведены при помощи предобученной модели code2seq к векторному представлению. Разработана и обучена модель на основе BiLSTM c обучаемыми эмбеддингами вместо пропущенных значений. На основе дополнительных признаков предсказания LSTM были отранжированы, что дало прирост качества к итоговому результату. Модель была оценена и получила хорошие результаты по сравнению с методами конкурентами.
Cited by 0Open access
Waqas Ali, Saima Siraj, Shamshad Lakho et al. · VFAST Transactions on Software Engineering · 2024
Software development always looks for automated methods to improve productivity and accuracy in issue detection. The paper conducts a comparative examination of several machine-learning techniques to tackle the bug localization difficulty. Our study compared the performance of Logistic Regression (LR), Random Forest Classifier (RFC), Support Vector Machine (SVM), Gradient Boosting Classifier (GBC), and Adaptive Bug Localization System (ABLS) on five dataset versions. The results demonstrate the superior performance of ensemble learning methods. The ABLS model regularly beats other models regarding F1 score, accuracy, and recall, indicating its strong potential for precise problem localization. The study highlights the necessity of continuously adapting models to tackle idea drift in dynamic datasets. Our research suggests a path for future endeavours involving improving feature engineering and integrating real-time online learning to sustain high performance in bug localization activities.
Cited by 0Open access
Devendra Kumar, Ritu Sharma · International Journal of Engineering Research and · 2015
Cited by 0Open access
Valentin Dallmeier, Christian Lindig, Andreas Zeller · 2005
AMPLE locates likely failure-causing classes by comparing method call sequences of passing and failing runs. A difference in method call sequences, such as multiple deallocation of the same resource, is likely to point to the erroneous class. Such sequences can be collected from arbitrary Java programs at low cost; comparing object-specific sequences predicts defects better than simply comparing coverage. AMPLE comes as a plug-in for the Java IDE Eclipse that is automatically invoked as soon as a JUnit test fails.
Cited by 94
Przymus, Piotr, Fejzer, Mikołaj, Narębski, Jakub et al. · Figshare · 2025
# Replication Package for L2R Models Evaluation<br>This repository contains all necessary resources to replicate the experiments described in our evaluation of Learning-to-Rank (L2R) models applied to grayscale-based code change analysis.<br>## OverviewWe evaluate three L2R models for ranking modified lines of code based on their relevance:**Model 1**: Baseline L2R model.**Model 2**: Uses expert-annotated data.**Model 3**: Fully automated grayscale-based annotation model.<br>Model 3 automatically assigns labels to modified code lines based on grayscale heuristics, and its ranking results are generated similarly to Model 2.<br>### Results Summary<br>| Model | MAP | MRR | ACC@1 || Model 1 | 0.408 | 0.659 | 0.521 || Model 2 | 0.429 | 0.705 | 0.608 || Model 3 | 0.427 | 0.704 | 0.608 |<br>These results suggest that the automatic grayscale-based Model 3 achieves comparable performance to expert-labeled Model 2, at a much lower cost.<br><br>## How to Replicate<br>All files required to replicate the experiments (datasets, configuration, and scripts) are available at:<br>👉 https://doi.org/10.6084/m9.figshare.24448888
Cited by 0Open access
Przymus, Piotr, Fejzer, Mikołaj, Narębski, Jakub et al. · Figshare · 2025
# Replication Package for L2R Models Evaluation<br>This repository contains all necessary resources to replicate the experiments described in our evaluation of Learning-to-Rank (L2R) models applied to grayscale-based code change analysis.<br>## OverviewWe evaluate three L2R models for ranking modified lines of code based on their relevance:**Model 1**: Baseline L2R model.**Model 2**: Uses expert-annotated data.**Model 3**: Fully automated grayscale-based annotation model.<br>Model 3 automatically assigns labels to modified code lines based on grayscale heuristics, and its ranking results are generated similarly to Model 2.<br>### Results Summary<br>| Model | MAP | MRR | ACC@1 || Model 1 | 0.408 | 0.659 | 0.521 || Model 2 | 0.429 | 0.705 | 0.608 || Model 3 | 0.427 | 0.704 | 0.608 |<br>These results suggest that the automatic grayscale-based Model 3 achieves comparable performance to expert-labeled Model 2, at a much lower cost.<br><br>## How to Replicate<br>All files required to replicate the experiments (datasets, configuration, and scripts) are available at:<br>👉 https://doi.org/10.6084/m9.figshare.24448888
Cited by 0Open access
Yaqiang Zhao, Xiaozhuo Li, Qing Tian et al. · 2023
The study of bug report-oriented program error location has the characteristics of strong pertinence and low cost, which is an important direction in the current research on program error location. This type of research takes bug reports and source code as input sources, and establishes a mapping relationship between the two through semantic mapping strategies to locate program errors. In the fine-grained program error location scenario, there is a problem that the location accuracy is greatly reduced. Existing empirical studies analyze the difference in location accuracy from two aspects: input source data noise and semantic mapping strategy selection, but most studies take the established location tools and methods as the evaluation object, the evaluation data type is single, and there is a lack of fine-grained analysis of constructing key variables. In order to evaluate the influence of key variables of location method on location accuracy, this paper decouples the location method through pseudo-siamese network, measures the sensitivity of location accuracy by counting the gain of location accuracy under different input source data types, and adds input source data types and a variety of semantic mapping strategies, Based on the evaluation of 23808 bug reports and corresponding source code data in 7 open source projects published on JIRA, this paper provides a more detailed empirical basis for additional data type selection and weight allocation, combined learning of multiple data types and different semantic mapping strategies in fine-grained program error location.
Cited by 0
NI Zhen, LI Bin, SUN Xiao-bing, LI Bi-xin, ZHU Cheng · SHILAP Revista de lepidopterología · 2022
Software bug localization is an important task in bug fixing process.The bug report-oriented localization approaches typically use software bug reports that describe the phenomenon of bugs as queries,and source code as corpus.First,correlations between the bug report and each source code unit are analyzed.Then,a bug localization data set is created by mining the software repository,aiming to construct a bug localization model to localize the source code unit(i.e.bug location) corresponding to the bug report.This paper offers a systematic survey of existing research achievements of the domestic and foreign studies of bug localization in recent years.First,the related concepts in bug report-oriented bug localization are introduced,and the main localization process is summarized,followed by discussing the existing research works that focus on the three key steps in the localization process.Then,the commonly used data sets and evaluation metrics for bug localization are summarized.Finally,future work in this research area is discussed.
Cited by 0Open access
Renjie Xiao, Xi Xiao, Le Yu et al. · Lecture notes in computer science · 2023
Cited by 0
Klaus Changsun Youm, June Ahn, Jeongho Kim et al. · 2015
A bug report is mainly used to find a fault location in software maintenance. It contains several fields such as summary, description, status and version. The description field includes detail scenario and stack traces if exceptional messages are presented. Recently researchers have proposed several approaches for automatic bug localization by using information retrieval and data mining. We propose BLIA, a statically integrated analysis approach of IR-based bug localization by utilizing texts and stack traces in bug reports, structured information of source files, and source code change histories. We performed experiments on three open source projects, namely AspectJ, SWT and ZXing. Compared with prior tools, our experiment results showed that BLIA outperforms the existing tools in terms of mean average precision. Our approach on average improved the metric of BugLocator, BLUiR, BRTracer and AmaLgam by 34%, 23%, 17% and 8%, respectively.
Cited by 60
Frank Eichinger, Klemens Böhm · The Kluwer international series on advances in database systems · 2010
Cited by 12
Yaojing Wang, Yuan Yao, Hanghang Tong et al. · 2018
Bug tracking systems, which help to track the reported software bugs, have been widely used in software development and maintenance. In these systems, recognizing relevant source files among a large number of source files for a given bug report is a time-consuming and labor-intensive task for software developers. To tackle this problem, information retrieval methods have been widely used to capture either the textual similarities or the semantic similarities between bug reports and source files. However, these two types of similarities are usually considered separately and the historical bug fixings are largely ignored by the existing methods. In this paper, we propose a supervised topic modeling method (STMLOCATOR) for automatically locating the relevant source files for a given bug report. In particular, the proposed model is built upon three key observations. First, supervised modeling can effectively make use of the existing fixing histories. Second, certain words in bug reports tend to appear multiple times in their relevant source files. Third, longer source files tend to have more bugs. By integrating the above three observations, the proposed STMLOCATOR utilizes historical fixings in a supervised way and learns both the textual similarities and semantic similarities between bug reports and source files. We further consider a special type of bug reports with stack-traces in bug reports, and propose a variant of STMLOCATOR to tailor for such bug reports. Experimental evaluations on three real data sets demonstrate that the proposed STMLOCATOR can achieve up to 23.6% improvement in terms of prediction accuracy over its best competitors, and scales linearly with the size of the data. Moreover, the proposed variant further improves STMLOCATOR by up to 76.2% on those bug reports with stack-traces.
Cited by 19
Chao Liu, Xifeng Yan, Long Fei et al. · 2005
Automated localization of software bugs is one of the es-sential issues in debugging aids. Previous studies indicated that the evaluation history of program predicates may dis-close important clues about underlying bugs. In this paper, we propose a new statistical model-based approach, called SOBER, which localizes software bugs without any prior knowledge of program semantics. Unlike existing statisti-cal debugging approaches that select predicates correlated with program failures, SOBER models evaluation patterns of predicates in both correct and incorrect runs respectively and regards a predicate as bug-relevant if its evaluation pat-tern in incorrect runs differs significantly from that in correct ones. SOBER features a principled quantification of the pat-tern difference that measures the bug-relevance of program predicates. We systematically evaluated our approach under the same setting as previous studies. The result demonstrated the power of our approach in bug localization: SOBER can help programmers locate 68 out of 130 bugs in the Siemens suite when programmers are expected to examine no more than 10 % of the code, whereas the best previously reported is 52 out of 130. Moreover, with the assistance of SOBER, we found two bugs in bc 1.06 (an arbitrary precision calcula-tor on UNIX/Linux), one of which has never been reported before.
Cited by 0
Anonymous · Zenodo (CERN European Organization for Nuclear Research) · 2024
This package contains the material used in the manuscript. For more information on understanding the package structure, please read README.md.
Cited by 0Open access
BO Li-li CHANG Jian-ming · SHILAP Revista de lepidopterología · 2021
With the evolution and the increased complexity of software project,bug fixing is getting more difficult.During the bug fixing,developers need to spend a lot of time on bug localization and fixing.To evaluate this problem,this paper builds a bug-code database by integrating the bug reports and the corresponding evolution information,and analyzing the relationship between the code block and the bug report.Then,a code search engine is constructed for bug localization based on the bug-code database,which is used for recommending more comprehensive information about similar bug reports,bug related code files,and code blocks.The experiment results show that the proposed approach is more accurate to localize buggy files,and the localization can effectively reach code level.
Cited by 0Open access
HeuiChan Lim, Saumya Debray · 2021
Many widely-deployed modern programming systems use just-in-time (JIT) compilers to improve performance. The size and complexity of JIT-based systems, combined with the dynamic nature of JIT-compiler optimizations, make it challenging to locate and fix JIT compiler bugs quickly. At the same time, JIT compiler bugs can result in exploitable security vulnerabilities, making rapid bug localization important. Existing work on automated bug localization focuses on static code, i.e., code that is not generated at runtime, and so cannot handle bugs in JIT compilers that generate incorrect code during optimization. This paper describes an approach to automated bug localization in JIT compilers, down to the level of distinct optimization phases, starting with a single initial Proof-of-Concept (PoC) input that demonstrates the bug. Experiments using a prototype implementation of our ideas on Google’s V8 JavaScript interpreter and TurboFan JIT compiler demonstrates that it can successfully identify buggy optimization phases.
Cited by 11Open access
Partha Chakraborty, Mahmoud Alfadel, Meiyappan Nagappan · IEEE Transactions on Software Engineering · 2024
Software developers spend a significant portion of time fixing bugs in their projects. To streamline this process, bug localization approaches have been proposed to identify the source code files that are likely responsible for a particular bug. Prior work proposed several similarity-based machine-learning techniques for bug localization. Despite significant advances in these techniques, they do not directly optimize the evaluation measures. We argue that directly optimizing evaluation measures can positively contribute to the performance of bug localization approaches. Therefore, in this paper, we utilize Reinforcement Learning (RL) techniques to directly optimize the ranking metrics. We propose <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">RLocator</small>, a Reinforcement Learning-based bug localization approach. We formulate RLocator using a Markov Decision Process (MDP) to optimize the evaluation measures directly. We present the technique and experimentally evaluate it based on a benchmark dataset of 8,316 bug reports from six highly popular Apache projects. The results of our evaluation reveal that RLocator achieves a Mean Reciprocal Rank (MRR) of 0.62, a Mean Average Precision (MAP) of 0.59, and a Top 1 score of 0.46. We compare RLocator with three state-of-the-art bug localization tools, FLIM, BugLocator, and BL-GAN. Our evaluation reveals that RLocator outperforms both approaches by a substantial margin, with improvements of 38.3% in MAP, 36.73% in MRR, and 23.68% in the Top K metric. These findings highlight that directly optimizing evaluation measures considerably contributes to performance improvement of the bug localization problem.
Cited by 12
Yiwei Zhang · 2009
Cited by 0Open access