Research On Software Reliability Growth Models Considering Fault Introduction

Reliability is one of the most important quality attributes of software. With the development of modern information technology, software products are being extensively used in numerous applications for all aspects of human social life, and more software functions have been achieved. The size and structure of software programming have expanded and become increasingly complex, especially with the evolution of software-intensive services, including cloud computing and big data applications. Thus, ensuring the development of high-quality software products is a difficult task. In real life, users prefer computers to be failure-free and to run all the time. Thus, software reliability, that is, whether software can be applied safely and effectively to computers, has become an important issue.Software reliability growth models(SRGMs) are a means for realizing software quality management. In modern software development, these models mostly assume that fault detection follows the non-homogeneous Poisson process(NHPP). Most NHPP models are assumed as the software reliability growth models with perfect debugging. Given the complex environment of modern software development and the difficulty in achieving more functional requirements, new faults can be introduced when the detected ones are removed. However, when the number and effect of introduced faults cannot be ignored, the phenomenon of imperfect debugging should be analyzed to establish a high-quality SRGM. Few researchers have examined the related problem of fault introduction and generally assumed that fault introduction rate is constant. Aimed at the changes of fault introduction over time, SRGM can be an effective and accurate tool for evaluating software reliability and predicting software failure behavior. In this paper, we not only considered building the SRGMs based on NHPP with imperfect debugging, but also considered using stochastic differential equation(SDE) to establish a related high-quality SRGM with imperfect debugging. The latter is because the software systems in the development of software-intensive services are larger in size, and the number of faults detected and removed through each debugging activity becomes sufficiently small compared with the initial fault content at the beginning of testing phase. In this case, fault detection can be considered a random process with continuous state changes.This study extensively analyzed the situations of fault introduction in software debugging and proposed the corresponding SRGMs. Problems in the optimal release of software products were also investigated. The main work of this study can be summarized as follows:1. In software debugging, debugging personnel undergo a learning process when detected faults are removed. In other words, the experiences of software debugging personnel are enriched with the increase of the number of removed software faults, and they obtain a deeper understanding of the debugging software.Thus, the number of software faults introduced by the software debugging personnel first increases and then decreases during the whole testing time. This condition implies that fault introduction rate first increases and then decreases over time. By considering this phenomenon in the software debugging process, we proposed an SRGM based on the log-logistic distribution fault introduction rate. The performance of the proposed model was compared with those of other SRGMs using related fault data sets and model comparison criteria. The experimental results indicate that the proposed model could satisfactorily fit fault data sets and precisely predict the occurrence of software failure in the future.2. During software debugging, fault introduction rate is affected by many factors and irregularly changes as time varies. Such an irregular changing process of fault introduction rate is consistent with the actual fault introduction process and could be simulated using the Brownian motion. Therefore, this study proposed an SRGM based on the irregular changes of fault introduction rate and used the related fault data sets to evaluate the model. The experimental results confirmed previous findings that the proposed model could satisfactorily fit fault data sets and precisely predict software failures.3. In software debugging, fault introduction can be a process of composition characterized by various rules and characteristics. In other words, fault introduction is a regular and unstable changing process, in which the cumulative number of introduced faults non-linearly changes. Considering the characteristics of fault introduction, we could develop a nonlinear fault content function. Although numerous software products have been developed and adequate testing and debugging processes have been implemented, users could still observe faults in using software. In fact, the removal of faults introduces new ones. As such, a failure-free running software can only be guaranteed in the present environment and conditions, but not in the user environment. When faults occur, they cannot be entirely removed. Thus, establishing an infinite introducing fault SRGM with imperfect debugging has certain practical significance. In this study, we proposed an SRGM based on the unstable changing of fault introduction. This model considers not only the unstable changing process of fault introduction, but also the case of infinite introduction faults. The experimental results confirmed that compared with other SRGMs, the proposed model could better fit fault data and more accurately predict the number of faults existing in a software. In SRGM research, the optimal release time of software is an important issue. The timely release of softwareproducts not only benefits enterprises in terms of profit, but it also reduces their developmental costs. Therefore, we also presented a method for using the imperfect software debugging model to determine the optimal release time of software products.4. NHPP has generally been used in the development of SRGM. However, fault detection rate irregularly fluctuates over time because of the complexity of software testing and the occurrence of fault introduction. Thus, we adopted stochastic differential equation to establish an SRGM with imperfect debugging. The experimental results once again verified that the proposed model derived from stochastic differential equation could better fit fault data and more accurately predict future software failures compared with other SRGMs.