A software reliability growth model for imperfect debugging

In this paper, we propose a new software reliability growth model which is the mixture of two exponential reliability growth models, one of which has the reliability growth and the other one does not have the reliability growth after the software is released upon completion of testing phase. The mixture of two such models is characterized by a weighted factor p, which is the proportion of reliability growth part within the model. Firstly, this paper discusses an optimal software release problem with regard to the expected total software cost incurred during the warranty period under the proposed software reliability growth model, which generalizes Kimura, Toyota and Yamada's (1999) model with consideration of the weighted factor. The second main purpose of this paper is to apply the Bayesian approach to the optimal software release policy by assuming the prior distributions for the unknown parameters contained in the proposed software reliability growth model. Some numerical examples are presented for the purpose of comparing the optimal software release policies depending on the choice of parameters by the non-Bayesian and Bayesian methods.

This paper presents a new stochastic model for determining the optimal release time for a computer software in testing phase, taking account of the debugging time lag. In the earlier works, most of software release models were considered, but it was assumed that an error detected can be removed instantaneously. In other words, none discussed quantitatively the effect of the software maintenance action in the optimal software release time. Main purpose of this work is to relate the optimal software release policy with the arrival-service process on the software operation phase by users. We use the Non-Homogeneous Poisson Process (NHPP) type of software reliability growth models as the software error detection phenomena and obtain the optimal software release policies minimizing the expected total software costs. As a result, the usage circumstance of a software in operation phase gives a monotone effect to the software release planning.

Owing to release of software in multiple releases, code changes take place in software. Because of this added complexity in software, the testing team may be unable to correct the fault upon detection, leaving the actual fault to reside in the software, termed as imperfect debugging or there may be replacement of original fault by other fault, leading to error generation. Many other factors exist that affect the testing phase of software like strategies of testing, test cases, skill, efficiency, and learning of testing team. All these factors cannot be kept stable during the whole process of testing. They may change at any time moment causing the background processes to experience change, which is known as change‐point. Keeping all these critical testing environment factors under consideration, a new software reliability growth model has been proposed, which is derived from an non homogenous Poisson process (NHPP)based unified scheme for multi‐release two‐stage fault detection/observation and correction/removal software reliability models. The developed model is numerically illustrated on tandem data set for four releases.

Reliability is the one of the important quality measure of software product. Testing is one important phase in software development life cycle whose intention is to find the bugs present in the software product. A mathematical model which describes the software testing in software development cycle termed as software reliability growth models. Past few decades many software reliability growth models were proposed. Estimating the accurate release time of software is an important challenging issue of software Development Company. If the software product is released early contain more errors makes software to be less reliable, where as late release will increase the development cost. It is observed that more than half of the total development cost is concentrated during the maintenance phase. Estimating the reliability and accurate development cost of software product by software reliability growth model at maintenance phase is an important issue. Warranty is defined to be an agreement between the customer and vendor of the software to provide the extra protection to the product. Several papers have concentrated on optimal release time by considering the warranty cost. All early proposed NHPP warranty cost models considered a perfect-debugging software reliability growth model while estimating the software maintenance cost. But it was observed that, the software product is influenced by several factors like environment, resources and nature of the faults during the operational phase. In such circumstances it is quite not right to consider a perfect NHPP software reliability growth model in operational phase. In this paper we proposed an imperfect debugging software reliability growth model by combining the cost and reliability at a given warranty period to estimate the optimal release time of software product.

Software reliability models are used to estimate and predict the reliability, number of remaining faults, failure intensity, total software development cost, etc., of a software. Testing coverage is very important for both software developers and customers of software products. Testing converge is a measure that enables software developers to evaluate the quality of tested software and determine how much additional effort is needed to improve the reliability of the software. This paper proposes a software reliability growth model based on a non-homogeneous Poisson process (NHPP) that incorporates a logistic–exponential testing coverage function with imperfect debugging. The proposed model relates the test coverage to fault detection phenomena in debugging. Goodness-of-fit test of the proposed model is conducted using different criteria for two sets of software failure data. The proposed model is compared with other existing NHPP models. A software cost model incorporating testing coverage and an optimal release policy based on the number of remaining faults are developed.

This investigation deals with a N-modules software reliability growth model (SRGM) wherein each module attains multiple types of faults of different severity levels. During the debugging phase, there may arise some new faults due to assumption of imperfect debugging. The reliability growth during the software testing phase governed by a non-homogeneous Poisson Process (NHPP). The proposed study is devoted to analyze the fault debugging phenomenon in all modules of software and to obtain expected number of faults observed, isolated and removed. The software reliability and optimum total cost of the software development during the testing phase are evaluated. The causes of fault occurrences in each module are different. The faults may occur with different failure rates and follow the nonlinear behavior with respect to the testing time. The NHPP model incorporates the testing-effort expenditure required for the faults debugging activities and governed by Weibull and logistic distributions which influence considerably not only the fault observation rate but also the time to isolate the faults and the time to remove the faults from all N-modules. In addition to predict the reliability of N-modular software, this study proposes optimal release policies for the SRGM by minimizing the expected cost subject to budget and testing-effort constraints, while ensuring a prescribed level of reliability and incorporating the effects of testing effort and efficiency. Some specific models are also deduced by setting the appropriate parameters so as to match with the existing models in the literature. Sensitivity results are presented through a numerical experiment to demonstrate the validity of the analytical formulations and the computational tractability of the model. An evolutionary algorithm, namely Particle Swarm Optimization (PSO) based on a dynamic penalty method, is employed to determine the optimal release time.

In order to overcome the limitations of debugging process, insufficient consideration of imperfect debugging and testing-effort (TE) in software reliability modeling and analysis, a software reliability growth model (SRGM) explicitly incorporating imperfect debugging and TE is developed. From the point of view of incomplete debugging and introduction of new fault, software testing process is described and a relatively unified SRGM framework is presented considering TE. The proposed framework models are fairly general models that cover a variety of the previous works on SRGM with ID and TE. Furthermore, a special SRGM incorporating an improved Logistic testing-effort function (TEF) into imperfect debugging modeling is proposed. The effectiveness and reasonableness of the proposed model are verified by published failure data set. The proposed model closer to real software testing has better descriptive and predictive power than other models

In reality, the fault detection (or correction) phenomenon and software reliability estimation in the operational phase are different from that in the testing phase. The fault removal continues at a slower rate during the operational phase. In this paper, we will investigate some techniques for software reliability prediction and measurement in the operational phase. We first review how some software reliability growth models (SRGMs) based on non-homogeneous Poisson processes (NHPPs) can be readily derived based on a unified theory for NHPP models. Under this general framework, we can not only verify some conventional SRGMs but also derive some new SRGMs that can be used for software reliability measurement in the operational phase. That is, based on the unified theory, we can incorporate the concept of multiple changepoints into software reliability modeling. We can formularize and simulate the fault detection process in the operational phase. Some numerical illustrations based on real software failure data are also presented. The experimental results show that the proposed models can easily reflect the possible changes of fault detection process and offer quantitative analysis on software failure behavior in field operation.

Failure of a safety critical system can lead to big losses. Very high software reliability is required for automating the working of systems such as aircraft controller and nuclear reactor controller software systems. Fault-tolerant softwares are used to increase the overall reliability of software systems. Fault tolerance is achieved using the fault-tolerant schemes such as fault recovery (recovery block scheme), fault masking (N-version programming (NVP)) or a combination of both (Hybrid scheme). These softwares incorporate the ability of system survival even on a failure. Many researchers in the field of software engineering have done excellent work to study the reliability of fault-tolerant systems. Most of them consider the stable system reliability. Few attempts have been made in reliability modeling to study the reliability growth for an NVP system. Recently, a model was proposed to analyze the reliability growth of an NVP system incorporating the effect of fault removal efficiency. In this model, a proportion of the number of failures is assumed to be a measure of fault generation while an appropriate measure of fault generation should be the proportion of faults removed. In this paper, we first propose a testing efficiency model incorporating the effect of imperfect fault debugging and error generation. Using this model, a software reliability growth model (SRGM) is developed to model the reliability growth of an NVP system. The proposed model is useful for practical applications and can provide the measures of debugging effectiveness and additional workload or skilled professional required. It is very important for a developer to determine the optimal release time of the software to improve its performance in terms of competition and cost. In this paper, we also formulate the optimal software release time problem for a 3VP system under fuzzy environment and discuss a the fuzzy optimization technique for solving the problem with a numerical illustration.

Many software reliability growth models have been proposed in the past decade. Those models tacitly assume that testing-effort expenditures are constant throughout software testing. This paper develops realistic software reliability growth models incorporating the effect of testing-effort. The software error detection phenomenon in software testing is modeled by a nonhomogeneous Poisson process. The software reliability assessment measures and the estimation methods of parameters are investigated. Testing-effort expenditures are described by exponential and Rayleigh curves. Least-squares estimators and maximum likelihood estimators are used for the reliability growth parameters. The software reliability data analyses use actual data. The software reliability growth models with testing-effort can consider the relationship between the software reliability growth and the effect of testing-effort. Thus, the proposed models will enable us to evaluate software reliability more realistically.

Software failure-occurrence or the fault-detection phenomenon is changed notably in an actual testing phase or an operational phase due to the changes of factors influencing the software reliability growth process. Taking into consideration of the effect of the change in software reliability growth modeling is expected to conduct more accurate software reliability assessment because it is said that such approach enables us to conduct more plausible software reliability assessment reflecting an actual testing-environment. We develop a framework for developing software hazard rate models with effect of change-point, and discuss change-point detection methods for applying our model to quantitative software reliability assessment. Additionally, we discuss an optimal software release problem for estimating optimal shipping time with the effect of the change as one of the application problems of our model in software project management. Finally, we show numerical examples for software reliability assessment and our optimal software release policy based on our change-point model by using actual data.

In order to incorporate the effect of test coverage, two novel software reliability growth models (SRGMs) are proposed in this paper using failure data and test coverage simultaneously. One is continuous using testing time, and the other is discrete with respect to the number of executed test cases instead of testing time. Since one of the most important factors of the coverage-based SRGMs is the test coverage function (TCF), we first discuss a discrete TCF based on Beta function. Then we develop mean value functions (MVF) of the two models integrating test coverage and imperfect debugging. Finally the proposed TCF and MVFs are evaluated and validated on actual software reliability data collected from real software development projects. The results demonstrate clearly that both the proposed TCF and SRGMs provide better estimation and fitting for the data sets under comparisons.

Software reliability growth models (SRGMs) have been developed to estimate software reliability measures such as the number of remaining faults, software failure rate, and software reliability. Issues such as imperfect debugging and the learning phenomenon of developers have been considered in these models. However, most SRGMs assume that faults detected during tests will eventually be removed. Consideration of fault removal efficiency in the existing models is limited. In practice, fault removal efficiency is usually imperfect. This paper aims to incorporate fault removal efficiency into software reliability assessment. Fault removal efficiency is a useful metric in software development practice and it helps developers to evaluate the debugging effectiveness and estimate the additional workload. In this paper, imperfect debugging is considered in the sense that new faults can be introduced into the software during debugging and the detected faults may not be removed completely. A model is proposed to integrate fault removal efficiency, failure rate, and fault introduction rate into software reliability assessment. In addition to traditional reliability measures, the proposed model can provide some useful metrics to help the development team make better decisions. Software testing data collected from real applications are utilized to illustrate the proposed model for both the descriptive and predictive power. The expected number of residual faults and software failure rate are also presented.

Multiple Software Reliability Growth Models (SRGM) has been illustrated to inspire designers and software developers to develop quality software. These models implicitly assume that expenditure is constant throughout testing effort. Recently importance was given to the testing phase by the development team and it requires controlled screening closely to raise its overall operational efficiency. Software Reliability Growth Models exhibits a precise relation between the failure patterns with time. Considering this as a basic building block a SRGM which is a Non-Homogeneous Poisson Process in nature is i in this work. The various aspects of our proposed model are testing effort function and fault detection rate (FDR). Mainly in Software Reliability Growth Model it was assumed that fault removal process are perfect which is not true in reality as new faults may get introduced during removal or some faults may not get removed due to its complexity. Thus in this model the concept of imperfect debugging was considered and assists us to justify the software reliability more convincingly through the help of testing effort function.

The software testing process basically aims at building confidence in the software for its use in real world applications. The reliability of a software system is always important to us. As we carry out the error detection and correction phenomenon on our software, the reliability of the software grows. With an aim to model this growth in the software reliability, many formulations in the form of Software Reliability Growth Models have been proposed. Many of these are based on Non-Homogeneous Poisson Process framework. In this paper, a parallel comparison of the performance of the proposed software reliability growth models is carried out, considering linear and exponential fault content functions for study of imperfect debugging situations. The performance of the proposed models has been compared with some famous existing software reliability models and the proposed models have been validated on some real-world datasets. Three goodness-of-fit criteria that include mean square error, predictive-ratio risk and predictive power are used to carry out the performance comparison of the models. Using these comparison criteria on six actual failure datasets, it is concluded that the proposed Model-2 which always outperforms Model-1, fits the actual failure data better and has better predictive power than other considered SRGMs for at least two data sets.