Software defects are a critical issue in software development that can lead to system failures and cause significant financial losses. Predicting software defects is a vital aspect of ensuring software quality. This can significantly impact both saving time and reducing the overall cost of software testing. During the software defect prediction (SDP) process, automated tools attempt to predict defects in the source codes based on software metrics. Several SDP models have been proposed to identify and prevent defects before they occur. In recent years, recurrent neural network (RNN) techniques have gained attention for their ability to handle sequential data and learn complex patterns. Still, these techniques are not always suitable for predicting software defects due to the problem of imbalanced data. To deal with this problem, this study aims to combine a bidirectional long short-term memory (Bi-LSTM) network with oversampling techniques. To establish the effectiveness and efficiency of the proposed model, the experiments have been conducted on benchmark datasets obtained from the PROMISE repository. The experimental results have been compared and evaluated in terms of accuracy, precision, recall, f-measure, Matthew’s correlation coefficient (MCC), the area under the ROC curve (AUC), the area under the precision-recall curve (AUCPR) and mean square error (MSE). The average accuracy of the proposed model on the original and balanced datasets (using random oversampling and SMOTE) was 88%, 94%, And 92%, respectively. The results showed that the proposed Bi-LSTM on the balanced datasets (using random oversampling and SMOTE) improves the average accuracy by 6 and 4% compared to the original datasets. The average F-measure of the proposed model on the original and balanced datasets (using random oversampling and SMOTE) were 51%, 94%, And 92%, respectively. The results showed that the proposed Bi-LSTM on the balanced datasets (using random oversampling and SMOTE) improves the average F-measure by 43 and 41% compared to the original datasets. The experimental results demonstrated that combining the Bi-LSTM network with oversampling techniques positively affects defect prediction performance in datasets with imbalanced class distributions.

Software defect prediction (SDP) plays a vital role in enhancing the quality of software projects and reducing maintenance-based risks through the ability to detect defective software components. SDP refers to using historical defect data to construct a relationship between software metrics and defects via diverse methodologies. Several prediction models, such as machine learning (ML) and deep learning (DL), have been developed and adopted to recognize software module defects, and many methodologies and frameworks have been presented. Class imbalance is one of the most challenging problems these models face in binary classification. However, When the distribution of classes is imbalanced, the accuracy may be high, but the models cannot recognize data instances in the minority class, leading to weak classifications. So far, little research has been done in the previous studies that address the problem of class imbalance in SDP. In this study, the data sampling method is introduced to address the class imbalance problem and improve the performance of ML models in SDP. The proposed approach is based on a convolutional neural network (CNN) and gated recurrent unit (GRU) combined with a synthetic minority oversampling technique plus the Tomek link (SMOTE Tomek) to predict software defects. To establish the efficiency of the proposed models, the experiments have been conducted on benchmark datasets obtained from the PROMISE repository. The experimental results have been compared and evaluated in terms of accuracy, precision, recall, F-measure, Matthew’s correlation coefficient (MCC), the area under the ROC curve (AUC), the area under the precision-recall curve (AUCPR), and mean square error (MSE). The experimental results showed that the proposed models predict the software defects more effectively on the balanced datasets than the original datasets, with an improvement of up to 19% for the CNN model and 24% for the GRU model in terms of AUC. We compared our proposed approach with existing SDP approaches based on several standard performance measures. The comparison results demonstrated that the proposed approach significantly outperforms existing state-of-the-art SDP approaches on most datasets.

In this study, we present the application of a novel capillary electrophoresis (CE) method in combination with label-free quantitation and support vector machine-based feature selection (support vector machine-estimated recursive feature elimination or SVM-RFE) to identify potential glycan alterations in Parkinson’s disease. Specific focus was placed on the use of neutral coated capillaries, by a dynamic capillary coating strategy, to ensure stable and repeatable separations without the need of non-mass spectrometry (MS) friendly additives within the separation electrolyte. The developed online dynamic coating strategy was applied to identify serum N-glycosylation by CE-MS/MS in combination with exoglycosidase sequencing. The annotated structures were quantified in 15 controls and 15 Parkinson’s disease patients by label-free quantitation. Lower sialylation and increased fucosylation were found in Parkinson’s disease patients on tri-antennary glycans with 2 and 3 terminal sialic acids. The set of potential glycan alterations was narrowed by a recursive feature elimination algorithm resulting in the efficient classification of male patients.

Code smells indicate potential symptoms or problems in software due to inefficient design or incomplete implementation. These problems can affect software quality in the long-term. Code smell detection is fundamental to improving software quality and maintainability, reducing software failure risk, and helping to refactor the code. Previous works have applied several prediction methods for code smell detection. However, many of them show that machine learning (ML) and deep learning (DL) techniques are not always suitable for code smell detection due to the problem of imbalanced data. So, data imbalance is the main challenge for ML and DL techniques in detecting code smells. To overcome these challenges, this study aims to present a method for detecting code smell based on DL algorithms (Bidirectional Long Short-Term Memory (Bi-LSTM) and Gated Recurrent Unit (GRU)) combined with data balancing techniques (random oversampling and Tomek links) to mitigate data imbalance issue. To establish the effectiveness of the proposed models, the experiments were conducted on four code smells datasets (God class, data Class, feature envy, and long method) extracted from 74 open-source systems. We compare and evaluate the performance of the models according to seven different performance measures accuracy, precision, recall, f-measure, Matthew’s correlation coefficient (MCC), the area under a receiver operating characteristic curve (AUC), the area under the precision–recall curve (AUCPR) and mean square error (MSE). After comparing the results obtained by the proposed models on the original and balanced data sets, we found out that the best accuracy of 98% was obtained for the Long method by using both models (Bi-LSTM and GRU) on the original datasets, the best accuracy of 100% was obtained for the long method by using both models (Bi-LSTM and GRU) on the balanced datasets (using random oversampling), and the best accuracy 99% was obtained for the long method by using Bi-LSTM model and 99% was obtained for the data class and Feature envy by using GRU model on the balanced datasets (using Tomek links). The results indicate that the use of data balancing techniques had a positive effect on the predictive accuracy of the models presented. The results show that the proposed models can detect the code smells more accurately and effectively.

Software bug prediction (SBP) involves identifying or categorizing software modules likely to contain defects, utilizing underlying system properties such as software metrics. SBP plays a crucial role in enhancing software project quality and mitigating maintenance risks. Numerous machine learning (ML) algorithms have been developed to predict software bugs. Class imbalance poses a significant challenge for these algorithms, significantly impeding their effectiveness and resulting in imbalanced false-positive and false-negative outcomes. However, limited research has been conducted to specifically tackle the issue of class imbalance in the context of SBP. This study investigates the prediction performance of a homogeneous ensemble: Bagging, boosting, and voting classifiers (VC) methods combined with the under-sampling methods to address the class imbalance problem and improve the accuracy of SBP. Two ensembles are classified as bagging ensembles: decision tree (DT) and random forest (RF); two ensembles are classified as boosting ensembles: AdaBoost (AB) and gradient boosting (GB), while the DT, RF, K-Nearest Neighbours (K-NN), and support vector machine (SVM) are considered as VC. To establish the effectiveness of the proposed models, the experiments were conducted on the available benchmark datasets, which comprise five public datasets based on both class and file-level metrics. We compared and evaluated the performance of the proposed models according to several performance measures, namely accuracy, precision, recall, f-measure, Matthew’s correlation coefficient (MCC), and the area under the receiver operating characteristic curve (AUROC). The experimental findings demonstrated that the proposed models exhibit superior efficiency in predicting software bugs on balanced datasets compared to the original datasets, with an improvement of up to 11% accuracy for the class-level metrics and 10% for the file-level metrics. The results indicate that the use of data sampling techniques had a positive impact on the prediction accuracy of the presented models. We compared our proposed method with existing SBP methods based on several standard performance measures. The comparison outcomes revealed a significant superiority of our method over the prevailing state-of-the-art SBP methods across most datasets.

Code smells refers to any symptoms or anomalies in the source code that shows violation of design principles or implementation. Early detection of bad code smells improves software quality. Nowadays several artificial neural network (ANN) models have been used for different topics in software engineering: software defect prediction, software vulnerability detection, and code clone detection. It is not necessary to know the source of the data when using ANN models but require large training sets. Data imbalance is the main challenge of artificial intelligence techniques in detecting the code smells. To overcome these challenges, the objective of this study is to presents deep convolutional neural network (D-CNN) model with synthetic minority over-sampling technique (SMOTE) to detect bad code smells based on a set of Java projects. We considered four code-smell datasets which are God class, data class, feature envy and long method and the results were compared based on different performance measures. Experimental results show that the proposed model with oversampling techniques can provide better performance for code smells detection and prediction results can be further improved when the model is trained with more datasets. Moreover, more epochs and hidden layers help increase the accuracy of the model.