Accurate classification and prediction, especially in critical software engineering tasks like software refactoring, often face significant challenges due to the messy nature of real-world data: high dimensionality, irrelevant noise, and wildly imbalanced categories. This study introduces a robust and practical framework designed to mitigate these issues. We thoroughly examine how advanced feature selection methodologies, including statistical tests, correlation filters, and Principal Component Analysis (PCA), synergize with the Synthetic Minority Over-sampling Technique (SMOTE) for data balancing. Our approach involves systematically applying these preprocessing steps to 30 distinct real-world datasets, followed by evaluation with different and diverse machine learning models. Our findings are clear: SMOTE consistently and significantly boosts the reliability and performance of our models, particularly in identifying crucial minority cases, which is vital for effective refactoring prediction. Moreover, intelligent feature selection proves instrumental in optimizing performance, frequently leading to simpler models without compromising accuracy. Ultimately, Random Forest, Support Vector Machines, and Neural Networks emerged as the consistent top-performing machine learning models. This research offers practical, empirically proven strategies for building highly accurate, efficient, and stable predictive models, essential for modern software engineering and refactoring efforts.

Refactoring prediction plays a crucial role in software maintenance by identifying structural improvements in code without altering external behavior. However, class imbalance and the inherent complexity of real-world codebases pose significant challenges for traditional detection approaches. In this study, we present a multi-view stacking-based framework that integrates structural features from object-oriented (CK) metrics with semantic representations derived from CodeBERT embeddings. To address data imbalance, SMOTE is applied exclusively to the combined feature representation. Each feature modality is processed by dedicated base classifiers, and their outputs are aggregated via a meta-learner in a stacking ensemble. The proposed method is evaluated on two open-source Java projects-ANTLR4 and Titan-using 22 diverse classifiers within a stacking pipeline. Results show that combining inputs with SMOTE significantly improves classification performance. For example, LightGBM and Extra Trees achieved AUC scores of 0.92 and 0.91, respectively, on ANTLR4, while Gradient Boosting and LightGBM exceeded 0.90 AUC on Titan. The stacking approach consistently outperformed single-view baselines, with notable improvements in F1-score (up to$\mathbf{1 5 \%}$) and F-measure (over 12%) across configurations. These findings validate the effectiveness of multi-view stacking with class balancing for robust and scalable refactoring prediction.

In recent times, software developers widely use instant messaging and collaboration platforms, as these platforms aid them in exploring new technologies, raising different development-related issues, and seeking solutions from their peers virtually.Gitter is one such platform that has a heavy userbase.It generates a tremendous volume of data, analysis of which is helpful to gain insights about trends in open-source software development and the developers' inclination toward various technologies.Analyzing these trends helps these platforms better cater to the needs of the developers, in turn increasing the usage of these platforms and promoting collaborations between more developers.The classification techniques can be deployed for this purpose.The selection of an apt word embedding for a given dataset of text messages plays a vital role in determining the performance of classification techniques.In the present work, the comparative analysis of nine-word embeddings in combination with seventeen classification techniques with onevsone and onevsrest has been performed on the GitterCom dataset for categorizing text messages into one of the pre-determined classes based on their purpose.Further, two feature selection methods have been applied.The SMOTE technique has been used for handling data imbalance.It resulted in a total of 1836 classification pipelines for analysis.The objective is to analyze their performances to recommend efficient pipelines for the classification task at hand.The experimental results show that word2vect, GLOVE with 300 vector size, and GLOVE with 100 vector size are three topperforming word embeddings having performance values taken across different classification techniques.The models trained using ANOVA features performed similarly to those models trained using all features.Finally, using the SMOTE technique helps models to get a better prediction ability.

Context: The application of Software Fault Prediction (SFP) in the software development life cycle to predict the faulty class at the early stage has piqued the interest of various scholars. In the SFP domain, during research analysis, it got realized that there has been very little work instigated on addressing both class imbalance and feature redundancy problems jointly to enhance the performance and prediction accuracy of SFP models. It has been perceived in the literature survey the study of droughts with the comprehensive comparative analysis of different sampling and feature selection strategies together. Objective: This research builds an extensive assessment of distinct combinations of different feature selection and sampling approaches, to effectively overcome the problems of class overlap, class imbalance , and feature redundancy. The objective is to determine the best combination that will produce results with a higher degree of accuracy and an effective SFP model. Method: Considering the above erudition, the study has applied 8 different sampling techniques along with 10 feature selection algorithms against 56 open-source projects. The comparative analysis is performed against 5346 variants of input datasets by applying 8 different classifiers to predict the faulty class. In addition, the research paper presents an intensive assessment and performance of these techniques individually against all the input projects. We have considered accuracy and Area Under the ROC (receiver operating characteristic curve) Curve (AUC) performance metrics to compare the performance of different models developed using the classification algorithm . Result: For each project in the proposed work, we evaluated a total of 792 combinations that were produced using 10 feature selection methods, 1 all metrics dataset, 8 sampling methods, 1 original, unsampled dataset, and 8 classifiers. The empirical result indicates that, against 21 projects out of 54 projects, Synthetic Minority Over Sampling Technique Edited (SMOTEE) with correlation-based feature selection (FS2) combination outperformed with the highest AUC value which is 38.89 % of projects. Additionally, according to experimental results, the highest AUC values were attained by 24.07 % of projects using the SMOTEE, FS2, and RF combination. Conclusion: The results of the statical analysis test reveal that 93.42 % of the combinational pairs of different sampling and feature selection approaches demonstrated a significant variance in the performance of the distinct combinations of sampling and feature selection techniques. The empirical result indicates the performance of the SFP Model is adversely impacted by class imbalance and irrelevance. The outcome indicates for more than 75% of projects, the performance of trained models improved with an AUC value between a range of 0.805 to 0.99 post-application of sampling and feature selection strategies, in comparison without the use of feature selection and sampling techniques.

Sentiment Analysis in the Software Engineering community aims to make the development and maintenance of software a better experience by helping provide code and library suggestions, defect-related comments for source code, etc.The manual finding of sentiment-based comments may be an inaccurate prediction and a time-consuming process.Automating the sentiment analysis process by leveraging Machine Learning models can benefit software professionals by giving them insights into other developers and feelings about software products, libraries, development, and maintenance tasks at a glance.This study aims to develop software sentiment prediction models based on comments by (1) identifying the best embedding techniques to represent the word of the comments, not just as a number but as a vector in n-dimensional space (2) finding the best sets of vectors using different features selection techniques (3) finding the best methods to handle the class imbalance nature of the data, and (4) finding the best architecture of deep-learning for the training of models.The developed models are validated using 5fold cross-validation with four different performance parameters: accuracy, AUC, recall, and precision on three different datasets.The experimental finding shows that the models developed using the word embeddings with feature selection using Deep Learning classifiers on balanced data can significantly predict the underlying sentiments of textual comments.

Software requirement classification is becoming increasingly crucial for the industry to keep up with the demand of growing project sizes.Based on client feedback or demand, software requirement classification is critical in segregating user needs into functional and quality requirements.However, because there are numerous machine learning (ML) and deep-learning (DL) models that require parameter tuning, the use of ML to facilitate decision-making across the software engineering pipeline is not well understood.Five distinct word embedding techniques were applied to the functional and quality software requirements in this study.The imbalanced classes in the dataset are balanced using Synthetic Minority Oversampling technique (SMOTE).Then, to reduce duplicate and unnecessary features, feature selection and dimensionality reduction techniques are used.Dimensionality reduction is accomplished with Principal Component Analysis (PCA), while feature selection is accomplished with the Rank-Sum Test (RST).For binary categorization into functional and non-functional needs, the generated vectors are provided as inputs to eight distinct Deep Learning classifiers.The findings of the research show that using a combination of word embedding and feature selection techniques in conjunction with various classifiers can accurately classify functional and quality software requirements.

Bug tracking is one of the prominent activities during the maintenance phase of software development. The severity of the bug acts as a key indicator of its criticality and impact towards planning evolution and maintenance of various types of software products. This indicator measures how negatively the bug may affect the system functionality. This helps in determining how quickly the development teams need to address the bug for successful execution of the software system. Due to a large number of bugs reported every day, the developers find it really difficult to assign the severity level to bugs accurately. Assigning incorrect severity level results in delaying the bug resolution process. Thus automated systems were developed which will assign a severity level using various machine learning techniques. In this work, five different types of sentence embedding techniques have been applied on bugs description to convert the description comments to an n-dimensional vector. These computed vectors are used as an input of the software defect severity level prediction models and ensemble techniques like Bagging, Random Forest classifier, Extra Trees classifier, AdaBoost and Gradient Boosting have been used to train these models. We have also considered different variants of the Synthetic Minority Oversampling Technique (SMOTE) to handle the class imbalance problem as the considered datasets are not evenly distributed. The experimental results on six projects highlight that the usage of sentence embedding, ensemble techniques, and different variants of SMOTE techniques helps in improving the predictive ability of defect severity level prediction models.

Software defect severity level helps to indicate the impact of bugs on the execution of the software and how rapidly these bugs need to be addressed by the team.The working team is regularly analyzing the bugs report and prioritizing the defects.The manual prioritization of these defects based on the experience may be an inaccurate prediction of the severity that will delay in fixing of critical bugs.It is compulsory to automate the process of assigning an appropriate level of severity based on bug report results with an objective to fix critical bugs without any delay.This work aims to develop defect severity level prediction models that have the ability to assign severity level of defects based on bugs report.In this work, seven different word embedding techniques are applied to defect description to represent the word, not just as a number but as a vector in n-dimensional space in order to reduce the number of features.Since the predictive ability of the developed models depends on the vectors extracted from text as they are used as an input to the defect severity level prediction models.Further, three feature selection techniques have been applied to find the right set of relevant vectors.The effectiveness of these word embedding techniques and different sets of vectors are evaluated using eleven different classification techniques with Synthetic Minority Oversampling Technique (SMOTE) to overcome the class imbalance problem.The experimental results show that the word embedding, feature selection techniques and SMOTE have the ability to predict the severity level of the defect in a software.

Android OS being the popular choice of majority users also faces the constant risk of breach of confidentiality, integrity and availability (CIA). Effective mitigation efforts needs to identified in order to protect and uphold the CIA triad model, within the android ecosystem. In this paper, we propose a novel method of android malware classification using Object-Oriented Software Metrics and machine learning algorithms. First, android apps are decompiled and Object-Oriented Metrics are obtained. VirusTotal service is used to tag an app either as malware or benign. Object-Oriented Metrics and malware tag are clubbed together into a dataset. Eighty different machine-learned models are trained over five thousand seven hundred and seventy four android apps. We evaluate the performance and stability of these models using it's malware classification accuracy and AUC (area under ROC curve) values. Our method yields an accuracy and AUC of 99.83% and 1.0 respectively.

Web Services are application components characterised by interoperability, extensibility, distributed application development and service oriented architecture. A complex distributed application can be developed by combing several third-party web-services. Anti-patterns are counter-productive and poor design and practices. Web-services suffer from a multitude of anti-patterns such as God object Web service and Fine grained Web service. Our work is motivated by the need to build techniques for automatically detecting common web-services anti-patterns by static analysis of the source code implementing a web-service. Our approach is based on the premise that summary values of object oriented source code metrics computed at a web-service level can be used as a predictor for anti-patterns. We present an empirical analysis of 4 data sampling techniques to encounter the class imbalance problem, 5 feature ranking techniques to identify the most informative and relevant features and 8 machine learning algorithms for predicting 5 different types of anti-patterns on 226 real-world web-services across several domains. We conclude that it is possible to predict anti-patterns using source code metrics and a machine learning framework. Our analysis reveals that the best performing classification algorithm is Random Forest, best performing data sampling technique is SMOTE and the best performing feature ranking method is OneR.

Timely identification of bugs plays an important role in delivering quality software.Defect prediction models help to detect or rank the defect prone files so that the project management team can allocate resources diligently or may seek help from external sources to enable rigorous quality assurance activities on defect prone files.Though defect prediction models have been built using several machine learning algorithms, Bayesian approach of these models is not explored.We propose Bayesian logistic regression with non-informative and informative priors to build defect prediction models.We seek to study if there are any advantages of using Bayesian logistic regression over logistic regression and the role of priors in the performance of Bayesian logistic regression.A comparative study of the performance of Bayesian logistic regression with other widely known classifies is also presented.

System analysts often use software fault prediction models to identify fault-prone modules during the design phase of the software development life cycle. The models help predict faulty modules based on the software metrics that are input to the models. In this study, we consider 20 types of metrics to develop a model using an extreme learning machine associated with various kernel methods. We evaluate the effectiveness of the mode using a proposed framework based on the cost and efficiency in the testing phases. The evaluation process is carried out by considering case studies for 30 object-oriented software systems. Experimental results demonstrate that the application of a fault prediction model is suitable for projects with the percentage of faulty classes below a certain threshold, which depends on the efficiency of fault identification (low: 47.28%; median: 39.24%; high: 25.72%). We consider nine feature selection techniques to remove the irrelevant metrics and to select the best set of source code metrics for fault prediction.

Source code refactoring consisting of modifying the structure of the source code without changing its functionality and external behavior. We present a method to predict refactoring candidates at class level which can help developers in improving their design and structure of source code while preserving the behavior. We propose a technique to predict refactoring candidates based on the application of a machine learning based framework. We use Least Squares Support Vector Machines (LS-SVM) as the learning algorithm, Principal Component Analysis (PCA) as a feature extraction technique and Synthetic Minority Over-sampling Technique (SMOTE) as a technique for handling imbalanced data. We start with 102 source code metrics as input features which are then reduced to 31 features after removing irrelevant and redundant features through statistical tests. We conduct a series of experiments on publicly available software engineering dataset consisting of seven open-source software systems in which the refactored classes are manually validated. We apply LS-SVM with three different functions: linear, polynomial and Radial Basis Function (RBF). Statistical significance test demonstrate that RBF kernel outperforms linear and polynomial kernel but there is no statistically significant difference between the performance of linear and polynomial kernel. Statistical significance test reveals that with-SMOTE technique outperforms without-SMOTE and all metrics outperforms PCA based metrics. The mean value of Area Under Curve (AUC) for LS-SVM RBF kernel is 0.96.

Software fault prediction models are employed to optimize testing resource allocation by identifying fault-prone classes before testing phases. We apply three different ensemble methods to develop a model for predicting fault proneness. We propose a framework to validate the source code metrics and select the right set of metrics with the objective to improve the performance of the fault prediction model. The fault prediction models are then validated using a cost evaluation framework. We conduct a series of experiments on 45 open source project dataset. Key conclusions from our experiments are: (1) Majority Voting Ensemble (MVE) methods outperformed other methods (2) selected set of source code metrics using the suggested source code metrics using validation framework as the input achieves better results compared to all other metrics (3) fault prediction method is effective for software projects with a percentage of faulty classes lower than the threshold value (low - 54.82%, medium - 41.04%, high - 28.10%).

We conduct a bibliometric and scientific publication mining based study to understand how the APSEC conference has evolved over the recent past 6 years (year 2010 to 2015). Our objective is to perform an in-depth examination of the state of APSEC so that the APSEC community can identify strengths, areas of improvements and future directions for the conference. Our empirical analysis is based on various perspectives such as: paper submission acceptance rate trends, scholarly productivity and contributions from various countries, identification of prolific authors, computation of citation impact of papers and contributing authors, internal and external collaboration, university and industry participation and collaboration, measurement of gender imbalance, yearly author churn and program committee characteristics.

The need to chose a suitable web service in the present scenario, due to the high growth in number of web services that provide similar types of functionalities is a critical task. To select a suitable web service, quality of service (QoS) parameters are efficient to use. In this paper, nine parameters of QoS have been considered as input for design a model using multivariate adaptive regression splines (MARS) to select suitable web service. The performance parameters of MARS model are evaluated and compared with those obtained using models such as: Multivariate Linear Regression, Multivariate Polynomial Regression, Naives Bayes Classifier, Artificial Neural Network. It is observed that the proposed model designed using MARS technique achieved better results as compared to the other three techniques. This paper also focuses on the effectiveness of feature selection techniques to find a small subset of QoS parameters. These may be able to classify the web services with higher accuracy and also reduced the value of misclassification errors.