Defect Prone Research Articles

A cognitive and neural network approach for software defect prediction

Software defect prediction is used to assist developers in finding potential defects and allocating their testing efforts as the scale of software grows. Traditional software defect prediction methods primarily concentrate on creating static code metrics that are fed into machine learning classifiers to predict defects in the code. To achieve the desired classifier performance, appropriate design decisions are required for deep neural network (DNN) and convolutional neural network (CNN) models. This is especially important when predicting software module fault proneness. When correctly identified, this could help to reduce testing costs by concentrating efforts on the modules that have been identified as fault prone. This paper proposes a CONVSDP and DNNSDP (cognitive and neural network) approach for predicting software defects. Python Programming Language with Keras and TensorFlow was used as the framework. From three NASA system datasets (CM1, KC3, and PC1) selected from PROMISE repository, a comparative analysis with machine learning algorithms (such as Random Forest (RF), Decision Trees (DT), Nave Bayes (NF), and Support Vector Machine (SVM) in terms of F-Measure (known as F1-score), Recall, Precision, Accuracy, Receiver Operating Characteristics (ROC) and Area Under Curve (AUC) has been presented. We extract four dataset attributes from the original datasets and use them to estimate the development effort, development time, and number of errors. The number of operands, operators, branch count, and executable LOCs are among these attributes. Furthermore, a new parameter called cognitive weight (Wc) of Basic Control Structure (BCS) is proposed to make the proposed cognitive technique more effective, and a cognitive data set of 8 features for NASA system datasets (CM1, KC3, and PC1) selected from the PROMISE repository to predict software defects is created. The experimental results showed that the CONVSDP and DNNSDP models was comparable to existing classifiers in both original datasets and cognitive data sets, and that it outperformed them in most of the experiments.

Impact of Parameter Tuning for Optimizing Deep Neural Network Models for Predicting Software Faults

Deep neural network models built by the appropriate design decisions are crucial to obtain the desired classifier performance. This is especially desired when predicting fault proneness of software modules. When correctly identified, this could help in reducing the testing cost by directing the efforts more towards the modules identified to be fault prone. To be able to build an efficient deep neural network model, it is important that the parameters such as number of hidden layers, number of nodes in each layer, and training details such as learning rate and regularization methods be investigated in detail. The objective of this paper is to show the importance of hyperparameter tuning in developing efficient deep neural network models for predicting fault proneness of software modules and to compare the results with other machine learning algorithms. It is shown that the proposed model outperforms the other algorithms in most cases.

CSSG: A cost‐sensitive stacked generalization approach for software defect prediction

SummaryThe prediction of software artifacts on defect‐prone (DP) or non‐defect‐prone (NDP) classes during the testing phase helps minimize software business costs, which is a classification task in software defect prediction (SDP) field. Machine learning methods are helpful for the task, although they face the challenge of data imbalance distribution. The challenge leads to serious misclassification of artifacts, which will disrupt the predictor's performance. The previously developed stacking ensemble methods do not consider the cost issue to handle the class imbalance problem (CIP) over the training dataset in the SDP field. To bridge this research gap, in the cost‐sensitive stacked generalization (CSSG) approach, we try to combine the staking ensemble learning method with cost‐sensitive learning (CSL) since the CSL purpose is to reduce misclassification costs. In the cost‐sensitive stacked generalization (CSSG) approach, logistic regression (LR) and extremely randomized trees classifiers in cases of CSL and cost‐insensitive are used as a final classifier of stacking scheme. To evaluate the performance of CSSG, we use six performance measures. Several experiments are carried out to compare the CSSG with some cost‐sensitive ensemble methods on 15 benchmark datasets with different imbalance levels. The results indicate that the CSSG can be an effective solution to the CIP than other compared methods.

Prediction of Defect Prone Software Modules using MLP based Ensemble Techniques

Prediction of Defect Prone Software Modules using MLP based Ensemble Techniques

A Mahalanobis distance based algorithm for assigning rank to the predicted fault prone software modules

This article proposes a methodology based on Artificial Neural Network(ANN) and type-2 fuzzy logic system (FLS) for detecting the fault prone software modules at early development phase. The present research concentrates on software metrics from requirement analysis and design phase of software life cycle. A new approach has been developed to sort out degree of fault proneness (DFP) of the software modules through type-2 FLS. ANN is used to prepare the rule base for inference engine. Furthermore, the proposed model has induced an order relation among the fault prone modules (FPMs) with the help of Mahalanobis distance (MD) metric. During software development process, a project manager needs to recognize the fault prone software modules with their DFP. Hence, the present study is of great importance to the project personnel to develop more cost-effective and reliable software. KC2 dataset of NASA has been applied for validating the model. Performance analysis clearly indicates the better prediction capability of the proposed model compared to some existing similar models.

Comparative Analysis of Selected Heterogeneous Classifiers for Software Defects Prediction Using Filter-Based Feature Selection Methods

Classification techniques is a popular approach to predict software defects and it involves categorizing modules, which is represented by a set of metrics or code attributes into fault prone (FP) and non-fault prone (NFP) by means of a classification model. Nevertheless, there is existence of low quality, unreliable, redundant and noisy data which negatively affect the process of observing knowledge and useful pattern. Therefore, researchers need to retrieve relevant data from huge records using feature selection methods. Feature selection is the process of identifying the most relevant attributes and removing the redundant and irrelevant attributes. In this study, the researchers investigated the effect of filter feature selection on classification techniques in software defects prediction. Ten publicly available datasets of NASA and Metric Data Program software repository were used. The topmost discriminatory attributes of the dataset were evaluated using Principal Component Analysis (PCA), CFS and FilterSubsetEval. The datasets were classified by the selected classifiers which were carefully selected based on heterogeneity. Naïve Bayes was selected from Bayes category Classifier, KNN was selected from Instance Based Learner category, J48 Decision Tree from Trees Function classifier and Multilayer perceptron was selected from the neural network classifiers. The experimental results revealed that the application of feature selection to datasets before classification in software defects prediction is better and should be encouraged and Multilayer perceptron with FilterSubsetEval had the best accuracy. It can be concluded that feature selection methods are capable of improving the performance of learning algorithms in software defects prediction.

Investigating the Effect of Sensitivity and Severity Analysis on Fault Proneness in Open Source Software

Fault prone components in open source software leads to huge loss and inadvertent effects if not properly identified and rigorously tested. Most of the reported studies in the literature have applied design metrics alone, to identify such critical components. But in reality, some of the components' criticality level can be identified only by means of dynamic code analysis; as some of the components seem to be normal but still have higher level of impact on the other components. This leads to an insight on the need of a rigorous analysis based on how sensitive a component is and how severe will be the impact of it on other components in the system. To achieve this, an efficient mechanism of evaluating the criticality index of each component by means of sensitivity and severity analysis using the static design metrics and dynamic source code metrics has been proposed. Then, testing is conducted rigorously on these components using both unit testing and pair-wise integration testing.

Machine Learning Based Approach for Predicting Fault in Software Engineering by GMFPA: A Survey

Fault propensity of software is the prospect that the component contains faults. To forecast fault proneness of modules different techniques have been proposed which includes statistical methods, machine learning techniques, etc. Machine learning techniques can be used to analyze data from different perspectives and enable developers to retrieve useful information. Machine learning techniques are proven to be useful in terms of software bug prediction. This is leading to increase in development of machine learning methods for exploring data sets, which can be used in constructing models for predicting quality attributes such as fault proneness. This research work analyzed various fault prediction techniques and proposed a new algorithm GMFPA (Genetic Metric Fault Prediction Algorithm) to explore the fault prone modules by using metrics. The GMFPA is used to identify fault with highest gain value by forming the hypothesis set.

Fragile base-class problem, problem?

The fragile base-class problem (FBCP) has been described in the literature as a consequence of “misusing” inheritance and composition in object-oriented programming when (re)using frameworks. Many research works have focused on preventing the FBCP by proposing alternative mechanisms for reuse, but, to the best of our knowledge, there is no previous research work studying the prevalence and impact of the FBCP in real-world software systems. The goal of our work is thus twofold: (1) assess, in different systems, the prevalence of micro-architectures, called FBCS, that could lead to two aspects of the FBCP, (2) investigate the relation between the detected occurrences and the quality of the systems in terms of change and fault proneness, and (3) assess whether there exist bugs in these systems that are related to the FBCP. We therefore perform a quantitative and a qualitative study. Quantitatively, we analyse multiple versions of seven different open-source systems that use 58 different frameworks, resulting in 301 configurations. We detect in these systems 112,263 FBCS occurrences and we analyse whether classes playing the role of sub-classes in FBCS occurrences are more change and–or fault prone than other classes. Results show that classes participating in the analysed FBCS are neither more likely to change nor more likely to have faults. Qualitatively, we conduct a survey to confirm/infirm that some bugs are related to the FBCP. The survey involves 41 participants that analyse a total of 104 bugs of three open-source systems. Results indicate that none of the analysed bugs is related to the FBCP. Thus, despite large, rigorous quantitative and qualitative studies, we must conclude that the two aspects of the FBCP that we analyse may not be as problematic in terms of change and fault-proneness as previously thought in the literature. We propose reasons why the FBCP may not be so prevalent in the analysed systems and in other systems in general.

Special section: software quality for mobile apps

Mobile phones are no longer simply a means of communication, but have gradually become supporting devices for day-to-day tasks. It is predicted that by 2020 all software will be developed for mobile devices, and this implies it is necessary to explore the issues involved in the design, development, and deployment of mobile applications. We accepted two papers for publication in this special section in response to an open call for papers exploring the challenges and opportunities presented by incorporating human aspects in mobile app engineering. Mark Syer, Meiyappan Nagappan, Bram Adams, and Ahmed Hassan explore the relationships between platform dependencies and the defect proneness of Android apps in the paper ‘‘Studying the relationship between source code quality and mobile platform dependence’’. The results of this work show that source code files that are defect prone have a higher dependence on the platform they are developed on. Moreover, an increase in the platform dependence leads to an increase in the likelihood of a defect being present in the source code. Bernhard Peischl, Michaela Ferk, and Andreas Holzinger report on a user-centred development approach to medical apps development in their paper ‘‘The fine art of usercentred software development’’. The authors identify several non-functional requirements to be used in analysing and comparing mobile platforms to support the development of

A systematic review of machine learning techniques for software fault prediction

BackgroundSoftware fault prediction is the process of developing models that can be used by the software practitioners in the early phases of software development life cycle for detecting faulty constructs such as modules or classes. There are various machine learning techniques used in the past for predicting faults. MethodIn this study we perform a systematic review of studies from January 1991 to October 2013 in the literature that use the machine learning techniques for software fault prediction. We assess the performance capability of the machine learning techniques in existing research for software fault prediction. We also compare the performance of the machine learning techniques with the statistical techniques and other machine learning techniques. Further the strengths and weaknesses of machine learning techniques are summarized. ResultsIn this paper we have identified 64 primary studies and seven categories of the machine learning techniques. The results prove the prediction capability of the machine learning techniques for classifying module/class as fault prone or not fault prone. The models using the machine learning techniques for estimating software fault proneness outperform the traditional statistical models. ConclusionBased on the results obtained from the systematic review, we conclude that the machine learning techniques have the ability for predicting software fault proneness and can be used by software practitioners and researchers. However, the application of the machine learning techniques in software fault prediction is still limited and more number of studies should be carried out in order to obtain well formed and generalizable results. We provide future guidelines to practitioners and researchers based on the results obtained in this work.

An empirical study based on semi-supervised hybrid self-organizing map for software fault prediction

Software testing is a crucial task during software development process with the potential to save time and budget by recognizing defects as early as possible and delivering a more defect-free product. To improve the testing process, fault prediction approaches identify parts of the system that are more defect prone. However, when the defect data or quality-based class labels are not identified or the company does not have similar or earlier versions of the software project, researchers cannot use supervised classification methods for defect detection. In order to detect defect proneness of modules in software projects with high accuracy and improve detection model generalization ability, we propose an automated software fault detection model using semi-supervised hybrid self-organizing map (HySOM). HySOM is a semi-supervised model based on self-organizing map and artificial neural network. The advantage of HySOM is the ability to predict the label of the modules in a semi-supervised manner using software measurement threshold values in the absence of quality data. In semi-supervised HySOM, the role of expert for identifying fault prone modules becomes less critical and more supportive. We have benchmarked the proposed model with eight industrial data sets from NASA and Turkish white-goods embedded controller software. The results show improvement in false negative rate and overall error rate in 80% and 60% of the cases respectively for NASA data sets. Moreover, we investigate the performance of the proposed model with other recent proposed methods. According to the results, our semi-supervised model can be used as an automated tool to guide testing effort by prioritizing the module’s defects improving the quality of software development and software testing in less time and budget.

Fault prediction considering threshold effects of object‐oriented metrics

AbstractSoftware product quality can be enhanced significantly if we have a good knowledge and understanding of the potential faults therein. This paper describes a study to build predictive models to identify parts of the software that have high probability of occurrence of fault. We have considered the effect of thresholds of object‐oriented metrics on fault proneness and built predictive models based on the threshold values of the metrics used. Prediction of fault prone classes in earlier phases of software development life cycle will help software developers in allocating the resources efficiently. In this paper, we have used a statistical model derived from logistic regression to calculate the threshold values of object oriented, Chidamber and Kemerer metrics. Thresholds help developers to alarm the classes that fall outside a specified risk level. In this way, using the threshold values, we can divide the classes into two levels of risk – low risk and high risk. We have shown threshold effects at various risk levels and validated the use of these thresholds on a public domain, proprietary dataset, KC1 obtained from NASA and two open source, Promise datasets, IVY and JEdit using various machine learning methods and data mining classifiers. Interproject validation has also been carried out on three different open source datasets, Ant and Tomcat and Sakura. This will provide practitioners and researchers with well formed theories and generalised results. The results concluded that the proposed threshold methodology works well for the projects of similar nature or having similar characteristics.

Studying the relationship between source code quality and mobile platform dependence

The recent meteoric rise in the use of smartphones and other mobile devices has led to a new class of software applications (i.e., mobile apps). One reason for this success is the extensive support available to mobile app developers through the APIs provided by mobile platforms (e.g., Android). In our previous research, we found that mobile apps tend to depend highly on these platform-specific APIs. High dependence on a particular mobile platform may introduce instability and defects, as these mobile platforms are rapidly evolving. Therefore, the extent of platform dependence may be an indicator of software quality. In this paper, we examine the relationship between platform dependence and defect proneness of the source code files of an Android app to determine whether software metrics based on platform dependence can be used to prioritize software quality assurance efforts. We find that (1) source code files that are defect prone have a higher dependence on the platform than defect-free files and (2) increasing the platform dependence increases the likelihood of a defect being present in a source code file. Thus, platform dependence may be used to prioritize the most defect-prone source code files for code reviews and unit testing by the software quality assurance team.

Software Defect Prediction Based on GUHA Data Mining Procedure and Multi-Objective Pareto Efficient Rule Selection

Software defect prediction, if is effective, enables the developers to distribute their testing efforts efficiently and let them focus on defect prone modules. It would be very resource consuming to test all the modules while the defect lies in fraction of modules. Information about fault-proneness of classes and methods can be used to develop new strategies which can help mitigate the overall development cost and increase the customer satisfaction. Several machine learning strategies have been used in recent past to identify defective modules. These models are built using publicly available historical software defect data sets. Most of the proposed techniques are not able to deal with the class imbalance problem efficiently. Therefore, it is necessary to develop a prediction model which consists of small simple and comprehensible rules. Considering these facts, in this paper, the authors propose a novel defect prediction approach named GUHA based Classification Association Rule Mining algorithm (G-CARM) where “GUHA” stands for General Unary Hypothesis Automaton. G-CARM approach is primarily based on Classification Association Rule Mining, and deploys a two stage process involving attribute discretization, and rule generation using GUHA. GUHA is oldest yet very powerful method of pattern mining. The basic idea of GUHA procedure is to mine the interesting attribute patterns that indicate defect proneness. The new method has been compared against five other models reported in recent literature viz. Naive Bayes, Support Vector Machine, RIPPER, J48 and Nearest Neighbour classifier by using several measures, including AUC and probability of detection. The experimental results indicate that the prediction performance of G-CARM approach is better than other prediction approaches. The authors' approach achieved 76% mean recall and 83% mean precision for defective modules and 93% mean recall and 83% mean precision for non-defective modules on CM1, KC1, KC2 and Eclipse data sets. Further defect rule generation process often generates a large number of rules which require considerable efforts while using these rules as a defect predictor, hence, a rule sub-set selection process is also proposed to select best set of rules according to the requirements. Evolution criteria for defect prediction like sensitivity, specificity, precision often compete against each other. It is therefore, important to use multi-objective optimization algorithms for selecting prediction rules. In this paper the authors report prediction rules that are Pareto efficient in the sense that no further improvements in the rule set is possible without sacrificing some performance criteria. Non-Dominated Sorting Genetic Algorithm has been used to find Pareto front and defect prediction rules.

SURVEY ON SOFTWARE REMODULARIZATION TECHNIQUES

Re-modularization of software systems is a key tech nique used in testing and maintenance phase of the software development lifecycle. This process helps the developer in revi ewing the modules and the interaction between those modules of the developed software systems. Re-modularization process also al lows the developer to make the software system more efficient by adding additional features according to their future requi rement and enhancement. Based on the review results , the developed software system can be re-modularized, thus finally making t he software system to be efficient and less fault-p rone. This paper deals with the survey on various methods that are used for re- modularization of software systems. The methods inc lude hierarchical clustering method, automated clustering methods and clustering using Genetic Algorithm (GA).The usage of hierarchical clustering helps in understanding the software doma in, software system and the measures used for clust ering the software system. Automatic clustering approaches are used in order t o group together highly cohesive components, in a m odule of the software system where the cohesiveness is measured in terms of intra-module links and reduce the coupling betwe en modules which is measured in terms of the inter-module dependencies of the software system. Genetic Algorithm belongs t o large class of Evolutionary Algorithm, which generates the solutio ns to optimization problems using techniques inspir ed by natural evolution such as inheritance mutation, crossover and selecti on. In general, Genetic Algorithm requires the gene tic representation of the solution domain and the fitness function to evaluat e the solution domain. In this survey the working p rinciple of various remodularization methods are discussed and the effici ent re-modularization approach is selected based on its features and advantages.

An Algorithmic Approach to Predict Fault Propagation and Defects in Dependent Modules based on Coupling

is an enormous amount of research going on to minimize the effect of coupling between the software modules and to reduce the defects present in them. In this paper, an algorithmic approach is proposed that gives a probability, such that the highly dependent modules in system must be analyzed by the development team for fault proneness and defects. The higher the coupling, interdependency between the modules is increased and it is alarming issue in software engineering tasks. There is an enormous amount of research done on direct and indirect coupling, but this paper approaches on the effect of coupling to predict defects and how they are propagating between the modules. Every software product is tested for defects and bugs before it is given to acceptance testing to users. The paper focuses on testing the defect propagation percentage of every module in a dependent system (dependent modules).The greater the percentage of defect propagation factor between two dependent module, implies that the coupling between them is higher and the probability of the module to be fault prone increases. Taking this into consideration, the testing team saves the time by considering more on the modules for which the percentage defect propagation factor is higher. It ensures time, cost and efficiency which are the main factors of a software industry.

Identification of Defect Prone Peritectic Steel Grades by Analyzing High-Temperature Phase Transformations

Continuous casting of peritectic steels is often difficult and critical; bad surface quality, cracks, and even breakouts may occur. The initial solidification of peritectic steels within the mold leads to formation of surface depressions and uneven shell growth. As commercial steels are always multicomponent alloys, the influence also of the alloying elements besides carbon on the peritectic phase transition needs to be taken into account. Information on the solidification sequence and phase diagrams for initial solidification are lacking especially for new steel grades, like high-alloyed TRIP-steels with high Mn, Si, and particularly high Al contents. Based on a comprehensive method development, the current study shows that differential scanning calorimeter measurements allow a clear prediction if an alloy is peritectic (i.e., critical to cast). In order to confirm these results, thermo-optical analyses with a high-temperature laser-scanning-confocal-microscope are performed to observe the phase transformations in situ up to the melting point.

Using Fuzzy Clustering and Software Metrics to Predict Faults in large Industrial Software Systems

Faults are a key problem in software systems. Awareness of possible flaws from the initialization of a project could save money, time and work. Estimating the possible deficiency of software could help in executing software development activities. This paper proposes a model to predict the possibility of faults on a software system before testing. The model predicts possible faults during software development using Fuzzy Clustering and Software Metrics. This research is aimed at predicting faults in large software systems by creating clusters and then finding out the distance of each point in the data set with the clusters created to determine their degree of membership within each cluster Reliance on software in our daily lives has increased so much in the last decade that in our day living without devices controlled by software is almost impossible. The Industrial domains such as medical applications, power plants, air traffic control and railway signaling have all integrated software as a fundamental part of their operation. Software engineers have to deal with a large number of quality requirements such as reliability, safety, availability, performance, maintainability and security which makes the development of these large software applications very challenging. The industrial reliance on software gives rise to the likelihood of gross crises in the case of a failure and the effect of these catastrophes ranges from economic damage to loss of lives. Therefore, there is an increasing necessity to ensure the steadfastness of software systems. Moreover, it is well known that the earlier a problem can be identified, the better and more cost effectively this problem can be fixed. Therefore, it is necessary to predict faults during the software development. There are numerous techniques and metrics for investigating fault prone modules which may aid software developers in performing testing activities during development. It is almost impossible to produce software that is free of faults due to the rising complexity and the constraints under which the software is developed. Such faults may lead to an increment in development & maintenance cost and time, due to software failures and decrease customer's satisfaction (1). Data Clustering is a basic technique in many modeling algorithms. The objective of clustering is to construct new collections of data from large data set. One of the most acceptable contributions to the field of data clustering is Fuzzy C-Means clustering. It has more benefits compared to other methods of data clustering, specifically the ability to split data for different size clusters with fuzzy logic. The Fuzzy C-Means can be seen as the modified version of the k-means algorithm. Which is a method of clustering that allows one piece of data to belong to two or more clusters. The degree of being in a certain cluster is related to the inverse of the distance to the cluster (2). Fuzzy C-Means iteratively moves the cluster centers to the right location within a data set. This research is aimed at predicting faults in large industrial software systems by creating clusters and then finding out the distance of each point in the data set with the clusters created to determine their degree of membership within each cluster. The Factors like Mean Absolute Error, Accuracy and Root Mean Square Error help us in predicting the software system as faulty or fault-free. The literature, (3)-(17) presents various types of Fault-Proneness Estimation Models. The results are also compared with (18) in which Hierarchical clustering based approach is used for Finding Fault Prone Classes in large software systems. The paper is organized as follows: section II exploits some literature on related works, section III explains the methodology followed in this research and section IV the result of the study. Finally conclusions of the research are presented in section V.

Clones: what is that smell?

Clones are generally considered bad programming practice in software engineering folklore. They are identified as a bad smell (Fowler et al. 1999) and a major contributor to project maintenance difficulties. Clones inherently cause code bloat, thus increasing project size and maintenance costs. In this work, we try to validate the conventional wisdom empirically to see whether cloning makes code more defect prone. This paper analyses the relationship between cloning and defect proneness. For the four medium to large open source projects that we studied, we find that, first, the great majority of bugs are not significantly associated with clones. Second, we find that clones may be less defect prone than non-cloned code. Third, we find little evidence that clones with more copies are actually more error prone. Fourth, we find little evidence to support the claim that clone groups that span more than one file or directory are more defect prone than collocated clones. Finally, we find that developers do not need to put a disproportionately higher effort to fix clone dense bugs. Our findings do not support the claim that clones are really a "bad smell" (Fowler et al. 1999). Perhaps we can clone, and breathe easily, at the same time.