This paper proposes a generalized model to cover imperfect debugging and the uncertainty of operating environment and its effect on fault detection rate into software reliability evaluation based on a non-homogeneous Poisson process (NHPP). Many NHPP software reliability growth models (SRGMs) have been proposed to estimate the software reliability measures over the past 40 years, but most of these models assume that the operating environment is the same as the testing environment. However, in fact, due to the unpredictability of uncertainty factors in the operating environments for the software, they may considerably influence the software’s reliability in an unpredictable way. So when a software system works in a field environment, its reliability is usually different from the original reliability prediction in the testing phase of the software development process, also from all its similar applications in other fields. In this paper, a general model is used to derive models that incorporate the uncertainty of operating environment, which provides the flexibility in considering different fault detection rate and random environmental factor and so on. Several published models are shown to be covered by this general model and a new model is also developed and examined. Numerical illustrative examples of the proposed model have been validated on two sets of real software failure data in terms of six criteria. The comparison results demonstrate that the new model can fit and predict significantly better than other existing models.

In this paper, we propose a software reliability model that considers not only error generation but also fault removal efficiency combined with testing coverage information based on a nonhomogeneous Poisson process (NHPP). During the past four decades, many software reliability growth models (SRGMs) based on NHPP have been proposed to estimate the software reliability measures, most of which have the same following agreements: 1) it is a common phenomenon that during the testing phase, the fault detection rate always changes; 2) as a result of imperfect debugging, fault removal has been related to a fault re-introduction rate. But there are few SRGMs in the literature that differentiate between fault detection and fault removal, i.e. they seldom consider the imperfect fault removal efficiency. But in practical software developing process, fault removal efficiency cannot always be perfect, i.e. the failures detected might not be removed completely and the original faults might still exist and new faults might be introduced meanwhile, which is referred to as imperfect debugging phenomenon. In this study, a model aiming to incorporate fault introduction rate, fault removal efficiency and testing coverage into software reliability evaluation is developed, using testing coverage to express the fault detection rate and using fault removal efficiency to consider the fault repair. We compare the performance of the proposed model with several existing NHPP SRGMs using three sets of real failure data based on five criteria. The results exhibit that the model can give a better fitting and predictive performance.

Many NHPP software reliability growth models (SRGMs) have been proposed to assess software reliability during the past 40 years, but most of them have focused on modeling the fault detection process (FDP) in two ways: one is to ignore the fault correction process (FCP), i.e., faults are assumed to be instantaneously removed after the failure caused by the faults is detected. However, in real software development, it is not always reliable as fault removal usually needs time, i.e., the faults causing failures cannot always be removed at once and the detected failures will become more and more difficult to correct as testing progresses. Another way to model the fault correction process is to consider the time delay between the fault detection and fault correction. The time delay has been assumed to be constant and function dependent on time or random variables following some kind of distribution. In this paper, some useful approaches to the modeling of dual fault detection and correction processes are discussed. The dependencies between fault amounts of dual processes are considered instead of fault correction time-delay. A model aiming to integrate fault-detection processes and fault-correction processes, along with the incorporation of a fault introduction rate and testing coverage rate into the software reliability evaluation is proposed. The model parameters are estimated using the Least Squares Estimation (LSE) method. The descriptive and predictive performance of this proposed model and other existing NHPP SRGMs are investigated by using three real data-sets based on four criteria, respectively. The results show that the new model can be significantly effective in yielding better reliability estimation and prediction.

This paper presents a general testing coverage software reliability modeling framework that covers imperfect debugging and considers not only fault detection processes (FDP) but also fault correction processes (FCP). Numerous software reliability growth models have evaluated the reliability of software over the last few decades, but most of them attached importance to modeling the fault detection process rather than modeling the fault correction process. Previous studies analyzed the time dependency between the fault detection and correction processes and modeled the fault correction process as a delayed detection process with a random or deterministic time delay. We study the quantitative dependency between dual processes from the viewpoint of fault amount dependency instead of time dependency, then propose a generalized modeling framework along with imperfect debugging and testing coverage. New models are derived by adopting different testing coverage functions. We compared the performance of these proposed models with existing models under the context of two kinds of failure data, one of which only includes observations of faults detected, and the other includes not only fault detection but also fault correction data. Different parameter estimation methods and performance comparison criteria are presented according to the characteristics of different kinds of datasets. No matter what kind of data, the comparison results reveal that the proposed models generally give improved descriptive and predictive performance than existing models.

Modern software systems need to autonomously adapt their behavior at runtime in order to maintain their utility in response to continuous environmental changes. Most studies on models at runtime focus on providing suitable techniques to manage the complexity of software at runtime but neglect reliability caused by adaptation activities. Therefore, adaptive behaviors may lead to a decrease in reliability, which may result in severe financial loss or life damage. Runtime software architecture (RSA) is an abstract of a running system, which describes the elements of the current system, the states of these elements and the relation between the elements and their states at runtime. The main difference between RSA and software architecture at design time (DSA) is that RSA has a causal connection with the running system, whereas DSA does not. However, RSA and DSA have both symmetry and asymmetry in software architecture. To ensure that architecture-centric software can provide reliable services after adaptation adjustment, a method is proposed to analyze the impact of changes caused by adaptation strategy on the overall software reliability, which will be predicted at the runtime architecture model layer. Based on a Java platform, through non-intrusive monitoring, an RSA behavioral model is obtained followed by runtime reliability analysis model. Following this, reliability prediction results are obtained through a discrete-time Markov chain (DTMC). Finally, an experiment is conducted to verify the feasibility of the proposed method.

The field of self-adaptive software is becoming increasingly crucial because software has to adapt its behavior at runtime to keep up with dynamic and constantly evolving environments. The ability of software to modify and adjust itself is known as adaptability, which has been acknowledged as an important quality attribute. As software architecture development represents the initial stage of the design process, architectural design has emerged as a critical development activity. The degree to which the architecture can adapt to changes will be the key factor in determining the adaptability of the software ultimately released to users. Existing metrics for software architectural adaptability typically view adaptability as a positive attribute, meaning that any possibility of change in architectural elements is perceived as an improvement in adaptability. However, the application of adaptability that leads to increased costs or complexity can only be seen as a negative attribute. In other words, the side effects brought about solely for the purpose of achieving adaptability are greatly overlooked; that is, the impacts caused by adaptability exhibit both symmetry and asymmetry for software architectural adaptability. On the other hand, the existing measures of adaptability only define it from the perspective of whether a module will change, without considering changes beyond the topological structure under multiple strategies. In this paper, we propose a comprehensive assessment approach to measure software architecture adaptability. Multiple factors are considered, including the number and types of strategies employed, the cost of completing the adaptation, the extent of changes made to the architectural elements, and the overall impact of the adaptation on the architecture. An extended UML (e-UML) component diagram is presented to model software architectural changes under various types of strategies. Finally, an experiment on the znn.com software is conducted to validate the practical feasibility of our proposed method. Our approach can assist software architects in making informed decisions regarding software architecture design options to improve the adaptability and longevity of their software systems.