Number Of Software Faults Research Articles

Software reliability model for open-source software that considers the number of finite faults and dependent faults.

Software has become a vital factor in the fourth industrial revolution. Owing to the increase in demand for software products in various fields (big data, artificial intelligence, the Internet of Things, etc.), the software industry has expanded more than ever before. Therefore, software reliability has become very important, and efforts are being made to increase it. One of these efforts is the development of software reliability models (SRMs). SRMs have been studied for a long time as a model that predicts software reliability by using the number of software faults. Software failures can occur for several reasons, including independent software faults such as code errors and software hangs, as well as dependent cases where code errors lead to other software faults. Recently, due to the diversity of software operating environments, software faults are more likely to occur in a dependent manner, and, for this reason, they are likely to increase rapidly from the beginning and progress slowly to the maximum number thereafter. In addition, many large companies have focused on open-source software (OSS) development, and OSS is being developed by many users. In this study, we propose a new SRM that considers the number of finite faults and dependent faults, and examine the goodness-of-fit of a new SRM and other existing non-homogeneous Poisson process models based on the OSS datasets. Through numerical examples, the proposed model demonstrated a significantly better goodness-of-fit when compared to other existing models, and it also exhibited better results on the newly proposed integrated criteria.

Defect Prediction Technology in Software Engineering Based on Convolutional Neural Network

Software defect prediction has become a significant study path in the field of software engineering in order to increase software reliability. Program defect predictions are being used to assist developers in identifying potential problems and optimizing testing resources to enhance program dependability. As a consequence of this strategy, the number of software defects may be predicted, and software testing resources are focused on the software modules with the most problems, allowing the defects to be addressed as soon as feasible. The author proposes a research method of defect prediction technology in software engineering based on convolutional neural network. Most of the existing defect prediction methods are based on the number of lines of code, module dependencies, stack reference depth, and other artificially extracted software features for defect prediction. Such methods do not take into account the underlying semantic features in software source code, which may lead to unsatisfactory prediction results. The author uses a convolutional neural network to mine the semantic features implicit in the source code and use it in the task of software defect prediction. Empirical studies were conducted on 5 software projects on the PROMISE dataset and using the six evaluation indicators of Recall, F1, MCC, pf, gm, and AUC to verify and analyze the experimental results showing that the AUC values of the items varied from 0.65 to 0.86. Obviously, software defect prediction experimental results obtained using convolutional neural networks are still ideal. Defect prediction model in software engineering based on convolutional neural network has high prediction accuracy.

LSTM Encoder-Decoder Dropout Model in Software Reliability Prediction

Numerous methods have been introduced to predict the reliability of software. In general, these methods can be divided into two main categories, namely parametric (e.g. software reliability growth models) and non-parametric (e.g. neural networks). Both approaches have been successfully implemented in software testing applications over the past four decades. Since most software reliability prediction data are available in the form of time series, deep recurrent network models (e.g. RNN, LSTM, NARX, and LSTM Encoder-Decoder networks) are considered as powerful tools to be employed in reliability-related problems. However, the problem of overfitting is a major concern when using deep neural networks for software reliability applications. To address this issue, we propose the use of dropout; therefore, this study utilizes a deep learning model based on LSTM Encoder-Decoder Dropout to predict the number of faults in software and assess software reliability. Experimental results show that the proposed model has better prediction performance compared with other RNN-based models.

A time-variant fault detection software reliability model

In this work, we propose a time-variant software reliability model (SRM)which considers the fault detection and the highest number of faults in software. The time-variant genetic algorithm process is implemented for the assessment of the SRM parameters. The proposed model works upon a non-homogeneous Poisson process (NHPP) and incorporates fault dependent detection and software failure intensity and the un-removed error in the software. We had considered programmers proficiency, software complexity, organization hierarchy, and perfect debugging as the determining factors for SRM. The dataset collected from 74 software projects was experimented with to establish and validate the proposed software reliability model's better fit. Data is collected over a period, which is initiated with the start of the project and is continuously monitored until its completion. Several parameters are analyzed, and a collection of 115 attributes are given with 11 different time frames in terms of product and process characteristics. A total of 383 persons were involved in software design, where the issue count total is 255. The proposed time-variant fault detection SRM is implemented in Jira and is also compared with the existing reliability model presented in the literature. It is observed that the proposed fault detection SRM works better in terms of different parameters like mean square error (MSE), root mean square error (RMSE), and r-squared (R2).The work is carried out, ensuring time-varying fault detection, which is measured by considering response count, coding and non-coding deliverables, and the number of bugs in the software.We considered the programmer's proficiency, software complexity, organization hierarchy, and perfect debugging as the determining factors for presenting the software reliability model.The proposed Software reliability model shows improvement over existing algorithms as the residual errors are reduced, and prediction accuracy is high in terms of cumulative fault detection.

Predicting the number of defects in a new software version.

Predicting the number of defects in software at the method level is important. However, little or no research has focused on method-level defect prediction. Therefore, considerable efforts are still required to demonstrate how method-level defect prediction can be achieved for a new software version. In the current study, we present an analysis of the relevant information obtained from the current version of a software product to construct regression models to predict the estimated number of defects in a new version using the variables of defect density, defect velocity and defect introduction time, which show considerable correlation with the number of method-level defects. These variables also show a mathematical relationship between defect density and defect acceleration at the method level, further indicating that the increase in the number of defects and the defect density are functions of the defect acceleration. We report an experiment conducted on the Finding Faults Using Ensemble Learners (ELFF) open-source Java projects, which contain 289,132 methods. The results show correlation coefficients of 60% for the defect density, -4% for the defect introduction time, and 93% for the defect velocity. These findings indicate that the average defect velocity shows a firm and considerable correlation with the number of defects at the method level. The proposed approach also motivates an investigation and comparison of the average performances of classifiers before and after method-level data preprocessing and of the level of entropy in the datasets.

Web service composition on IoT reliability test based on cross entropy

AbstractWeb service has developed the managed IoT application to let connected devices easily and securely interact with cloud applications and other devices. As an important factor for web service, the reliability of web services refers to the probability of web service running success. For modeling web service composition, we should abstract the process of web service composition. Due to the diversity and complexity of web service composition, it is unlikely to do exhaustive testing. In order to improve the quality of web service composition test cases and find out which path leads to the greatest probability of service combination failure, heuristic test case generation method is adopted to obtain the optimal test path. First, the web service composition test is abstracted into the MDP model. The QoS of the web service composition is taken as the software test optimization goal, and the cross‐entropy strategy is used to optimize the test case. The experimental results show that the test profile given by the cross‐strategy is better than the random test strategy. Detect and exclude the same number of software defects. Cross‐entropy strategy can significantly reduce the number of test cases, reduce test costs, and improve defect detection efficiency.

Multi-response optimization based on desirability function and Taguchi method in agile software development

Software industries are continuously striving to achieve software quality through delivery of defect free software within time and within estimated budget. Most of the quality improvement strategies in software development focusses on optimizing a single response variable such as the defect count. But in reality, many responses contribute to the quality of software developed which requires to be studied simultaneously. This paper attempts to study the number of defects in software and the effort required in correcting these defects, simultaneously using desirability function and Taguchi method. Effort is defined as the time span from when the defect was logged into the system to the time when the defect was corrected and removed from the system and is measured in hours. The work has been executed on the issue tracking system of a large telecommunication organization. The organization manufactured consumer electronic devices having embedded software developed using agile development method. The input factors studied are Change Request Priority, software development phase and severity, which were selected from a total of 24 parameters using analytic hierarchy process. Significant factors and their optimal levels which optimized the defects captured and the effort taken to eliminate them, were obtained. Confirmation tests were performed using the optimal settings of the input factors on the data from the subsequent sprint which showed a 20% improvement in the overall desirability value.

On the Impact of Programming Languages on Code Quality

In a 2014 article, Ray, Posnett, Devanbu, and Filkov claimed to have uncovered a statistically significant association between 11 programming languages and software defects in 729 projects hosted on GitHub. Specifically, their work answered four research questions relating to software defects and programming languages. With data and code provided by the authors, the present article first attempts to conduct an experimental repetition of the original study. The repetition is only partially successful, due to missing code and issues with the classification of languages. The second part of this work focuses on their main claim, the association between bugs and languages, and performs a complete, independent reanalysis of the data and of the statistical modeling steps undertaken by Ray et al. in 2014. This reanalysis uncovers a number of serious flaws that reduce the number of languages with an association with defects down from 11 to only 4. Moreover, the practical effect size is exceedingly small. These results thus undermine the conclusions of the original study. Correcting the record is important, as many subsequent works have cited the 2014 article and have asserted, without evidence, a causal link between the choice of programming language for a given task and the number of software defects. Causation is not supported by the data at hand; and, in our opinion, even after fixing the methodological flaws we uncovered, too many unaccounted sources of bias remain to hope for a meaningful comparison of bug rates across languages.

A fuzzy rule-based generation algorithm in interval type-2 fuzzy logic system for fault prediction in the early phase of software development

ABSTRACTReliability, a measure of software, deals in total number of faults count up to a certain period of time. The present study aims at estimating the total number of software faults during the early phase of software life cycle. Such estimation helps in producing more reliable software as there may be a scope to take necessary corrective actions for improving the reliability within optimum time and cost by the software developers. The proposed interval type-2 fuzzy logic-based model considers reliability-relevant software metric and earlier project data as model inputs. Type-2 fuzzy sets have been used to reduce uncertainties in the vague linguistic values of the software metrics. A rule formation algorithm has been developed to overcome inconsistency in the consequent parts of large number of rules. Twenty-six software project data help to validate the model, and a comparison has been provided to analyse the proposed model’s performance.

Software reliability prediction using a deep learning model based on the RNN encoder–decoder

Different software reliability models, such as parameter and non-parameter models, have been developed in the past four decades to assess software reliability in the software testing process. Although these models can effectively assess software reliability in certain testing scenarios, no single model can accurately predict the fault number in software in all testing conditions. In particular, modern software is developed with more sizes and functions, and assessing software reliability is a remarkably difficult task. The recently developed deep learning model, called deep neural network (NN) model, has suitable prediction performance. This deep learning model not only deepens the layer levels but can also adapt to capture the training characteristics. A comprehensive, in-depth study and feature excavation ultimately shows the model can have suitable prediction performance. This study utilizes a deep learning model based on the recurrent NN (RNN) encoder–decoder to predict the number of faults in software and assess software reliability. Experimental results show that the proposed model has better prediction performance compared with other parameter and NN models.

Evolution of Software Reliability Growth Models: A Comparison of Auto-Regression and Genetic Programming Models

reliability growth models to predict software reliability and identify and remove errors is both a necessity and a challenge for software testing engineers and project managers. Being able to predict the number of faults in software helps significantly in determining the software release date and in effectively managing project resources. Most of the growth models consider two or three parameters to estimate the accumulated faults in the testing process. Interest in using evolutionary computation to solve prediction and modeling problems has grown in recent years. In this paper, we explore the use of genetic programming (GP) as a tool to help in building growth models that can accurately predict the number of faults in software early on in the testing process. The proposed GP model is based on a recursive relation derived from the history of measured faults. The developed model is tested on real-time control, military, and operating system applications. The dataset was developed by John Musa of Bell Telephone Laboratories. The results of a comparison of the GP model with the traditional and simpler auto-regression model are presented. Keywordsreliability, genetic programming, evolutionary Computation

Exponentiated Weibull distribution approach based inflection S-shaped software reliability growth model

Abstract The aim of this paper was to estimate the number of defects in software and remove them successfully. This paper incorporates Weibull distribution approach along with inflection S-shaped Software Reliability Growth Models (SRGM). In this combination two parameter Weibull distribution methodology is used. Relative Prediction Error (RPE) is calculated to predict the validity criterion of the developed model. Experimental results on actual data from five data sets are compared with two other existing models, which expose that the proposed software reliability growth model predicts better estimation to remove the defects. This paper presents best software reliability growth model with including feature of both Weibull distribution and inflection S-shaped SRGM to estimate the defects of software system, and provide help to researchers and software industries to develop highly reliable software products.

Impact of Size and Productivity on Testing and Rework Efforts for Web-based Development Projects

In the planning of a software development project, a major challenge faced by project managers is to predict the rework effort. (Rework effort is the effort required to fix the software defects identified during system testing). The project manager's objective is to deliver the software within the time, cost and quality requirements given by the client. To ensure the quality of the software, many testing cycles will be conducted before it is finally delivered to the client for acceptance. Each testing cycle is a costly affair as it involves running all possible test scenarios in all possible environments, followed by defect fixing and re-verification of defect fixes. On average, two to three testing cycles are conducted but this depends on the number of defects identified during testing. The number of defects will depend on the team expertise and whether they earlier worked on similar projects and technologies. Therefore, it becomes critical to predict the number of defects that will be identified during testing and it is a very challenging task as it requires a good model to predict the rework effort. In this paper, we describe the relationships among software size, number of software defects, productivity and efforts for web-based development projects. These relationships are established by using the multiple linear regression technique on the benchmarking data published by International Software Benchmarking Standard Group. Results suggest that in web-based projects the number of defects identified is directly proportional to the productivity, i.e. higher productivity will led to more defects found and lower productivity will lead to fewer defects found, therefore, less testing and rework effort will be required if project is planned with lower productivity because we can spend more time on development (i.e. time spend till construction phase) to reduce the number of defects found during testing and it will directly contribute in reducing the rework efforts. We infer from the relationship that software size has a significant impact on the total number of defect identified. We also infer that while planning a software project we should use appropriate tools to reduce the margin of error in size estimation and we should also re-estimate the size after every phase of the development life cycle to re-calibrate overall efforts and to minimize the impact on the project plan.

Correlation Analysis of Software Defects Density and Metrics

It is very useful for improving software quality if we can find which software metrics are more correlative with software defects or defects density. Based on 33 actual software projects, we analyzed 44 software metrics from application level, file level, class level and function level, and do correlation analysis with the number of software defects and defect density, the results show that software metrics have little correlation with the number of software defects, but are correlative with defect density. Through correlation analysis, we selected five metrics that have larger correlation with defect density, these metrics can be used for improving software quality and predicting software defects density.

Research on Software Defect Prediction Method Based on Machine Learning

This paper analyzed 44 metrics of application level, file level, class level and function level, and do correlation analysis with the number of software defects and defect density, the results show that software metrics have little correlation with the number of software defect, but are correlative with defect density. Through correlation analysis, we selected five metrics that have larger correlation with defect density. On the basis of feature selection, we predicted defect density with 16 machine learning models for 33 actual software projects. The results show that the Spearman rank correlation coefficient (SRCC) between the predicting defect density and the actual defect density based on SVR model is 0.6727, higher than other 15 machine learning models, the model that has the second absolute value of SRCC is IBk model, the SRCC only is-0.3557, the results show that the method based on SVR has the highest prediction accuracy.

Towards assessment of software reliability and its characteristics in safety systems of nuclear reactors

As software failures in critical systems could be life threatening and catastrophic, the increase in software-based controls for safety operations demand a systematic evaluation of software reliability. To understand the dynamics behind building reliable software, not only is it important to estimate software reliability with high confidence, it is necessary to study the factors that are likely to affect software reliability. This is especially important for systems that are yet to be certified to be used in the field, i.e. have no operational history. Such systems are often difficult to analyze as no or little operational information is available. This paper attempts to generalize the following relationships in safety-critical software: (i) software reliability versus number of faults in software, (ii) software reliability versus results of static and dynamic analysis, and (iii) software reliability versus safety. The present study reports and discusses results observed in safety- critical software in nuclear reactors using mutation-based testing. The results observed in the case studies indicate that (i) reliability estimates based on number of bugs present in software are likely to be inaccurate for safety-critical software, (ii) the relationship between reliability and errors observed during dynamic analysis indicates that the average warnings and errors decrease exponentially as the reliability increases. No conclusive relationship was found between software reliability and warnings observed during static analysis; and (iii) for safety-critical software, the required safety can be achieved by improving the reliability, however the converse is not always true.

A SOFTWARE RELIABILITY ESTIMATION METHOD TO NUCLEAR SAFETY SOFTWARE

A method for estimating software reliability for nuclear safety software is proposed in this paper. This method is based on the software reliability growth model (SRGM), where the behavior of software failure is assumed to follow a non-homogeneous Poisson process. Two types of modeling schemes based on a particular underlying method are proposed in order to more precisely estimate and predict the number of software defects based on very rare software failure data. The Bayesian statistical inference is employed to estimate the model parameters by incorporating software test cases as a covariate into the model. It was identified that these models are capable of reasonably estimating the remaining number of software defects which directly affects the reactor trip functions. The software reliability might be estimated from these modeling equations, and one approach of obtaining software reliability value is proposed in this paper.

Using Artificial Neural-Networks in Stochastic Differential Equations Based Software Reliability Growth Modeling

Due to high cost of fixing failures, safety concerns, and legal liabilities, organizations need to produce software that is highly reliable. Software reliability growth models have been developed by software developers in tracking and measuring the growth of reliability. Most of the Software Reliability Growth Models, which have been proposed, treat the event of software fault detection in the testing and operational phase as a counting process. Moreover, if the size of software system is large, the number of software faults detected during the testing phase becomes large, and the change of the number of faults which are detected and removed through debugging activities becomes sufficiently small compared with the initial fault content at the beginning of the testing phase. Therefore in such a situation, we can model the software fault detection process as a stochastic process with a continuous state space. Recently, Artificial Neural Networks (ANN) have been applied in software reliability growth prediction. In this paper, we propose an ANN based software reliability growth model based on Ito type of stochastic differential equation. The model has been validated, evaluated and compared with other existing NHPP model by applying it on actual failure/fault removal data sets cited from real software development projects. The proposed model integrated with the concept of stochastic differential equation performs comparatively better than the existing NHPP based model.

A dynamic capture–recapture model for software defect prediction

Several models have been developed that attempt to predict the total number of defects in a software product. One such approach uses the capture–recapture model, a technique employed by biologists for predicting wildlife populations. In this method once the software is built and defects begin to be identified a prediction can be made for the total number of software defects present. But capture–recapture models rely on expert inspectors and the technique cannot be employed once the software has been released. The work reported here extends the capture–recapture technique to the post-inspection phase and to where inspection data is unavailable, by using user defect reports. The proposed technique does not rely on expert inspectors and is particularly suitable for open source software.

Software Reliability Modeling Based on Capture-Recapture Sampling

This paper proposes a dynamic capture-recapture (DCR) model to estimate not only the total number of software faults but also quantitative software reliability from observed data. Compared to conventional static capture-recapture (SCR) model and usual software reliability models (SRMs) in the past literature, the DCR model can handle dynamic behavior of software fault-detection processes and can evaluate quantitative software reliability based on capture-recapture sampling of software fault data. This is regarded as a unified modeling framework of SCR and SRM with the Bayesian estimation. Simulation experiments under some plausible testing scenarios show that our models are superior to SCR and SRMs in terms of estimation accuracy.