Bug Resolution Research Articles

Improving Log Anomaly Detection via Spatial Pooling: Combining SPClassifier with Ensemble Method

In the ever-updating field of software development, new bugs emerge daily, requiring significant time for analysis. As a result, research is being conducted on automating bug resolution using techniques such as anomaly detection through deep learning applied to text logs. This study focuses on anomaly detection using text logs and aims to address current challenges. Specifically, we aim to improve the accuracy of SPClassifier, a robust and lightweight AI model capable of handling dynamic log datasets through ad-hoc learning. We employ three ensemble learning methods to enhance the accuracy of SPClassifier. The method that achieved the greatest improvement was Improved Bagging, which combines the non-overlapping sampling of Pasting with the overlapping sampling of Bagging, resulting in a maximum F1-score improvement of 155%. Additionally, on certain datasets, the F1-score surpassed that of well-known DNN methods by 130%. Furthermore, the proposed method demonstrated lower variance compared to DNN methods, indicating its advantage, particularly in environments where datasets frequently fluctuate, such as development fields. These results highlight the clear superiority of the proposed method, which is lightweight in terms of computational resources and supports ad-hoc learning.

On the value of instance selection for bug resolution prediction performance

AbstractSoftware maintenance is a challenging and laborious software management activity, especially for open‐source software. The bugs reports of such software allow tracking maintenance activities and were used in several empirical studies to better predict the bug resolution effort. These reports are known for their large size and contain nonrelevant instances that need to be preprocessed to be suitable for use. To this end, instance selection (IS) has been proposed in the literature as a way to reduce the size of the datasets, while keeping the relevant instances. The objective of this study is to perform an empirical study that investigates the impact of data preprocessing through IS on the performance of bug resolution prediction classifiers. To deal with this, four IS algorithms, namely, edited nearest neighbor (ENN), repeated ENN, all‐k nearest neighbors, and model class selection, are applied on five large datasets, together with five machine learning techniques. Overall, 125 experiments were performed and compared. The findings of this study highlight the positive impact of IS in providing better estimates for bug resolution prediction classifiers, in particular using repeated ENN and ENN algorithms.

Bug Tracking System

For many years, bug-tracking mechanisms have been employed only in some of the large software development houses. Most of the others never bothered with bug tracking at all, and instead simply relied on shared lists and email to monitor the status of defects. This procedure is error-prone and tends to cause those bugs judged least significant by developers to be dropped or ignored. Bug Tracking System is an ideal solution to track the bugs of a product, solution or an application. Bug Tracking System allows individuals or groups of developers to keep track of outstanding bugs in their product effectively. This can also be called the Defect Tracking System. The Bug Tracking System can dramatically increase the productivity and accountability of individual employees by providing a documented workflow and positive feedback for good performance. Moreover, the project explores the use of machine learning for automated root cause analysis, assisting developers in identifying underlying issues contributing to bug occurrences. Recommendation systems are also developed to suggest potential fixes or solutions for reported bugs based on past incidents and code repositories, aiding developers in efficient bug resolution. Through these ML-driven functionalities, the proposed bug tracking software aims to revolutionize the bug management process, enabling faster bug detection, prioritization, and resolution, thereby enhancing software quality, user satisfaction, and overall development productivity. Key Words: Bug Tacking system, apps, users.

Automatic App Review Using Android Application

DeepMatcher comes with a tool that connects usage data from app analytics to error reports in the monitored data. DeepMatcher uses advanced techniques to automate this process, enabling developers to quickly spot bugs and dynamically improve bug reporting. In this Paper we have got Simple Mail Transfer protocol (SMTP) which can send and receive Mail to concerned app developers for the improvement in app experience. As our abstract aims to make a standalone app that can make the user give feedback directly to developer so that the app satisfies the user as NLP required in DeepMatcher to report the SMTP used is simplified and make the developer easily rectify the issue with regards to this research we propose DeepMatcher, a tool to automate bug detection and enhance bug reporting in app development .We contrast our solution to an alternative, SMTP (Simple Mail Transfer Protocol), featuring distinct advantages. Whilst DeepMatcher illustrates automation, SMTP provides user-to-developer direct and immediate communication channels, simplifying feedback submission and bug reports. This direct approach provides timely and detailed feedback, faster bug resolution and higher app quality resulting in improved user satisfaction. Keywords— SMTP, CoRe, Standalone, Feedback, Developer, Generated

Bug priority change: An empirical study on Apache projects

In issue tracking systems, each bug is assigned a priority level (e.g., Blocker, Critical, Major, Minor, or Trivial in JIRA from highest to lowest), which indicates the urgency level of the bug. In this sense, understanding bug priority changes helps to arrange the work schedule of participants reasonably, and facilitates a better analysis and resolution of bugs. According to the data extracted from JIRA deployed by Apache, a proportion of bugs in each project underwent priority changes after such bugs were reported, which brings uncertainty to the bug fixing process. However, there is a lack of in-depth investigation on the phenomenon of bug priority changes, which may negatively impact the bug fixing process. Thus, we conducted a quantitative empirical study on bugs with priority changes through analyzing 32 non-trivial Apache open source software projects. The results show that: (1) 8.3% of the bugs in the selected projects underwent priority changes; (2) the median priority change time interval is merely a few days for most (28 out of 32) projects, and half (50. 7%) of bug priority changes occurred before bugs were handled; (3) for all selected projects, 87.9% of the bugs with priority changes underwent only one priority change, most priority changes tend to shift the priority to its adjacent priority, and a higher priority has a greater probability to undergo priority change; (4) bugs that require bug-fixing changes of higher complexity or that have more comments are likely to undergo priority changes; and (5) priorities of bugs reported or allocated by a few specific participants are more likely to be modified, and maximally only one participant in each project tends to modify priorities.

The vital role of community in open source software development: A framework for assessment and ranking

AbstractOpen source software (OSS) follows a software development paradigm whereby self‐motivated volunteers scattered all around the globe contribute to the development in the form of code, documentation, feedback, feature recommendations, bug reporting, and bug resolution. These volunteers, commonly referred to as OSS project community, serve as the foundation of the OSS project, fostering its creation and sustenance and providing long‐term support. The quality and sustainability of the OSS project is reliant upon the development and structure of the self‐governing community. When a business organization plans to acquire an OSS solution, it not only takes into consideration the factors such as reliability, security, and scalability but also attaches significant importance to the likelihood of the OSS project being maintained and supported in the future so that it can rely on it as a stable and secure technology solution. Modern cloud‐based software hosting platforms, such as GitHub, offer a range of options for automatically and freely accessing the complete development history of millions of OSS projects. This easy availability of detailed development history has enabled researchers to analyze and draw quantitative and scientific inferences about the quality of an OSS project which generally involves assessing three aspects, namely, software product, development process, and project community. With focus on project community part, a Framework for Assessment and Ranking of OSS Community is being presented in the current research work, following a detailed examination of the largest source code hosting and project collaboration platform, GitHub. Technique for Order of Preference by Similarity to Ideal Solution from Multi‐Criteria Decision‐Making toolkit has been utilized for assessing the quality of the project community. The framework has been validated by applying it on nine OSS projects and comparing the results with the outcomes obtained through an existing OSS evaluation methodology. The comparative analysis demonstrated that the proposed framework aligns with the aforementioned evaluation methodology while offering an opportunity for in‐depth analysis on the dynamics of volunteer communities, which is lacking in previous evaluation methods. These insights can prove valuable for both potential adopters and project maintainers, aiding them in making informed strategic decisions.

Duplicate Bug Report detection using Named Entity Recognition

Software bugs pose significant challenges in management. The Bug Tracking System (BTS) serves as a standard platform to chronicle, oversee, and manage bugs throughout software development and maintenance. While BTS aggregates numerous bug reports for tracking purposes, identical bugs often get reported by various individuals. This redundancy leads to excessive duplicate reports, straining manual inspection efforts, risking repeated bug assignment tasks, and diminishing the efficiency of bug resolution. Notably, many contemporary DBR detection techniques tend to overlook the structured data abundant in descriptive information about bug report behaviors. To mitigate this oversight, this study introduces a groundbreaking method named CorNER. This technique enhances DBR detection precision by converting unstructured textual content into structured data via named entity recognition (NER). Specifically, CorNER employs Random Forest with context (RNER) to annotate entities in the title and description sections of bug reports and subsequently harnesses Text Convolutional Neural Networks (TextCNN) for feature extraction. Empirical evidence indicates a commendable improvement in CorNER’s F1-Score by 6.24% and 4.96% on average, surpassing the benchmarks of two prevalent DBR detection methods across five datasets.

BERT based severity prediction of bug reports for the maintenance of mobile applications

Mobile application maintenance is crucial to ensuring the accurate operation and continuous improvement of mobile applications (mobile apps). To effectively address issues and enhance the user experience, developers utilize issue-tracking systems that gather bug reports to refine mobile apps. Users can submit bugs through these systems, allowing them to determine the severity of each reported issue. The severity level plays a pivotal role in prioritizing bug resolution, enabling developers to address critical bugs promptly. Nonetheless, manually assessing the severity of each issue can be laborious and prone to errors. To overcome this challenge, this paper presents Bidirectional Encoder Representations from Transformers (BERT) based severity prediction of bug reports (called BERT-SBR) that leverages a deep neural network for automatic bug severity classification for mobile app maintenance. We collect the publicly available mobile apps bug reports dataset from the Hugging Face. BERT-SBR first computes the sentiment of reporters of bug reports and preprocesses them by leveraging BertTokenizer input formatting techniques. Next, it passes the formatted text and computed sentiment of each bug report to generate word embeddings. Then, it introduces a fine-tuned BERT classifier for bug report severity prediction. After that, it passes the generated word embeddings to the fine-tuned BERT classifier for training and testing. Finally, the proposed classifier’s performance is evaluated. The BERT-SBR assessment results confirm that the fine-tuned BERT classifies bug reports significantly more effectively than other deep learning classifiers. On average, BERT-SBR achieves a remarkable improvement of 40.43%, 67.78%, 40.71%, and 58.14% in the accuracy, precision, recall, and f-measure. This indicates its superiority in accurately predicting the severity of bug reports for mobile application maintenance.

Deep learning-based software bug classification

Context:Accurate classification of bugs can help accelerate the bug triage process, code inspection, and repair activities. In this context, many machine learning techniques have been proposed to classify bugs. The expressive power of deep learning could be used to further improve classification. Objective:We propose a novel deep learning-based bug classification approach. Methods:We first build a bug taxonomy with eight bug classes, each characterized by a set of keywords. Subsequently, we heuristically annotate a moderately large set (∼1.36M) of software bug resolution reports using an earth-mover distance technique based on the keywords. Finally, we use four attention-based classification techniques to classify these curated bugs. Results:Our experiments on a carefully collected dataset indicate that our proposed technique achieved a mean F1-Score of 84.78% and a mean macro-average ROC of 98.25%. Conclusion:Our proposed approach was observed to outperform the existing techniques by 16.88% on an average in terms of F1-Score for the considered dataset.

Enhanced Approach for Bug Severity Prediction: Experimentation and Scope for Improvements

Software development is an iterative process, where developers create, test, and refine their code until it is ready for release. Along the way, bugs and issues are inevitable. A bug can be any error identified in requirement specification, design or implementation of any project. These bugs need to be categorized and assigned to developers to be resolved. the number of bugs generated in any large scale project are vast in number. These bugs can have significant or no impact on the project depending on the type of bug. The aim of this study is to develop a deep learning-based bug severity prediction model that can accurately predict the severity levels of software bugs. This study aims to address the limitations of the current manual bug severity assessment process and provide an automated solution using various classifiers e.g. Naïve Bayes, Logistic regression, KNN and Support vector machine along with Mutual information as feature selection method, that can assist software development teams in giving severity code to bugs effectively. It seeks to improve the overall software development process by reducing the time and effort required for bug resolution and enhancing the quality and reliability of software.

Automated program and software defect root cause analysis using machine learning techniques

For the automated root cause analysis (ARCA) method and simplified RCA technique, their empirical assessment is presented in this study. A focus group meeting is a foundation for the target problem identification in the ARCA technique. This is compared to earlier RCA methodologies which rely on problem sampling for target problem discovery and high beginning costs. In this research, we suggest a naïve Bayes based machine learning method for identifying the underlying causes of newly reported software issues, which will facilitate a quicker and more effective resolution of software bugs. The ARCA technique produced a large number of high-quality corrective actions while requiring a reasonable amount of effort. The strategy is an effective way to find new opportunities for process improvement and produce fresh process improvement ideas in contrast to the organization’s corporate practices. In addition it is simple to utilize. Ultimately, we compared the methodology with other machine learning classifiers including support vector machine and decision tree.

SusRec: An Approach to Sustainable Developer Recommendation for Bug Resolution Using Multimodal Ensemble Learning

The sustainability of an open source project is essential for the long-term and reliable development of software. Most existing studies focus on the recommendation accuracy of bug report assignment while ignoring inexperienced developers in the open source community. This gives inexperienced developers less opportunity to resolve bugs and can cause them to gradually lose interest in the development of open source software (OSS). To address this problem, this article proposes a novel approach called sustainable recommender (SusRec) to make sustainable report assignments without sacrificing accuracy. The SusRec approach is based on multimodal learning and ensemble learning, and it consists of two stages: the preprocessing stage and the developer scoring stage. In the preprocessing stage, the approach selects candidate developers who have participated in the resolution of bugs under the product of a new bug report. It then divides the candidate developers into three types—core developers, active developers, and peripheral developers—according to their experience. In the developer scoring stage, multimodal learning is adopted to score the three types of bug report–developer pairs, and ensemble learning is adopted to weight the scores of the three types of bug report–developer pairs and recommend developers for bug reports. We conduct extensive experiments using the bug repositories of the Eclipse and Mozilla projects to compare the proposed SusRec approach with the baseline methods in bug report assignment. The results demonstrate that the proposed SusRec approach cannot only improve the accuracy of developer recommendations for bug reports, but also the sustainability of OSS projects by providing more opportunities for active developers and peripheral developers to participate in bug resolution.

Large-Scale Identification and Analysis of Factors Impacting Simple Bug Resolution Times in Open Source Software Repositories

One of the most prominent issues the ever-growing open-source software community faces is the abundance of buggy code. Well-established version control systems and repository hosting services such as GitHub and Maven provide a checks-and-balances structure to minimize the amount of buggy code introduced. Although these platforms are effective in mitigating the problem, it still remains. To further the efforts toward a more effective and quicker response to bugs, we must understand the factors that affect the time it takes to fix one. We apply a custom traversal algorithm to commits made for open source repositories to determine when “simple stupid bugs” were first introduced to projects and explore the factors that drive the time it takes to fix them. Using the commit history from the main development branch, we are able to identify the commit that first introduced 13 different types of simple stupid bugs in 617 of the top Java projects on GitHub. Leveraging a statistical survival model and other non-parametric statistical tests, we found that there were two main categories of categorical variables that affect a bug’s life; Time Factors and Author Factors. We find that bugs are fixed quicker if they are introduced and resolved by the same developer. Further, we discuss how the day of the week and time of day a buggy code was written and fixed affects its resolution time. These findings will provide vital insight to help the open-source community mitigate the abundance of code and can be used in future research to aid in bug-finding programs.

Bug Prioritization Using Average One Dependence Estimator

Automation software need to be continuously updated by addressing software bugs contained in their repositories. However, bugs have different levels of importance; hence, it is essential to prioritize bug reports based on their severity and importance. Manually managing the deluge of incoming bug reports faces time and resource constraints from the development team and delays the resolution of critical bugs. Therefore, bug report prioritization is vital. This study proposes a new model for bug prioritization based on average one dependence estimator; it prioritizes bug reports based on severity, which is determined by the number of attributes. The more the number of attributes, the more the severity. The proposed model is evaluated using precision, recall, F1-Score, accuracy, G-Measure, and Matthew’s correlation coefficient. Results of the proposed model are compared with those of the support vector machine (SVM) and Naive Bayes (NB) models. Eclipse and Mozilla datasetswere used as the sources of bug reports. The proposed model improved the bug repository management and outperformed the SVM and NB models. Additionally, the proposed model used a weaker attribute independence supposition than the former models, thereby improving prediction accuracy with minimal computational cost.

Developer load balancing bug triage: Developed load balance

AbstractDuring the software development process, numerous bugs are reported daily in the software bug repositories. Bug triage assigned these bugs to the most relevant and expert developer for resolution. Moreover, assigning bugs to an incompetent or an over‐engaged developer causes repeated reassignment to other developers until it is resolved. This problem can be solved by devising a triage process that assigns bugs to not only expert developers but also to those who are either under‐engaged or reasonably engaged but are not over‐engaged in work. This paper has designed and implemented work engagement sensitive bug triage that resolves the issue of assigning bugs to developers considering their due work engagement, expertise as well as the current state of activity. For this purpose, a developer profile is built by using metrics to generate three types of scores: technical skill, work engagement and work experience. Metadata features like developer‐name, email, developer‐work‐experience in bug resolution, last and present‐work‐activity, timestamp, component and priority are used for it. A multi‐criteria‐based Henry–Garret technique is used to generate a single ranked list of developers from three ranked lists. The performance of the proposed approach is evaluated on four large OOS projects: Mozilla, Eclipse, Netbeans, and Open Office covering 895,439 bug reports accumulated for 33 years of development. The overall system accuracy of the proposed triage using all four datasets is 91.96 ± 0.05% which is 5.87% better than previously published work. The proposed method is achieved up to 90.30 ± 0.05 and 97.1 ± 0.05 MRR and accuracy of reassignment respectively that indicates how significantly it re‐assigns the bug to the relevant developers. The results demonstrate improvement in the accuracy of software‐bugs triaging as well as a reduction in the probability of bug‐tossing.

Characterizing duplicate bugs: Perceptions of practitioners and an empirical analysis

AbstractBug handling is an essential part of the software development process. Ideally, in a bug‐tracking system, bugs are reported, fixed, verified, and closed. In some cases, bugs have to be reopened mostly due to an incorrect fix. However, instead of reopening the existing bug report, users may submit a new report for a previously reported bug, which results in duplicate bug reports. Users might report duplicate bugs if they miss the previous bug report or if the previous bug is unresolved (i.e., in progress) and therefore cannot be reopened. These duplicate bug reports may cost extra maintenance efforts in triaging and bug fixing. There have been several studies on characterizing reopened bugs and duplicate bug reports; however, to the best of our knowledge, there has been no prior work on understanding the dynamics of their interaction, which is missed reopen bugs. Our study is based on analyzing the difference between duplicate and nonduplicate bugs and further categorizing the duplicate bugs. In this regard, we categorize duplicate bugs according to the original bug's resolution status at the duplicate's creation time as Master‐Unresolved bugs and Master‐Resolved (Missed Reopen) bugs to distinguish their properties. We compare these two types of bugs in terms of their relationship to their master bug, bug surface time, bug fix time, bug's severity, and the number of users involved. We perform case studies using the Eclipse and Mozilla projects' bug repositories that include more than 165,500 and 394,000 bug reports, respectively. Additionally, we investigate the perceived importance, impact, and causes of duplicate bugs, as well as the difference between nonduplicate and duplicate bugs and its categories for practitioners in the software industry by conducting a survey.

SPAN: A self-paced association augmentation and node embedding-based model for software bug classification and assignment

Effective bug classification and assignment to relevant developers improves the efficiency of software management. However, textually dependent approaches produce inconsistent results on varying datasets, while approaches that depend upon multi-source data can produce dataset conflicts and inaccuracy. Accordingly, we introduce a model based on Self-Paced Association augmentation and Node embedding (SPAN), which uses an effective combination of textually dependent and independent bug categorization to produce consistent results, followed by a bug assignment mechanism to prevent conflicts. To this end, we present a novel unified classifier and assignment model that exploits the connections between nodes in the Software Bug Report Network (SBRNet) to identify the target features. The model is capable of accurately categorizing bugs in a self-paced manner with association augmentation. Finally, we present an approach that assigns the most appropriate developer for bug resolution through SBRNet node information embedding. Our deep two-step self-paced solution is capable of categorizing software bugs with improved accuracy, while still utilizing fewer features. Results reveal that our model is more effective (up to 98% classification accuracy and 96% for bug assignment) when compared to its counterparts.

Automated Event-Triggered GUI Testing and Bug Reproduction for Non-Android Applications

Today’s mobile gadgets are seamlessly incorporating innovative features demanded by the users. Most often, the applications contain bugs or functionality issues reported by the customers. The developers are responsible for reproducing such reported bugs, which are written in natural languages. Reproducing bugs from bug reports make the bug resolution inefficient. Nowadays, various methods are adopted to reproduce crash reports for android applications. But bug reproduction for non-android applications is still a challenging task. This paper proposes a novel approach that is capable of doing bug reproduction from bug reports to help the developers to solve the functionality issues of non-android applications in an automated manner. This approach uses a UI tester called the GUI engine, which is an excel sheet. The use cases which are to be tested can be filled in the GUI engine. All the use cases are to be filled based on a particular syntax. For that purpose, the developer can make use of a set of yaml files containing all the GUI information for all the screens of the application under test. The use cases are executed in the GUI engine and conclusions are made based on the test result. The GUI engine displays two colors green and red showing the working and failing of GUI components of the application under test. So that the developer can easily identify the failing components and take actions accordingly. The test has been done with more than 1000 test cases for one region and the result shows that almost all GUI components work for this method except for animation. It has tested for software developed for US, Europe, and German regions. Also, the proposed method is found to be much faster and efficient than the existing as well as manual testing methods.

Effective Prediction of Bug-Fixing Priority via Weighted Graph Convolutional Networks

With the increasing number of software bugs, bug fixing plays an important role in software development and maintenance. To improve the efficiency of bug resolution, developers utilize bug reports to resolve given bugs. Especially, bug triagers usually depend on bugs' descriptions to suggest priority levels for reported bugs. However, manual priority assignment is a time-consuming and cumbersome task. To resolve this problem, recent studies have proposed many approaches to automatically predict the priority levels for the reported bugs. Unfortunately, these approaches still face two challenges that include words' nonconsecutive semantics in bug reports and the imbalanced data. In this article, we propose a novel approach that graph convolutional networks (GCN) based on weighted loss function to perform the priority prediction for bug reports. For the first challenge, we build a heterogeneous text graph for bug reports and apply GCN to extract words' semantics in bug reports. For the second challenge, we construct a weighted loss function in the training phase. We conduct the priority prediction on four open-source projects, including Mozilla, Eclipse, Netbeans, and GNU compiler collection. Experimental results show that our method outperforms two baseline approaches in terms of the F-measure by weighted average of 13.22%.

CaPBug-A Framework for Automatic Bug Categorization and Prioritization Using NLP and Machine Learning Algorithms

Bug reports facilitate software development teams in improving the quality of software. These reports include significant information related to problems encountered within a software, possible enhancement suggestions, and other potential issues. Bug reports are typically complex and are too detailed; hence a lot of resources are required to analyze and process them manually. Moreover, it leads to delays in the resolution of high priority bugs. Accurate and timely processing of bug reports based on their category and priority plays a significant role in improving the quality of software maintenance. Therefore, an automated process of categorization and prioritization of bug reports is needed to address the aforementioned issues. Automated categorization and prioritization of bug reports have been explored recently by many researchers; however, limited progress has been made in this regard. In this research, we present a novel framework, titled CaPBug, for automated categorization and prioritization of bug reports. The framework is implemented using Natural Language Processing (NLP) and supervised machine learning algorithms. A baseline corpus is built with six categories and five prioritization levels by analyzing more than 2000 bug reports of Mozilla and Eclipse repository. Four classification algorithms i.e., Naive Bayes, Random Forest, Decision Tree, and Logistic Regression have been used to categorize and prioritize bug reports. We demonstrate that the CaPBug framework achieved an accuracy of 88.78% by using a Random Forest classifier with a textual feature for predicting the category. Similarly, using the CaPBug framework, an accuracy of 90.43% was achieved in predicting the priority of bug reports. Synthetic Minority Over-Sampling Technique (SMOTE) has been applied to address the class imbalance issue in priority classes.