Bug Fixing Time Research Articles

Two-Level Information-Retrieval-Based Model for Bug Localization Based on Bug Reports

Software bugs are a noteworthy concern for developers and maintainers. When a failure is detected late, it costs more to be fixed. To repair the bug that caused the software failure, the location of the bug must first be known. The process of finding the defective source code elements that led to the failure of the software is called bug localization. Effective approaches for automatically locating bugs using bug reports are highly desirable, as they would reduce bug-fixing time, consequently lowering software maintenance costs. With the increasing size and complexity of software projects, manual bug localization methods have become complex, challenging, and time-consuming tasks, which motivates research on automated bug localization techniques. This paper introduces a novel bug localization model, which works on two levels. The first level localizes the buggy classes using an information retrieval approach and it has two additional sub-phases, namely the class-level feature scoring phase and the class-level final score and ranking phase, which ranks the top buggy classes. The second level localizes the buggy methods inside these classes using an information retrieval approach and it has two sub-phases, which are the method-level feature scoring phase and the method-level final score and ranking phase, which ranks the top buggy methods inside the localized classes. A model is evaluated using an AspectJ dataset, and it can correctly localize and rank more than 350 classes and more than 136 methods. The evaluation results show that the proposed model outperforms several state-of-the-art approaches in terms of the mean reciprocal rank (MRR) metrics and the mean average precision (MAP) in class-level bug localization.

Deep learning and gradient-based extraction of bug report features related to bug fixing time

Bug reports typically contain detailed descriptions of failures, hints at the location of the corresponding defects, and discussions. Developers usually resolve bugs using comments in descriptions and discussions. The time to fix a bug varies greatly. Previous studies have investigated bug reports, but the influence of comments on bug fixing time is not well understood. This study adopts a convolutional neural network (CNN) and gradient-based visualization approach called Grad-cam to elucidate the impact of comments on bug fixing time and extract features. A feature represents an observed characteristic in a bug report when processing via deep learning. Specifically, CNN classifies bug reports, and then Grad-cam visualizes the decision basis of CNN by identifying the top 10 word sequences used in the prediction. Here, the features are major word sequences extracted by Grad-cam. In an experiment, the proposed method classified more than 36,000 actual bug reports from Bugzilla with an accuracy of 75%–80%. Additionally, the visualization highlighted differences in the stack trace and word abstraction by bug fixing time. Bug reports with short bug fixing times are concrete, whereas those with a long bug fixing time are abstract.

ProRE: An ACO- based programmer recommendation model to precisely manage software bugs

The process of assigning bugs to particular programmers is called bug assignment in software engineering. The programmer can fix the bugs by applying their knowledge. This research article presents an Ant colony optimization-based programmer recommendation model (ProRE) to manage software bugs precisely. The proposed ProRE model performs four operations: data pre-processing, i.e., data Pre-processing, extraction, feature selection, and programmer recommendation process. The feature selection stage utilized the Ant colony optimization (ACO) method to determine the appropriate subsets of features from all features. In the programmer recommendation stages, three programmer metrics, i.e., functionality ranking, bug occurrence, and mean Bug fixing time, are utilized for the recommendation assignment. The effectiveness of the proposed programmer recommendation system is assessed using datasets from Mozilla, Eclipse, Firefox, JBoss, and OpenFOAM. It is noted that the proposed model offers a better recommendation strategy over the other available systems. The simulation findings of the proposed ProRE model are also analyzed with well-known available ML methods, i.e., SVM, NB, and C4.5. It is observed that the recommendation results have improved by an average of 4%, 10%, and 12% compared to SVM, C4.5, and NB-based models. Programmer recommendation software is implemented for allocating the bugs to accurate programmers. It has been found that the proposed ProRE model generates more optimistic outcomes than existing ones.

S-DABT: Schedule and Dependency-aware Bug Triage in open-source bug tracking systems

Fixing bugs in a timely manner lowers various potential costs in software maintenance. However, manual bug fixing scheduling can be time-consuming, cumbersome, and error-prone. In this paper, we propose the Schedule and Dependency-aware Bug Triage (S-DABT), a bug triaging method that utilizes integer programming and machine learning techniques to assign bugs to suitable developers. Unlike prior works that largely focus on a single component of the bug reports, our approach takes into account the textual data, bug fixing costs, and bug dependencies. We further incorporate the schedule of developers in our formulation to have a more comprehensive model for this multifaceted problem. As a result, this complete formulation considers developers' schedules and the blocking effects of the bugs while covering the most significant aspects of the previously proposed methods. Our numerical study on four open-source software systems, namely, EclipseJDT, LibreOffice, GCC, and Mozilla, shows that taking into account the schedules of the developers decreases the average bug fixing times. We find that S-DABT leads to a high level of developer utilization through a fair distribution of the tasks among the developers and efficient use of the free spots in their schedules. Via the simulation of the issue tracking system, we also show how incorporating the schedule in the model formulation reduces the bug fixing time, improves the assignment accuracy, and utilizes the capability of each developer without much comprising in the model run times. We find that S-DABT decreases the complexity of the bug dependency graph by prioritizing blocking bugs and effectively reduces the infeasible assignment ratio due to bug dependencies. Consequently, we recommend considering developers' schedules while automating bug triage.

Optimum bug fixing rate and bug fixing time detection by software reliability modelling

PurposeSoftware reliability growth models (SRGMs) are used to assess and predict reliability of a software system. Many of these models are effective in predicting future failures unless the software evolves.Design/methodology/approachThis objective of this paper is to identify the best path for rectifying the BFT (bug fixing time) and BFR (bug fixing rate). Moreover, the flexible software project has been examined while materializing the BFR. To enhance the BFR, the traceability of bug is lessened by the version tag virtue in every software deliverable component. The release time of software build is optimized with the utilization of mathematical optimization mechanisms like ‘software reliability growth’ and ‘non-homogeneous Poisson process methods.’FindingsIn current market scenario, this is most essential. The automation and variation of build is also resolved in this contribution. Here, the software, which is developed, is free from the bugs or defects and enhances the quality of software by increasing the BFR.Originality/valueIn current market scenario, this is most essential. The automation and variation of build is also resolved in this contribution. Here, the software, which is developed, is free from the bugs or defects and enhances the quality of software by increasing the BFR.

A STUDY ON SOFTWARE DEFECT PREDICTION SYSTEM USING DATA MINING TECHNIQUES

Defects in software modules are a source of significant concern. Software reliability and software quality assurance ensure the high quality of applications. A software defect triggers software malfunction in an executable product. A number of methods for forecasting machine faults have been suggested, but none have proven to be sufficiently accurate. In the design of software error prediction models, the aim is to use metrics that can be obtained comparatively early in the life cycle of software production to provide fair initial quality estimates of an evolving software framework.Here are various data mining classification and forecasting techniques. Artificial Neural Network (ANN), K-Nearest Neighbor (KNN) have been analyzed and compared for software defect prediction model development. For this paper, the DATATRIEVETM project developed by Digital Engineering, Italy was used to validate the algorithm. The findings revealed that the model was an exceptional statistical model using the NN classification methodology. The main challenges faced in the secure software development process are quality and reliability. There are major software cost violations when a software product with errors in its various components is used on the customer’s side. The software warehouse is commonly used as a record keeping repository, which is often needed when adding new features or fixing bugs. Software errors can lead to erroneous and different results. As a result, software programs run late, are canceled, or become unreliable after use. Different social and technical issues are associated with software failure and software defects are the main reasons for deteriorating product quality. In software engineering, the most active research in software domain is defect prediction.This study discusses the bug-fix time forecast model, pre-release release, post-release error and different measurements to predict failures. Predicted results help developers identify and fix potential vulnerabilities, thereby improving software stability and reliability.

Multi-label software bug categorisation based on fuzzy similarity

The efficiency of the software depends on timely detection of bugs. For better quality and low-cost development bug fixing time should be minimised. Categorisation of software bugs helps to understand the root cause of software bugs and to improve triaging. As the software development approach is modular and multi-skilled, it is possible that one software bug can affect multiple modules, and multiple developers can fix newly reported bugs. Hence, a multi-label categorisation of software bugs is needed. Fuzzy similarity techniques can be helpful in understanding the belongingness of software bugs in multiple categories. In this paper a multi-label fuzzy similarity based categorisation technique is presented for effective categorisation of software bugs. Fuzzy similarity between a pair of bugs is computed and, based on a user defined threshold value, the bugs are categorised. Experiments are performed on software bug data sets, and the performance of the proposed classifier is evaluated.

What are the Features of Good Discussions for Shortening Bug Fixing Time?

What are the Features of Good Discussions for Shortening Bug Fixing Time?

Multi-label software bug categorisation based on fuzzy similarity

The efficiency of the software depends on timely detection of bugs. For better quality and low-cost development bug fixing time should be minimised. Categorisation of software bugs helps to understand the root cause of software bugs and to improve triaging. As the software development approach is modular and multi-skilled, it is possible that one software bug can affect multiple modules, and multiple developers can fix newly reported bugs. Hence, a multi-label categorisation of software bugs is needed. Fuzzy similarity techniques can be helpful in understanding the belongingness of software bugs in multiple categories. In this paper a multi-label fuzzy similarity based categorisation technique is presented for effective categorisation of software bugs. Fuzzy similarity between a pair of bugs is computed and, based on a user defined threshold value, the bugs are categorised. Experiments are performed on software bug data sets, and the performance of the proposed classifier is evaluated.

Mining social collaboration patterns in developer social networks

Software development is extremely complex, requiring collaboration between teams and developers who collaborate on various tasks; these activities lead to the generation of an implicit developer social network (DSN). The authors’ aim to understand the development process in terms of collaboration between developers. In this work, they conducted an empirical study on mining social collaboration patterns of DSNs for open source software projects based on an integrated approach involving the identification of global and local collaboration patterns among developers based on social network analysis. The bug tracking system-based DSN (BTS-DSN) is chosen as an example over the other DSNs since it incorporates larger collaboration activities and actors. The empirical results show that the DSNs, specifically BTS-DSN, exhibits three different coordination pattern levels (Plan, Aware, and Reflexive) based on their collaboration activities. The mean time to repair metric proves that the Reflexive level occupies the fastest bug fixing time, then the Plan level comes secondly, and lastly the Aware level. In addition, each level group shows different collaboration behaviours among developers; thus, this information can be useful as a resource for better understanding of developer collaboration and collaboration awareness.

Predicting the bug fixing time using word embedding and deep long short term memories

In bug fixing process, estimating the ‘Time to Fix Bug’ is one of the factors that helps the triager to allocate jobs in a better way. Due to the limitation of resources for bug fixing, the bugs with long fixing time must be identified, as soon as possible, after receiving the report. This helps the prioritisation and fixing process of the bug reports. In the process of bug fixing, a temporal sequence of activities is done. Each activity is represented by a term. Useful semantic information and long-term dependency are available between terms in the sequence, but it is usually underutilised by existing bug fixing time predictor approaches. This work presents a novel deep learning-based model (called DeepLSTMPred) that (i) converts constituent terms to a vector of real numbers by considering their semantic meaning, (ii) finds the long-term dependencies between terms by deep long short term memory (LSTM) and (iii) classifies sequences to short fixing time or long fixing time. DeepLSTMPred is evaluated on bug reports extracted from the Mozilla project. The results show that the proposed method has better performance in comparison with a state-of-the-art approach (that is the hidden Markov-based model). The experimental results show that DeepLSTMPred achieves 15–20% improvement in terms of accuracy, precision, f-score, and recall.

Continual Prediction of Bug-Fix Time Using Deep Learning-Based Activity Stream Embedding

Predicting the fix time of a bug is important for managing the resources and release milestones of a software development project. However, it is considered non-trivial to achieve high accuracy when predicting bug-fix times. We view that such difficulties come from the lack of continuous or posterior estimation based on subsequent developers’ activities after a bug is initially reported. In this paper, we formulate the problem of bug-fix time prediction into a continual update of estimates with more activities. Logging data of bug-related activities that are streamed to a bug tracking system change the bug reports, enabling us to recalculate predictions over time. To do so, we propose a deep learning-based two-staged activity stream embedding model, DASENet that employs (i) a merged network for extracting contextual features across different types of logs, and (ii) a sequence network for exploring temporal relations of the logs. Through experiments with bug tracking system datasets from open source projects including Firefox, Chromium, and Eclipse, we show that DASENet achieves stable performance, e.g., for the Firefox dataset, top-1 accuracy of 4.6 to 8.5 % higher than other state-of-the-art works. Our approach also provides a transferable structure, yielding robust performance with a small dataset for different tasks; the DASENet model trained with a small dataset of about 900 samples (2 % of a full dataset) can show competitive performance to the other models with a full dataset. To the best of our knowledge, we are the first to employ deep learning on log streams in the context of bug-fix time prediction.

To Minimize Fault Report and Bug Fixing Time using an Efficient Integration of Instance and Aspect Preferment Algorithm

Background: Data mining is an emerged and promising technology, and it utilized in the software engineering development process. It does not only enhance the accurateness, it also improves the reliability of the software. A software development application error is a fault or bug in a computer program. It produces wrong or unexpected outcomes. In traditional software development, faults manually triaged through a specialist developer, i.e., a human being triaged. Methods: Manual fault triage takes long time and produce low accuracy for the huge amount of faults. To resolve above issues, An Efficient Integration of Instance and Aspect Preferment Algorithm (EIIAPA) is proposed to decrease the scale of fault report data concurrently and to enhance the accurateness of data. Results & Conclusion: The proposed technique helps to validate & verify software application in effective way. Reduction of data on fault triage aims to construct a high-superiority set of fault data in the small-scale system through eliminating the fault report. To applying an algorithm, fault data set and attributes are extracted from every fault data set and train a predictive model based on the historical dataset. Based on Experimental evaluations, proposed methodology reduces 0.06 ET (Execution Time), and improves 0.5 P (Precision), 0.75 R (Recall), 0.39 F-M (F-Measure) and 5.07% (accuracy) compared than existing methodologies.

Improving bug report quality by predicting correct component in bug reports

Bugs reported in bug tracking systems contain important information in the form of standard and mandatory fields like version, operating system, product, component and type of the bug, etc. Unfortunately, the information provided in these fields is sometimes missing and inaccurate. Inaccurate information makes the program understanding difficult and inflicts delay in the process of bug fixing. Many times, these fields are reassigned during the bug fixing time even more than ones. This study explores the automatic identification of correct component field in a bug report. This study proposes using fuzzy similarity-based approach for identifying the correct component as well as predicting the possibility of component reassignment. Experimentation is done using bug reports of three open source projects from eclipse. The experimental results show that fuzzy similarity approach performs better as compared to state of art approaches on two out of three datasets in terms of precision score.

Improving bug report quality by predicting correct component in bug reports

Bugs reported in bug tracking systems contain important information in the form of standard and mandatory fields like version, operating system, product, component and type of the bug, etc. Unfortunately, the information provided in these fields is sometimes missing and inaccurate. Inaccurate information makes the program understanding difficult and inflicts delay in the process of bug fixing. Many times, these fields are reassigned during the bug fixing time even more than ones. This study explores the automatic identification of correct component field in a bug report. This study proposes using fuzzy similarity-based approach for identifying the correct component as well as predicting the possibility of component reassignment. Experimentation is done using bug reports of three open source projects from eclipse. The experimental results show that fuzzy similarity approach performs better as compared to state of art approaches on two out of three datasets in terms of precision score.

Predicting bug-fixing time: A replication study using an open source software project

Background: On projects with tight schedules and limited budgets, it may not be possible to resolve all known bugs before the next release. Estimates of the time required to fix known bugs (the “bug fixing time”) would assist managers in allocating bug fixing resources when faced with a high volume of bug reports. Aim: In this work, we aim to replicate a model for predicting bug fixing time with open source data from Bugzilla Firefox. Method: To perform the replication study, we follow the replication guidelines put forth by Carver [J. C. Carver, Towards reporting guidelines for experimental replications: a proposal, in: 1st International Workshop on Replication in Empirical Software Engineering, 2010.]. Similar to the original study, we apply a Markov-based model to predict the number of bugs that can be fixed monthly. In addition, we employ Monte-Carlo simulation to predict the total fixing time for a given number of bugs. We then use the k-nearest neighbors algorithm to classify fixing times into slow and fast. Result: The results of the replicated study on Firefox are consistent with those of the original study. The results show that there are similarities in the bug handling behaviour of both systems. Conclusion: We conclude that the model that estimates the bug fixing time is robust enough to be generalized, and we can rely on this model for our future research.

Finding the best bug fixing rate and bug fixing time using software reliability modelling

This article is mainly focused on finding the best possible way to rectify bug fixing rate (BFR) and bug fixing time (BFT). Further, versatile software projects have been verified when materialising the bug fixing rate. To increase the bug fixing rate, bug traceability is reduced by virtue of version tag in each and every component of a software deliverable. Software build release time is optimised by using mathematical optimisation techniques such as software reliability growth and non-homogeneous Poisson process models. This is very much essential in the present market scenario. The build inconsistency and automation are also rectified in this erudite research work. The developed software is free from defects and improves the software quality by increasing bug fixing rate.

Finding the best bug fixing rate and bug fixing time using software reliability modelling

This article is mainly focused on finding the best possible way to rectify bug fixing rate (BFR) and bug fixing time (BFT). Further, versatile software projects have been verified when materialising the bug fixing rate. To increase the bug fixing rate, bug traceability is reduced by virtue of version tag in each and every component of a software deliverable. Software build release time is optimised by using mathematical optimisation techniques such as software reliability growth and non-homogeneous Poisson process models. This is very much essential in the present market scenario. The build inconsistency and automation are also rectified in this erudite research work. The developed software is free from defects and improves the software quality by increasing bug fixing rate.

Automated Bug Report Field Reassignment and Refinement Prediction

Bug fixing is one of the most important activities in software development and maintenance. Bugs are reported, recorded, and managed in bug tracking systems such as Bugzilla. In general, a bug report contains many fields, such as product, component, severity, priority, fixer, operating system (OS), and platform, which provide important information for the bug triaging and fixing process. Our previous study finds that approximately 80% of bug reports have their fields reassigned and refined at least once, and bugs with reassigned and refined fields take more time to fix than bugs with no reassigned and refined fields. Thus, automatically predicting which bug report fields get reassigned and refined could help developers to save bug fixing time. Considering that a bug report could have multiple field reassignments and refinements (e.g., the product, component, fixer, and other fields of a bug report can get reassigned and refined), in this paper, we propose a multi-label learning algorithm to predict which bug report fields might be reassigned and refined. We note that the number of bug reports with some types of reassignment and refinement (e.g., bugs whose severity fields gets reassigned and refined) is a small proportion of the whole bug report collection, indicating the class imbalance problem. Thus, we propose imbalanced ML.KNN (Im-ML.KNN), which extends ML.KNN, one of the state-of-the-art multi-label learning algorithms, to achieve better performance. Im-ML.KNN is a composite model that combines 3 multi-label classifiers built using different types of features (i.e., meta, textual, and mixed features). We evaluate our solution on 4 large bug report datasets including OpenOffice, Netbeans, Eclipse, and Mozilla containing a total of 190,558 bug reports. We show that Im-ML.KNN can achieve an average F-measure score of 0.56–0.62. We also compare Im-ML.KNN with other state-of-art methods, such as the method proposed by Lamkanfi , ML.KNN, and HOMER-NB. The results show that Im-ML.KNN, on average, improves the average F-measure scores of Lamkanfi 's method, ML.KNN, and HOMER-NB by 119.69%, 9.11%, and 161.08%, respectively.

버그 리포트를 이용한 버그 정정 시간 추정

As fixing bugs is a large part of software development and maintenance, estimating the time to fix bugs -bug fixing time- is extremely useful when planning software projects. Therefore, in this study, we propose a way to estimate bug fixing time using bug reports. First, we classify previous bug reports with meta fields by applying a k-NN method. Next, we compute the similarity of the new bug and previous bugs by using data from bug reports. Finally, we estimate how long it will take to fix the new bug using the time it took to repair similar bugs. In this study, we perform experiments with open source software. The results of these experiments show that our approach effectively estimates the bug fixing time.