Bug Reports Research Articles

Code quality control by bug report classification

Code quality control by bug report classification

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.

Graph collaborative filtering-based bug triaging

Issue tracking systems are widely used for collecting bug reports. A target of intelligent software engineering is to automate assigning bugs to appropriate developers. Recently, the momentum of artificial intelligence has brought many successful studies that triage bugs by classifying their reports with NLP-based methods. Some studies also try to introduce context information to represent developers. Nevertheless, they take a fundamental assumption that developers and bugs, closely related entities in real-world scenarios, should be modeled independently.To capture the bug-developer correlations in bug triaging activities, we propose a Graph Collaborative filtering-based Bug Triaging framework: (1) bug-developer correlations are modeled as a bipartite graph; (2) natural language processing-based pre-training is implemented on bug reports to initialize bug nodes; (3) spatial–temporal graph convolution strategy is designed to learn the representation of developer nodes; (4) information retrieval-based classifier is proposed to match bugs and developers. Extensive experiments across mainstream datasets show the competence of our GCBT. Moreover, We believe that GCBT could generally benefit the modeling of correlations in other software engineering scenarios.

Automated Priority Prediction for Bug Reports Using Comment Intensiveness Features and SMOTE Data Balancing

The processing priorities for software bug reports are important for software maintenance. Predicting the priorities for bug reports is the subject of many software engineering studies. This study proposes a priority prediction method that uses comment intensiveness features and a Synthetic Minority Over-sampling Technique (SMOTE)-based data balancing scheme. Experiments use datasets for three open-source projects: Eclipse, Mozilla and OpenOffice. The effectiveness of the proposed approach is determined using five classification models: Multinomial Naïve Bayes, Support Vector Machines, Random Forest, Extra Trees and eXtreme Gradient Boosting. The results show that the CIS-SMOTE-based models achieve 0.6078 Precision, 0.4927 Recall, 0.4465 F1-score and 0.7836 Accuracy in priority perdition. The results also show that CIS-SMOTE-RF, CIS-SMOTE-ET and CIS-SMOTE-XGB outperform two advanced priority prediction approaches, eApp and cPur, in terms of all performance measures.

Bug severity prediction using LDA and sentiment scores: A CNN approach

AbstractThe crucial part of the software development cycle is software maintenance. The demands included in the software management are fault fixes and request to change or bring a new feature. If priority is not given to these demands, then it may lead to customer dissatisfaction, inefficient planning, and software failure as well. Therefore, it is important to study the severity of the bug reports to maintain the efficiency of the software. Various research has been conducted in the past to predict the severity of the paper using text mining focusing only on the content of the bug reports. The sentiment of the user while reporting a bug also plays a vital role. In this study, we will be focusing on two aspects, that is, sentiment and content to improve the prediction. We propose a prediction model based on LDA to study the content aspect and emotion analysis to study the sentiment aspect. The model is validated on the datasets collected from the Eclipse project using Convolutional Neural Network (CNN). The results show that the CNN model effectively utilizes the content and sentiment aspect of the data to handle the severity prediction. CNN has weight sharing feature that decreases the number of parameters used for training. It also improves generalization and overfitting is avoided The Accuracy, Precision, Recall, and F‐measure are improved when both aspects are taken into account rather than considering only content.

Classification of Bugs in Cloud Computing Applications Using Machine Learning Techniques

In software development, the main problem is recognizing the security-oriented issues within the reported bugs due to their unacceptable failure rate to provide satisfactory reliability on customer and software datasets. The misclassification of bug reports has a direct impact on the effectiveness of the bug prediction model. The misclassification issue surely compromises the accuracy of the system. Manually reviewing bug reports is necessary to solve this problem, but doing so takes a lot of time and is tiresome for developers and testers. This paper proposes a novel hybrid approach based on natural language processing (NLP) and machine learning. To address these issues, the intended outcomes are multi-class supervised classification and bug prioritization using supervised classifiers. After being collected, the dataset was prepared for vectorization, subjected to exploratory data analysis, and preprocessed. The feature extraction and selection methods used for a bag of words are TF-IDF and word2vec. Machine learning models are created after the dataset has undergone a full transformation. This study proposes, develops, and assesses four classifiers: multinomial Naive Bayes, decision tree, logistic regression, and random forest. The hyper-parameters of the models are tuned, and it is concluded that random forest outperformed with a 91.73% test and 100% training accuracy. The SMOTE technique was used to balance the highly imbalanced dataset, which was initially created for the justified classification. The comparison between balanced and imbalanced dataset models clearly showed the importance of the balanced dataset in classification as it outperformed in all experiments.

A multi-model framework for semantically enhancing detection of quality-related bug report descriptions

A multi-model framework for semantically enhancing detection of quality-related bug report descriptions

Mobile crowdsourced test report prioritization based on text and image understanding

AbstractIn the process of mobile crowdsourced testing, a large number of test reports are generated, which often consist of short text and rich image information. One of the critical issues is how to review these reports efficiently. Researchers have recently proposed clustering, classification, and prioritization techniques to solve this problem. However, existing studies directly use related technologies to text description and segment the text content without further understanding of the text content. By deeply digging into the text information and distinguishing it according to its actual meaning, the sentences described in the text can be categorized into two types: Describing abnormal system behavior and describing reproduction steps. This paper proposes a mobile crowdsourced test report prioritization technique to improve performance. First, we use a TextCNN trained on large‐scale projects to distinguish the text descriptions of reports, then extract features from the text and screenshot information, respectively. Then we apply a clustering technique to gather similar reports. Finally, the inspection order is sampled from the clustering results. To validate our approach, we conduct experiments on six industrial crowdsourced projects. The results show that our method can detect all bugs faster in a limited time than existing prioritization methods, which can improve the bug reports review efficiency.

Bug localization based on syntactical and semantic information of source code

The existing software bug localization models treat the source file as natural language, which leads to the loss of syntactical and structure information of the source file. A bug localization model based on syntactical and semantic information of source code is proposed. Firstly, abstract syntax tree (AST) is divided based on node category to obtain statement sequence. The statement tree is encoded into vectors to capture lexical and syntactical knowledge at the statement level. Secondly, the source code is transformed into vector representation by the sequence naturalness of the statement. Therefore, the problem of gradient vanishing and explosion caused by a large AST size is obviated when using AST to the represent source code. Finally, the correlation between bug reports and source files are comprehensively analyzed from three aspects of syntax, semantics and text to locate the buggy code. Experiments show that compared with other standard models, the proposed model improves the performance of bug localization, and it has good advantages in mean reciprocal rank (MRR), mean average precision (MAP) and Top N Rank.

Sentence embedding and fine-tuning to automatically identify duplicate bugs

Industrial software maintenance is critical but burdensome. Activities such as detecting duplicate bug reports are often performed manually. Herein an automated duplicate bug report detection system improves maintenance efficiency using vectorization of the contents and deep learning–based sentence embedding to calculate the similarity of the whole report from vectors of individual elements. Specifically, sentence embedding is realized using Sentence-BERT fine tuning. Additionally, its performance is experimentally compared to baseline methods to validate the proposed system. The proposed system detects duplicate bug reports more effectively than existing methods.

Leveraging multi-level embeddings for knowledge-aware bug report reformulation

Software bug analysis based on the information retrieval (IR) technology is widely studied and used for bug understanding, localization and fixing. IR technology with various textual feature extraction methods formulates the textual information in a given new bug report (i.e., title and description) as an initial query. However, due to the low-quality content in the new bug report and improper representation to be used as a query, the retrieval results are usually not satisfactory.To alleviate these problems, we propose a novel knowledge-aware bug report reformulation approach (a.k.a, KABR) by leveraging multi-level embeddings from the bug data. First, we construct a bug-specific knowledge graph (KG) to manage and reuse prior knowledge extracted from historical bug reports. Then, we extract word embedding from the original bug data, entity embedding and context embedding from the bug-specific KG to enhance the initial query. Finally, a new query representation is generated by leveraging multi-level embeddings through Convolutional Neural Networks (CNN) with the self-attention mechanism. We evaluate KABR based on the duplicate bug report detection task, and the experimental results show that KABR achieves 6%–11% F1-measure improvement over the state-of-the-art approaches.

The Impact of GloVe and Word2Vec Word-Embedding Technologies on Bug Localization with Convolutional Neural Network

In the field of software engineering, software quality assurance faces many challenges, including overcoming the problem of identifying errors in the source code. Finding the location of the error in the source code is a very important process, as is taking advantage of the semantic information available in the bug reports and the source code to find the similarities between them, using modern techniques called word embedding. This study aims to demonstrate how GloVe and Doc2Vec word-embedding technologies affect bug localization accuracy and performance. Therefore, this study proposes to adapt DeepLoc by using GloVe embedding techniques to process the source code instead of Word2vec and using Word2vec embedding techniques to process the bug report instead of Sent2Vec. AspectJ represents the large dataset, which contains many bug reports, while SWT's small dataset contains fewer bug reports. Experimental results show that the improved DeepLoc on SWT achieves 0.60 and 0.72 MAP and MRR, respectively. While the improved DeepLoc on AspectJ achieves 0.17 and 0.27 MAP and MRR, respectively. The results of the improved DeepLoc should be compared using two advanced models from previous studies: DeepLoc, DeepLocator.

A Study of the Ping An Health App Based on User Reviews with Sentiment Analysis.

By mining the dimensional sentiment and dimension weight of the Ping An Health App reviews, this paper explores the changing trend of the influence of dimensions on user satisfaction and provides suggestions for the Ping An Health App operators to improve user satisfaction. Firstly, the topic model is used to identify the topic of user comments, and then the fine-grained sentiment analysis method is used to calculate the sentiment and weight of each dimension. Finally, the changing trend of the weight of each dimension and the changing trend of user satisfaction of each dimension are drawn. Based on the reviews of the Ping An Health App in the Apple App Store, users' concerns about Ping An Health App can be summarized into seven main dimensions: Usage, Bug report, Reliability, Feature information, Services, Other apps, and User Background. The "Feature information" dimension and "Reliability" dimension have a great impact on user satisfaction with the Ping An Health App, while the "Bug report" dimension has the lowest user satisfaction.

Checking Just Pairs of Threads for Efficient and Scalable Incremental Verification of Multithreaded Programs

Many techniques of automated verification target multithreaded programs, because subtle interactions between threads may trigger concurrency errors such as deadlocks and data races. However, techniques and tools involving systematic exploration of the whole space of possible thread interleavings do not scale to large software systems, despite various clever algorithmic optimizations. A viable approach is to use incremental verification techniques that, in each run, focus just on the recently modified code and the relatively small number of affected execution traces, and therefore can provide results (bug reports) very quickly. In this paper we present a new algorithm for incremental verification of multithreaded programs based on the pairwise approach, whose key idea is systematic exploration of all possible thread interleavings just for specific relevant pairs of threads. We implemented the algorithm with Java Pathfinder as the backend verification tool, and evaluated it on several multithreaded Java programs. Results show that our incremental algorithm (1) can find errors very fast, (2) greatly reduces time needed for complete safety verification, and (3) it can find the same errors as full verification of the whole state space.

Does Deep Learning improve the performance of duplicate bug report detection? An empirical study

Do Deep Learning (DL) techniques actually help to improve the performance of duplicate bug report detection? Prior studies suggest that they do, if the duplicate bug report detection task is treated as a binary classification problem. However, in realistic scenarios, the task is often viewed as a ranking problem, which predicts potential duplicate bug reports by ranking based on similarities with existing historical bug reports. There is little empirical evidence to support that DL can be effectively applied to detect duplicate bug reports in the ranking scenario. Therefore, in this paper, we investigate whether well-known DL-based methods outperform classic information retrieval (IR) based methods on the duplicate bug report detection task. In addition, we argue that both IR- and DL-based methods suffer from incompletely evaluating the similarity between bug reports, resulting in the loss of important information. To address this problem, we propose a new method that combines IR and DL techniques to compute textual similarity more comprehensively. Our experimental results show that the DL-based method itself does not yield high performance compared to IR-based methods. However, our proposed combined method improves on the MAP metric of classic IR-based methods by a median of 7.09%–11.34% and a maximum of 17.228%–28.97%.

Improving Bug Localization With Effective Contrastive Learning Representation

Automated localization of buggy files can accelerate developers’ efficiency of software maintenance, improving the quality of software products. State-of-the-art approaches for bug localization is based on neural networks, e.g., RNN or CNN, and can learn semantic feature from the given bug report. However, these simple neural architectures are difficult to learn the deep contextual feature from bug reports, which hurts the semantic mapping between bug reports and their corresponding buggy files. To resolve the above problem, in this paper we propose a bug localization approach that combines pre-trained language models and contrastive learning, namely CoLoc. Specifically, CoLoc first is pre-trained on a large-scale bug report corpus in an unsupervised way, to learn the deep contextual feature of each token in the bug report according to its context. Afterward, CoLoc is further pre-trained by a contrastive learning objective to learn the contrastive learning representations both of bug reports and buggy files. Contrastive learning can help CoLoc to learn the semantic differences between different bug reports and buggy files. To evaluate the effectiveness of CoLoc, we choose five baseline approaches and compare their performance on a public dataset. The experimental results show that CoLoc outperforms all baseline approaches by up to 76.00% in terms of MRR, achieving new results for bug localization.

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.

Enhancing Bug Localization Using Phase-Based Approach

Software bug localization is an important step in the software maintenance process. Automatic bug localization can reduce the time consumed in the process of localization. Some techniques are applied in the bug localization process, but those techniques suffer from limitations in time and accuracy. This paper proposes a phase-based bug localization approach to overcome these limitations. The approach is composed of three main phases which are raw data preparation, package classification, and source code recommendation. The main input to our approach is a bug report and the source code of the past versions for the target system of interest. From the bug report, various information is utilized: the summary, the description, the stack traces, and the fixed source code files. The raw data preparation phase is used to restructure those inputs. The package classification phase aims to locate the package that would include the source code to be modified as a first step, hence reducing the time needed to locate the source code file due to the lexical mismatch between those files and the bug report data. Bidirectional Encoder Representations from Transformers (BERT), which is a sentence embedding technique, is utilized in the package classification and source code recommendation phases. The experimental results show that our approach outperforms existing approaches according to TOP-N rank and Mean Reciprocal Rank (MRR) evaluation metrics.

Adaptive Deep Learning Model for Software Bug Detection and Classification

Software is unavoidable in software development and maintenance. In literature, many methods are discussed which fails to achieve efficient software bug detection and classification. In this paper, efficient Adaptive Deep Learning Model (ADLM) is developed for automatic duplicate bug report detection and classification process. The proposed ADLM is a combination of Conditional Random Fields decoding with Long Short-Term Memory (CRF-LSTM) and Dingo Optimizer (DO). In the CRF, the DO can be consumed to choose the efficient weight value in network. The proposed automatic bug report detection is proceeding with three stages like pre-processing, feature extraction in addition bug detection with classification. Initially, the bug report input dataset is gathered from the online source system. In the pre-processing phase, the unwanted information from the input data are removed by using cleaning text, convert data types and null value replacement. The pre-processed data is sent into the feature extraction phase. In the feature extraction phase, the four types of feature extraction method are utilized such as contextual, categorical, temporal and textual. Finally, the features are sent to the proposed ADLM for automatic duplication bug report detection and classification. The proposed methodology is proceeding with two phases such as training and testing phases. Based on the working process, the bugs are detected and classified from the input data. The projected technique is assessed by analyzing performance metrics such as accuracy, precision, Recall, F_Measure and kappa.

Empirical Study: How Issue Classification Influences Software Defect Prediction

Software defect prediction aims to identify potentially defective software modules to better allocate limited quality assurance resources. Practitioners often do this by utilizing supervised models trained using historical data. This data is gathered by mining version control and issue tracking systems. Version control commits are linked to issues they address. If the linked issue is classified as a bug report, the change is considered as bug fixing. The problem arises from the fact that issues are often incorrectly classified within issue tracking systems. This introduces noise into the gathered datasets. In this paper, we investigate the influence issue classification has on software defect prediction dataset quality and resulting model performance. To do this, we mine data from 7 popular open-source repositories, create issue classification and software defect prediction datasets for each of them. We investigate issue classification using four different methods; a simple keyword heuristic, an improved keyword heuristic, the FastText model and the RoBERTa model. Our results show that using the RoBERTa model for issue classification produces the best software defect prediction datasets, containing on average 14.3641% of mislabeled instances. SDP models trained on such datasets achieve superior performance, to those trained on SDP datasets created using other issue classification methods, in 65 out of 84 experiments, with 55 of them being statistically relevant. Furthermore, in 17 out of 28 experiments we could not show a statistically relevant performance difference between SDP models trained on RoBERTa derived software defect prediction datasets and those created using manually labeled issues.