Bug Prediction Research Articles

KnowBug: Enhancing Large language models with bug report knowledge for deep learning framework bug prediction

Understanding and predicting the bug type is crucial for developers striving to enhance testing efficiency and reduce software release problems. Bug reports, although semi-structured, contain valuable semantic information, making their comprehension critical for accurate bug prediction. Recent advances in large language models (LLMs), especially generative LLMs, have demonstrated their power in natural language processing. Many studies have utilized these models to understand various forms of textual data. However, the capability of LLMs to fully understand bug reports remains uncertain. To tackle this challenge, we propose KnowBug, a framework designed to augment LLMs with knowledge from bug reports to improve their ability to predict bug types. In this framework, we utilize bug reports from open-source deep learning frameworks, design specialized prompts, and fine-tune LLMs to assess KnowBug’s proficiency in understanding bug reports and predicting different bug types.

Software bug prediction using graph neural networks and graph-based text representations

While open-source communities keep growing at an impressive pace, the corresponding platforms where software engineers share their work, deliberate about software-related issues, point out undetected bugs and suggest potential features that could be incorporated, usually suffer from information overload. This paper proposes a hybrid approach that builds on the strengths of word embeddings techniques, graph-based representation of textual data and graph neural networks for the prediction of software bugs. Existing approaches aim to improve each of these components individually, thus neglecting structural or semantical underlying information. On the contrary, the approach presented in this paper aims to leverage both types of information by representing each text as a graph and utilizing Graph Attention Networks (GATs). The evaluation carried out in this paper demonstrates an overall improvement for a variety of metrics (i.e., accuracy, precision and recall), in comparison with a plethora of graph-based machine learning models. The experiments took place using four datasets of short-text GitHub and Jira issues, which are publicly available on the kaggle.com and zenodo.com platforms respectively.

Development of partial least squares regression with discriminant analysis for software bug prediction

Many prediction models and approaches have been introduced during the past decades that try to forecast bugged code elements based on static source code metrics, change and history metrics, or both. However, there is still no universal best solution to this problem, as most suitable features and models vary from dataset to dataset and depend on the context in which we use them. Therefore, novel approaches and further studies on this topic are highly necessary.In this paper, we employ a chemometric approach – Partial Least Squares with Discriminant Analysis (PLS-DA) – for predicting bug prone Classes in Java programs using static source code metrics. PLS-DA is successfully applied within the field of chemometrics, but to our best knowledge, it has never been used before in the software maintenance domain for predicting bugs. In addition, we have used rigorous statistical treatments and evaluation for representing the software engineering results.We show that our PLS-DA based prediction model achieves superior performances compared to the state-of-the-art approaches (i.e. F-measure of 0.44–0.47 at 90% confidence level) when no data re-sampling applied and comparable to others when applying up-sampling on the largest open bug dataset, while training the model is significantly faster, thus finding optimal parameters is much easier. In terms of completeness, which measures the amount of bugs contained in the Java Classes predicted to be defective, PLS-DA outperforms every other algorithm: it found 69.3% and 79.4% of the total bugs with no re-sampling and up-sampling, respectively.

An exploratory study on just-in-time multi-programming-language bug prediction

Context:An increasing number of software systems are written in multiple programming languages (PLs), which are called multi-programming-language (MPL) systems. MPL bugs (MPLBs) refers to the bugs whose resolution involves multiple PLs. Despite high complexity of MPLB resolution, there lacks MPLB prediction methods. Objective:This work aims to construct just-in-time (JIT) MPLB prediction models with selected prediction metrics, analyze the significance of the metrics, and then evaluate the performance of cross-project JIT MPLB prediction. Methods:We develop JIT MPLB prediction models with the selected metrics using machine learning algorithms and evaluate the models in within-project and cross-project contexts with our constructed dataset based on 18 Apache MPL projects. Results:Random Forest is appropriate for JIT MPLB prediction. Changed LOC of all files, added LOC of all files, and the total number of lines of all files of the project currently are the most crucial metrics in JIT MPLB prediction. The prediction models can be simplified using a few top-ranked metrics. Training on the dataset from multiple projects can yield significantly higherAUC than training on the dataset from a single project for cross-project JIT MPLB prediction. Conclusions:JIT MPLB prediction models can be constructed with the selected set of metrics, which can be reduced to build simplified JIT MPLB prediction models, and cross-project JIT MPLB prediction is feasible.

SGT: Aging-related bug prediction via semantic feature learning based on graph-transformer

Software aging, characterized by an increasing failure rate or performance decline in long-running software systems, poses significant risks including financial losses and potential harm to human life. This is primarily attributed to the accumulation of runtime errors, commonly referred to as aging-related bugs (ARBs). ARBP aims to detect and address ARBs before software release, optimizing testing resource allocation. However, ARBP’s effectiveness relies heavily on dataset quality. Prior research often relied on manually designed metrics that lack semantic features, resulting in low prediction accuracy. Some studies construct models to learn semantic features from source code, but typically focus on token-level features from abstract Syntax Trees, neglecting critical topological and functional connections. In this paper, we introduce the SGT model, an ARBP method based on Graph-Transformer. This model efficiently extracts semantic information and logical structures from source code, capturing data dependencies and program dependencies. We also propose sub-graph sampling based on node degree to reduce structural complexity and apply random oversampling to address class imbalance. Experiments on three projects demonstrate notable improvements. For instance, SGT achieved F1 scores of 0.726 and 0.706 on Linux and MySQL, respectively. Compared to ALW, SGT shows a 12.3% and 6.8% improvement on Linux and MySQL.

Predicting Software Defect Complexity and Accuracy using Bug Tracking and Clustering

Many open sources, free and commercial bug tracking tools have been developed and are currently under development. There are number of issues are related to software projects are daily increasing and the developers are started to use bug tracking systems in that order to manages the bug reports. The industry needs that the criteria to select the best system tool among the available set of system tools which will helps to fix and track the progressive report of bug fixes. While, collection of useful information from the large and not organized set of these reports is still difficult problem because there are various bug tracking systems are provide the data via many resources like web interfaces. We try to present these comprehensive classification criteria to manage the reviews for available tools and propose a new modified tool for the bug tracking and reporting system. It also helps in reporting the bugs which are founded by that process, assigning the bug to the developer for monitoring and fixing the progress of bug fixing by various graphical/charting facility and status updates. It also providing the reliability of bug prediction and tries to find the bugs for complexity measurements, and allows to distributing.

Various Approaches for Software vulnerability Assessment and Risk Identification using soft computing Techniques

The detection of software flaws is a viable technique for enhancing the quality of technology and testing management by providing rapid detection of deficiency simulation models until the actual testing phase starts. These prediction outcomes help designers of technology effectively devote their available resources to components that are more vulnerable to deficiencies. In this research investigation, a software bug prediction model is proposed using Deep Learning (DL) approach. The Recurrent Neural Network (RNN) is used for classification of source code including numerous soft computing techniques. Numerous preprocessing and data filtration techniques have been carried out for data balancing and normalization. The Term Frequency and Inverse Document Frequency (TF-IDF) and relation features extraction techniques is used to generate Vector Space Model (VSM). The classification has been done using RNN on both training and validation dataset. The evaluation of performance of proposed work is performed using various real-time and synthetic accessible databases. It is observed from the experimental results that the proposed framework performs better when different evaluated with different datasets

Development of optimised software fault prediction model using machine learning

Software fault prediction is a crucial task, especially with the rapid improvements in software technology and increasing complexity of software. As identifying and addressing bugs early in the development process can significantly minimize the costs and enhance the software quality. Software fault prediction using machine learning algorithms has gained significant attention due to its potential to improve software quality and save time in the testing phase. This research paper investigates the impact of classification models on bug prediction performance and explores the use of bio-inspired optimization techniques to enhance model results. Through experiments, it is demonstrated that applying bio-inspired algorithms improves the accuracy of fault prediction models. The evaluation is based on multiple performance metrics and the results show that KNN with BACO (Binary Ant Colony Optimization) generally outperform the other models in terms of accuracy. The BACO-KNN fault prediction model attains the accuracy of 96.39% surpassing the previous work.

Software Bug Prediction Using Machine Learning

Software bug prediction is a crucial aspect of software development and maintenance as it directly impacts the overall success of the software. By identifying potential bugs early on, software quality, reliability, and efficiency can be improved while also helping to reduce costs. Creating a reliable bug prediction model is a complex task, with various techniques proposed in the literature. In this paper, a bug prediction model utilizing machine learning algorithms is introduced. Three supervised machine learning algorithms have been incorporated to forecast future software faults using historical data. The evaluation process revealed that Machine Learning algorithms, specifically Naïve Bayes (NB), Decision Tree (DT), and Artificial Neural Networks (ANNs), can be effectively utilized with a high level of accuracy. Additionally, a comparison measure was implemented to assess the proposed prediction model against other methods. The findings indicated that the Machine Learning approach outperformed other techniques in terms of performance. Key Words: Bug Prediction, Reliability, Efficiency, Quality, Machine Learning, Performance Metrics

Cross-project concurrency bug prediction using domain-adversarial neural network

In recent years, software bug prediction has shown to be effective in narrowing down the potential bug modules and boosting the efficiency and precision of existing testing and analysis tools. However, due to its non-deterministic nature and low presence, concurrency bug labeling is a challenging task, which limits the implementation of within-project concurrency bug prediction. This paper proposes DACon, a Domain-Adversarial neural network-based cross-project Concurrency bug prediction approach to tackle this problem by leveraging information from another related project. By combining a set of designed concurrency code metrics with widely used sequential code metrics, DACon uses SMOTE (Synthetic Minority Over-sampling TEchnique) and domain-adversarial neural network to mitigate two challenges including the severe class imbalance between concurrency bug-prone samples and concurrency bug-free samples, and shift between source and target distribution during bug prediction implementation. Our evaluation on 20 pair-wise groups of experiments constructed from 5 real-world projects indicates that cross-project concurrency bug prediction is feasible, and DACon can effectively predict concurrency bugs across different projects.

Method-level Bug Prediction: Problems and Promises

Fixing software bugs can be colossally expensive, especially if they are discovered in the later phases of the software development life cycle. As such, bug prediction has been a classic problem for the research community. As of now, the Google Scholar site generates ∼113,000 hits if searched with the “bug prediction” phrase. Despite this staggering effort by the research community, bug prediction research is criticized for not being decisively adopted in practice. A significant problem of the existing research is the granularity level (i.e., class/file level) at which bug prediction is historically studied. Practitioners find it difficult and time-consuming to locate bugs at the class/file level granularity. Consequently, method-level bug prediction has become popular in the past decade. We ask, are these method-level bug prediction models ready for industry use? Unfortunately, the answer is no . The reported high accuracies of these models dwindle significantly if we evaluate them in different realistic time-sensitive contexts. It may seem hopeless at first, but, encouragingly, we show that future method-level bug prediction can be improved significantly. In general, we show how to reliably evaluate future method-level bug prediction models and how to improve them by focusing on four different improvement avenues: building noise-free bug data, addressing concept drift, selecting similar training projects, and developing a mixture of models. Our findings are based on three publicly available method-level bug datasets and a newly built bug dataset of 774,051 Java methods originating from 49 open-source software projects.

Feature importance feedback with Deep Q process in ensemble-based metaheuristic feature selection algorithms

Feature selection is an indispensable aspect of modern machine learning, especially for high-dimensional datasets where overfitting and computational inefficiencies are common concerns. Traditional methods often employ either filter, wrapper, or embedded approaches, which have limitations in terms of robustness, computational load, or capability to capture complex interactions among features. Despite the utility of metaheuristic algorithms like Particle Swarm Optimization (PSO), Firefly Algorithm (FA), and Whale Optimization (WOA) in feature selection, there still exists a gap in efficiently incorporating feature importance feedback into these processes. This paper presents a novel approach that integrates the strengths of PSO, FA, and WOA algorithms into an ensemble model and further enhances its performance by incorporating a Deep Q-Learning framework for relevance feedbacks. The Deep Q-Learning module intelligently updates feature importance based on model performance, thereby fine-tuning the selection process iteratively. Our ensemble model demonstrates substantial gains in effectiveness over traditional and individual metaheuristic approaches. Specifically, the proposed model achieved a 9.5% higher precision, an 8.5% higher accuracy, an 8.3% higher recall, a 4.9% higher AUC, and a 5.9% higher specificity across multiple software bug prediction datasets and samples. By resolving some of the key issues in existing feature selection methods and achieving superior performance metrics, this work paves the way for more robust and efficient machine learning models in various applications, from healthcare to natural language processing scenarios. This research provides an innovative framework for feature selection that promises not only superior performance but also offers a flexible architecture that can be adapted for a variety of machine learning challenges.

Development of Honey Badger-Cat Swarm Optimisation-Based Parallel Cascaded Deep Network for Software Bug Prediction Framework

Software bug prediction is mainly used for testing and code inspection. So, software bug prediction is carried out by network measures over the decades. But, the classical fault prediction method failed to obtain the semantic difference among various programs. Thus, it degrades the working of the prediction model, which is designed using these aspects. It is necessary to obtain the semantic difference for designing the prediction model accurately and effectively. In a software defect prediction system, it faces many difficulties in identifying the defect modules like correlation, irrelevance aspects, data redundancy, and missing samples or values. Consequently, many researchers are designed to detect software bug prediction that categorises faulty as well as non-faulty modules with software matrices. But, there are only a few works focussed to mitigate the class imbalance problem in bug prediction. In order to overcome the problem, it is required to develop an efficient software bug prediction method with the enhanced classifier. For this experimentation, the input data are taken from the standard online data sources. Initially, the input data undergo pre-processing phase and then, the pre-processed data are provided as input to the feature extraction by utilising the Auto-Encoder. These obtained features are utilised in getting the optimal fused features with the help of a new Hybrid Honey Badger Cat Swarm Algorithm (HHBCSA). Finally, these features are fed as input to the Optimised Parallel Cascaded Deep Network (OPCDP), where the “Extreme Learning Machine (ELM) and Deep Belief Network (DBN)” are used for the prediction of software bugs, in which the parameters from both classifiers are optimised by proposed HHBCSA algorithm. From the investigations, the recommended software bug prediction method offers a quicker bug prediction result, which helps to detect and remove the software bug easily and accurately.

The Effectiveness of Hidden Dependence Metrics in Bug Prediction

The Effectiveness of Hidden Dependence Metrics in Bug Prediction

Improved software fault prediction using new code metrics and machine learning algorithms

Many code metrics exist for bug prediction. However, these metrics are based on the trivial count of code properties and are not sufficient. This research article proposes three new code metrics based on class complexity, coupling, and cohesion to fill the gap. The Promise repository metrics suite's complexity, coupling, and cohesion metrics are replaced by the proposed metrics, and a new metric suite is generated. Experiments show that the proposed metrics suite gives more than 2 % improvement in AUC and precision and approximately 1.5 % in f1-score and recall with fewer code metrics than the existing metrics suite.

Machine Learning-Powered Identification of Source Code Vulnerabilities

These methods for identifying source code defects face limitations, including false positives and negatives, resource demands, and integration issues in modern software projects. This article explores cutting-edge research in using ML to enhance source code security. As ML gains traction in bug prediction, numerous studies investigate its potential. This research contributes to the growing interest in applying ML to source code, addressing the need for more efficient, accurate, and scalable defect detection methods. By leveraging ML techniques, software development processes can become more robust, reducing vulnerabilities and enhancing overall code quality.

Improving the accuracy of recurrent neural networks models in predicting software bug based on undersampling methods

<span>The process of identifying software bugs is of paramount importance as it ensures software reliability and facilitates maintenance activities. The quality improvement process of software relies heavily on software bug prediction (SBP). In SBP, the task of accurately identifying defective source code poses a significant challenge. Numerous of machine learning (ML) models has been developed specifically to address this challenge in SBP. Nonetheless, the class imbalance issue restricts the potential of these models to predict software bugs accurately. This issue poses a significant hindrance to the efficiency of these models, leading to imbalanced false-positive and false-negative outcomes. Previous studies have paid limited attention to addressing the challenge of class imbalance in SBP. This study aims to fill this research gap by employing a combination of two recurrent neural networks (RNNs), namely <a name="_Hlk141433135"></a>long-short-term memory (LSTM) and gated recurrent unit (GRU), along with an undersampling method (near miss) to effectively tackle this issue. Experiments have been conducted on publicly available benchmark datasets, considering both class-level and file-level metrics. The experimental results lead to the conclusion that our models outperform others and the combination of RNNs models with undersampling methods leads to improved bug prediction performance, particularly for datasets with imbalanced class distributions.</span>

Automatic software bug prediction using adaptive golden eagle optimizer with deep learning

In the software maintenance and development process, the software bug detection is an essential problem because it related with the complete software successes. So, the earlier software bug detection is essential to enhance the software efficiency, reliability, software quality and software cost. Moreover, the efficient software bug prediction is a critical as well as challenging operation. Hence, the efficient software bug prediction model is developed in this article. To achieve this objective, optimized long short-term memory is developed. The important stages of the proposed model is preprocessing, feature selection and bug detection. At first the input bug dataset is preprocessed. In preprocessing, the duplicate data instances are removed from the dataset. After the preprocessing, the feature selection is done by Adaptive Golden Eagle Optimizer (AGEO). Here the traditional GEO algorithm is altered by means of opposition-based learning (OBL). Finally, the proposed approach utilizes a long short-term memory (LSTM) based recurrent neural network (RNN) for bug prediction. Long Short-Term Memory (LSTM) network is a type of recurrent neural network. The promise and NASA dataset are considered as the input for bug prediction. the performance of proposed approach is analysed based on various metrics namely, accuracy, F- measure, G-measure and Matthews Correlation Coefficient (MCC).

Automatic Software Bug Prediction Using Adaptive Artificial Jelly Optimization With Long Short-Term Memory

AbstractIn the software maintenance and development process, software bug detection is an essential problem because it is related to complete software success. It is recommended to begin anticipating defects at the early stages of creation rather than during the assessment process due to the high expense of fixing the found bugs. The early stage software bug detection is used to enhance software efficiency, reliability, and software quality. Nevertheless, creating a reliable bug-forecasting system is a difficult challenge. Therefore, in this paper, an efficient, software bug forecast is developed. The presented technique consists of three stages namely, pre-processing, feature selection, and bug prediction. At first, the input datasets are pre-processed to eliminate the identical data from the dataset. After the pre-processing, the important features are selected using an adaptive artificial jelly optimization algorithm (A2JO) to eliminate the possibility of overfitting and reduce the complexity. Finally, the selected features are given to the long short-term memory (LSTM) classifier to predict whether the given data is defective or non-defective. In this paper, investigations are shown on visibly obtainable bug prediction datasets namely, promise and NASA which is a repository for most open-source software. The efficiency of the presented approach is discussed based on various metrics namely, accuracy, F- measure, G-measure, and Matthews Correlation Coefficient (MCC). The experimental result shows our proposed method achieved the extreme accuracy of 93.41% for the Promise dataset and 92.8% for the NASA dataset.

BERT- and TF-IDF-based feature extraction for long-lived bug prediction in FLOSS: A comparative study

BERT- and TF-IDF-based feature extraction for long-lived bug prediction in FLOSS: A comparative study