The Influence Ranking for Testers in Bug Tracking Systems

2019 ◽  
Vol 29 (01) ◽  
pp. 93-113 ◽  
Author(s):  
Hui Li ◽  
Guofeng Gao ◽  
Rong Chen ◽  
Xin Ge ◽  
Shikai Guo ◽  
...  
Keyword(s):  
Tracking System ◽  
Tracking Systems ◽  
Software Projects ◽  
Actual Performance ◽  
Bug Reports ◽  
Existence Time ◽  
Bug Report ◽  
Bug Tracking ◽  
Node Removal ◽  
Bug Fixes

At present, bug tracking systems are used to collect and manage bug reports in many software projects. As participants, the testers not only submit bug reports to the system, but also comment on bug reports in the system. The tester’s behaviors of submitting and commenting reflect his/her influence in bug tracking systems. However, with the rapid increase of the bug reports in software projects, evaluating the testers’ influence in the projects accurately becomes more and more difficult. Aiming at solving this problem, the submission and comment on bug report can be regarded as social behaviors of the testers, and thus the method of Influence Ranking for Testers (IRfT) in bug tracking systems is presented and used for measuring the influence of the testers in this paper. The case study of the Eclipse project in Bugzilla shows that the result produced by IRfT is consistent with the actual performance of the testers in this project. The ranking results can keep stable in the cases of link adding or removing and tester removing in tester networks, and the results are also proved to be valid in the future. The further investigation on the speed of network break-down by node removal demonstrates that the top-ranking testers are important in the organization of tester networks. Additionally, the results also show that the ranking of the testers is related to the existence time in bug tracking system. Therefore, IRfT is proved to be an effective measurement for evaluating the influence of the testers in bug tracking system, and it can further demonstrate the testers’ contributions in software testing, such as bug validations, bug fixes, etc.

From Android Bug Reports to Android Bug Handling Process

2016 ◽  
Vol 7 (4) ◽  
pp. 1-18
Author(s):  
Liguo Yu
Keyword(s):  
Project Management ◽  
Open Source ◽  
Tracking System ◽  
Software Project ◽  
Bug Reports ◽  
Bug Report ◽  
Bug Tracking ◽  
Android Development ◽  
Comprehensive Study

Android is an operating system for mobile devices. Its development is led by Google and some other companies. Because of the open-source property of Android, anyone can report a bug through its online bug tracking system. In this paper, we analyze the bug reports of Android operating systems. Specifically, through this study, we would like to answer the following questions regarding Android development and its project management: (1) Could Android bug reports be handled on time? (2) What is the distribution of different maintenance activities initiated by Android bug reports? (3) How long does it take to handle an Android bug report? (4) Are the number of followers and the number of following messages of an Android bug report related to the effort spent on handling this bug report? Through answering these questions, this paper presents a comprehensive study of Android bug reporting and handling process. The information and knowledge obtained through this case study could help us better understand open-source software project, such as its development process and project management.

Adaptive Ranking Relevant Source Files for Bug Reports Using Genetic Algorithm

2021 ◽  
Author(s):  
Thi Mai Anh Bui ◽  
Nhat Hai Nguyen
Keyword(s):  
Genetic Algorithm ◽  
Software Maintenance ◽  
Large Scale ◽  
Maintenance Phase ◽  
Bug Localization ◽  
Software Projects ◽  
Source File ◽  
Bug Reports ◽  
Localization Model ◽  
Bug Report

Precisely locating buggy files for a given bug report is a cumbersome and time-consuming task, particularly in a large-scale project with thousands of source files and bug reports. An efficient bug localization module is desirable to improve the productivity of the software maintenance phase. Many previous approaches rank source files according to their relevance to a given bug report based on simple lexical matching scores. However, the lexical mismatches between natural language expressions used to describe bug reports and technical terms of software source code might reduce the bug localization system’s accuracy. Incorporating domain knowledge through some features such as the semantic similarity, the fixing frequency of a source file, the code change history and similar bug reports is crucial to efficiently locating buggy files. In this paper, we propose a bug localization model, BugLocGA that leverages both lexical and semantic information as well as explores the relation between a bug report and a source file through some domain features. Given a bug report, we calculate the ranking score with every source files through a weighted sum of all features, where the weights are trained through a genetic algorithm with the aim of maximizing the performance of the bug localization model using two evaluation metrics: mean reciprocal rank (MRR) and mean average precision (MAP). The empirical results conducted on some widely-used open source software projects have showed that our model outperformed some state of the art approaches by effectively recommending relevant files where the bug should be fixed.

An Empirical Comparison of Machine Learning Techniques in Predicting the Bug Severity of Open and Closed Source Projects

2012 ◽  
Vol 4 (2) ◽  
pp. 32-59 ◽  
Author(s):  
K. K. Chaturvedi ◽  
V.B. Singh
Keyword(s):  
Machine Learning ◽  
Tracking System ◽  
Machine Learning Techniques ◽  
Support Vector ◽  
Severity Level ◽  
Bug Reports ◽  
Learning Techniques ◽  
Bug Report ◽  
Closed Source ◽  
F Measure

Bug severity is the degree of impact that a defect has on the development or operation of a component or system, and can be classified into different levels based on their impact on the system. Identification of severity level can be useful for bug triager in allocating the bug to the concerned bug fixer. Various researchers have attempted text mining techniques in predicting the severity of bugs, detection of duplicate bug reports and assignment of bugs to suitable fixer for its fix. In this paper, an attempt has been made to compare the performance of different machine learning techniques namely Support vector machine (SVM), probability based Naïve Bayes (NB), Decision Tree based J48 (A Java implementation of C4.5), rule based Repeated Incremental Pruning to Produce Error Reduction (RIPPER) and Random Forests (RF) learners in predicting the severity level (1 to 5) of a reported bug by analyzing the summary or short description of the bug reports. The bug report data has been taken from NASA’s PITS (Projects and Issue Tracking System) datasets as closed source and components of Eclipse, Mozilla & GNOME datasets as open source projects. The analysis has been carried out in RapidMiner and STATISTICA data mining tools. The authors measured the performance of different machine learning techniques by considering (i) the value of accuracy and F-Measure for all severity level and (ii) number of best cases at different threshold level of accuracy and F-Measure.

scholarly journals Surprise Bug Report Prediction Utilizing Optimized Integration with Imbalanced Learning Strategy

Complexity ◽  
2020 ◽  
Vol 2020 ◽  
pp. 1-14
Author(s):  
Hui Li ◽  
Yang Qu ◽  
Shikai Guo ◽  
Guofeng Gao ◽  
Rong Chen ◽  
...  
Keyword(s):  
Learning Strategy ◽  
Work Force ◽  
Ensemble Method ◽  
Software Systems ◽  
Imbalanced Learning ◽  
Software Projects ◽  
Bug Reports ◽  
Bug Report ◽  
Bug Repositories ◽  
Better Than

In software projects, a large number of bugs are usually reported to bug repositories. Due to the limited budge and work force, the developers often may not have enough time and ability to inspect all the reported bugs, and thus they often focus on inspecting and repairing the highly impacting bugs. Among the high-impact bugs, surprise bugs are reported to be a fatal threat to the software systems, though they only account for a small proportion. Therefore, the identification of surprise bugs becomes an important work in practices. In recent years, some methods have been proposed by the researchers to identify surprise bugs. Unfortunately, the performance of these methods in identifying surprise bugs is still not satisfied for the software projects. The main reason is that surprise bugs only occupy a small percentage of all the bugs, and it is difficult to identify these surprise bugs from the imbalanced distribution. In order to overcome the imbalanced category distribution of the bugs, a method based on machine learning to predict surprise bugs is presented in this paper. This method takes into account the textual features of the bug reports and employs an imbalanced learning strategy to balance the datasets of the bug reports. Then these datasets after balancing are used to train three selected classifiers which are built by three different classification algorithms and predict the datasets with unknown type. In particular, an ensemble method named optimization integration is proposed to generate a unique and best result, according to the results produced by the three classifiers. This ensemble method is able to adjust the ability of the classifier to detect different categories based on the characteristics of different projects and integrate the advantages of three classifiers. The experiments performed on the datasets from 4 software projects show that this method performs better than the previous methods in terms of detecting surprise bugs.

scholarly journals Enhancing the Unified Features to Locate Buggy Files by Exploiting the Sequential Nature of Source Code

2017 ◽  
Author(s):  
Xuan Huo ◽  
Ming Li
Keyword(s):  
Programming Languages ◽  
Software Maintenance ◽  
Structural Information ◽  
Source Code ◽  
Semantic Features ◽  
Software Projects ◽  
Bug Reports ◽  
Bug Report ◽  
Structural Semantics ◽  
Sequential Nature

Bug reports provide an effective way for end-users to disclose potential bugs hidden in a software system, while automatically locating the potential buggy source files according to a bug report remains a great challenge in software maintenance. Many previous approaches represent bug reports and source code from lexical and structural information correlated their relevance by measuring their similarity, and recently a CNN-based model is proposed to learn the unified features for bug localization, which overcomes the difficulty in modeling natural and programming languages with different structural semantics. However, previous studies fail to capture the sequential nature of source code, which carries additional semantics beyond the lexical and structural terms and such information is vital in modeling program functionalities and behaviors. In this paper, we propose a novel model LS-CNN, which enhances the unified features by exploiting the sequential nature of source code. LS-CNN combines CNN and LSTM to extract semantic features for automatically identifying potential buggy source code according to a bug report. Experimental results on widely-used software projects indicate that LS-CNN significantly outperforms the state-of-the-art methods in locating buggy files.

Severity Assessment of a Reported Bug by Considering its Uncertainty and Irregular State

2018 ◽  
Vol 9 (4) ◽  
pp. 20-46 ◽  
Author(s):  
Madhu Kumari ◽  
Meera Sharma ◽  
V. B. Singh
Keyword(s):  
Learning Strategies ◽  
State Of The Art ◽  
Tracking System ◽  
Machine Learning Techniques ◽  
Severity Assessment ◽  
Fast Speed ◽  
Learning Techniques ◽  
Bug Report ◽  
Bug Tracking ◽  
Software Bug

An accurate bug severity assessment is an important factor in bug fixing. Bugs are reported on the bug tracking system by different users with a fast speed. The size of software repositories is also increasing at an enormous rate. This increased size often has much uncertainty and irregularities. The factors that cause uncertainty are biases, noise and abnormality in data. The authors consider that software bug report phenomena on the bug tracking system keeps an irregular state. Without proper handling of these uncertainties and irregularities, the performance of learning strategies can be significantly reduced. To incorporate and consider these two phenomena, they have used entropy as an attribute to assess bug severity. The authors have predicted the bug severity by using machine learning techniques, namely KNN, J48, RF, RNG, NB, CNN and MLR. They have validated the classifiers using PITS, Eclipse and Mozilla projects. The results show that the proposed entropy-based approaches improves the performance as compared to the state of the art approach considered in this article.

Guiding Bug Triage through Developer Analysis in Bug Reports

2016 ◽  
Vol 26 (03) ◽  
pp. 405-431 ◽  
Author(s):  
Tao Zhang ◽  
Geunseok Yang ◽  
Byungjeong Lee ◽  
Alvin T. S. Chan
Keyword(s):  
Empirical Study ◽  
Software Maintenance ◽  
Large Scale ◽  
Software Projects ◽  
Bug Reports ◽  
Bug Fixing ◽  
Bug Report ◽  
Report Analysis ◽  
Mozilla Firefox ◽  
Triage Algorithm

An important part of software maintenance is bug report analysis during bug-fixing, especially for large-scale software projects. Since bugs reported to the bug repository need to be fixed, triagers are responsible to identify appropriate developers to execute the fix. Previous research focused on optimizing this process, such as by duplicate detection and use of developer recommendations for reducing the workload of triagers. However, there were scant studies that analyzed developer roles (e.g. reporter and assignee) in the bug-fixing process. Therefore, in this paper, we perform an in-depth empirical study of the different roles that developers perform in bug resolution. By extracting the factors that affect bug resolution from the analysis results, we propose a novel bug triage algorithm to recommend the appropriate developers to fix a given bug. We implement the proposed recommendations on the Eclipse and Mozilla Firefox projects, with the results showing that the new bug triage algorithm can effectively recommend which experts should fix given bugs.

scholarly journals A Novel Deep-Learning-Based Bug Severity Classification Technique Using Convolutional Neural Networks and Random Forest with Boosting

Sensors ◽  
2019 ◽  
Vol 19 (13) ◽  
pp. 2964 ◽  
Author(s):  
Ashima Kukkar ◽  
Rajni Mohana ◽  
Anand Nayyar ◽  
Jeamin Kim ◽  
Byeong-Gwon Kang ◽  
...  
Keyword(s):  
Neural Network ◽  
Deep Learning ◽  
Random Forest ◽  
Convolutional Neural Network ◽  
High Speed ◽  
Tracking System ◽  
Bug Reports ◽  
Severity Classification ◽  
Bug Report ◽  
N Gram

The accurate severity classification of a bug report is an important aspect of bug fixing. The bug reports are submitted into the bug tracking system with high speed, and owing to this, bug repository size has been increasing at an enormous rate. This increased bug repository size introduces biases in the bug triage process. Therefore, it is necessary to classify the severity of a bug report to balance the bug triaging process. Previously, many machine learning models were proposed for automation of bug severity classification. The accuracy of these models is not up to the mark because they do not extract the important feature patterns for learning the classifier. This paper proposes a novel deep learning model for multiclass severity classification called Bug Severity classification to address these challenges by using a Convolutional Neural Network and Random forest with Boosting (BCR). This model directly learns the latent and highly representative features. Initially, the natural language techniques preprocess the bug report text, and then n-gram is used to extract the features. Further, the Convolutional Neural Network extracts the important feature patterns of respective severity classes. Lastly, the random forest with boosting classifies the multiple bug severity classes. The average accuracy of the proposed model is 96.34% on multiclass severity of five open source projects. The average F-measures of the proposed BCR and the existing approach were 96.43% and 84.24%, respectively, on binary class severity classification. The results prove that the proposed BCR approach enhances the performance of bug severity classification over the state-of-the-art techniques.

scholarly journals Assessment of Software Bug Complexity and Severity using Evolutionary SOM Scheme

2019 ◽  
Vol 8 (6) ◽  
pp. 3152-3158
Keyword(s):  
Software Quality ◽  
Software Maintenance ◽  
Negative Impact ◽  
Distance Functions ◽  
Tracking Systems ◽  
Software Defects ◽  
Bug Reports ◽  
Bug Report ◽  
Severity Prediction ◽  
Software Bug

The software defect prediction and assessment plays a significant role in the software development process. Predicting software defects in the earlier stages will increases the software quality, reliability and efficiency, the cost of detecting and eliminating software defects have been the most expensive task during both development and maintenance process, as software demands increase and delivery of the software span decreased, ensuring software quality becomes a challenge. However, due to inadequate testing, no software can pretend to be free from errors. Bug repositories are used for storing and managing bugs in software projects. A bug in the repositories is recorded as a bug report. When a bug is found by a tester its available information is entered in defect tracking systems. During its resolution process a bug enters into various bug states. These defect tracking systems enable user to give the information about the bugs while running the software. However, the severity prediction has recently gained a lot of attention in software maintenance. Bugs with greater severity should be resolved before bugs with lower severity. In this paper an evolutionary interactive scheme to evaluate bug reports and assess the severity is proposed. This paper presents a Software Bug Complexity Cluster (SBCC) using Self Organizing Maps. In this SBCC a feature matrix is built using bug durations and the complexities of software bugs are categorized into distinct clusters including Blocker, Critical, Major, Trivial and Minor by specifying negative impact of the defect using two different techniques, namely k-means and SOM. Bug duration, proximity error and pre-defined distance functions are used to estimate the accuracy of different bug complexities. Our systematic study found that SOM's proximity error and fitness have greater performance and efficiency than K-Means. The collected results showed better performance for the SBCC with respect to fitness and cluster proximity error.

Sign in / Sign up

Export Citation Format

Share Document