**1. Introduction**

Software, one of the main components of a computer, plays an important role in the operation of physical devices. Software was originally developed with the ability to perform extremely small or simple functions. Currently, however, embedded systems that perform multiple functions are being developed. With the rapid development of the software market, technology has also developed, and software is now being used in all fields. Recently, the Internet of Things (IoT) based on the combination of various software, has been commercialized. Furthermore, AIoT (Artificial Intelligence of Things) combined AI (Artificial Intelligence) with IoT (Intelligence of Things) is developing [1]. It means that software has become a very important part not only in the industrial field but also in our daily life.

A software failure is caused by various faults (coding or system errors, etc.). In the past, software failures caused relatively small losses because the degree of software dependence was not as large. However, in today's world, the degree of dependence on software is extremely high, and thus software failures can cause significant social and economic losses. Therefore, we measured the software reliability, which indicates the ability of a software program to avoid failure for a set period of time and refers to how long the software can be used without such a failure.

**Citation:** Kim, Y.S.; Song, K.Y.; Pham, H.; Chang, I.H. A Software Reliability Model with Dependent Failure and Optimal Release Time. *Symmetry* **2022**, *14*, 343. https://doi.org/ 10.3390/sym14020343

Academic Editor: Ming-Chin Chuang

Received: 31 December 2021 Accepted: 7 February 2022 Published: 8 February 2022

**Publisher's Note:** MDPI stays neutral with regard to jurisdictional claims in published maps and institutional affiliations.

**Copyright:** © 2022 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (https:// creativecommons.org/licenses/by/ 4.0/).

Early research on software reliability was conducted based on the assumption that software failures occur independently. Goel and Okumoto proposed the GO model, which is the most basic non-homogeneous Poisson process (NHPP) software reliability growth model [2]. The Hossain, Dahiya, Goel and Okumoto (HDGO) model further extended the GO model [3]. Yamada et al., Ohba, and Zhang et al. [4–6] proposed an NHPP S-shaped curve model in which the cumulative number of software failures increases to the S curve. In addition, Yamada et al. [7] proposed a new model in which the test effort invested during phase was reflected in the software reliability model. It is a model that reflects even the resources consumed for testing in the previously developed model. Furthermore, Yamada et al. [8] developed a software reliability model with a constant fault detection rate of *b*(*t*) = *b*, assuming incomplete debugging, in which faults detected during the test phase were corrected and removed.

The model developed by extending the above approach involved a generalized incomplete debugging-error detection rate model. Here, the fault detection rate *b*(*t*) of the model is not a constant but rather a different function [9–14]. It started from the software error causing the failure being immediately eliminated and so a new error can be generated [9]. It progressed to that during the fault removal process, whether the fault is removed successfully or not, new faults are generated with a constant probability [13,14]. In addition, because the operating environment of the software is operated differently for each software program, a comparison is difficult to achieve. Therefore, in [15–17], a software reliability model was developed considering uncertain factors in the operating environment. Currently, research using non-parametric methods such as deep learning or machine learning is also being conducted [18–21].

Recently, finding the most optimal model for reliability prediction is an important concern. Through combination of analytic hierarchy method (AHP), hesitant fuzzy (HF) sets and techniques for order of preference by similarity to ideal solution (TOPSIS), Sahu et al., Ogundoyin et al., and Rafi et al. [22–24] found the most optimal software reliability model.

However, software failures often occur in a dependent manner because the developed software is composed of extremely complex structures [25]. Here, the dependent failure means that one failure affects other failures or increases the failure probability of other equipment [26,27]. There are two main types of dependent failure. A common cause failure is when several pieces of software fail simultaneously due to a common cause, and a cascading failure is a case in which a part of the system fails and affects other software as well. A software reliability model assuming a dependent failure was developed from the number of software failures and the fault detection rate, which have a dependency relationship in a software reliability model assuming incomplete debugging [28]. In addition, Lee et al. [29] presented a model that assumes that if past software failures are not corrected well, they will continue to have an effect.

In this study, a new software reliability model is developed under the assumption that software failures occur in a dependent manner. It is suitable for a general environment. We show the superiority of the newly developed dependent software reliability model through a comparison under various criteria. In addition, determining the optimal release time of the developed software is also important. If the test period is long, the software will be reliable, but the software development cost will increase. If the test period is short, the reliability of the product may decrease. Therefore, it is important to find a balance between time to market and minimum cost taking into account the installation costs, test costs, and error removal costs, etc. We propose a cost model that combines the proposal software reliability model and the cost coefficient [30–33]. In addition, among the various parameters of the proposed model, we propose a parameter that has a significant influence on predicting the number of cumulative failures through a variation in the cost model for changes in the parameters [34,35]. Section 2 introduces a new dependent software reliability model and its mathematical derivation. Section 3 introduces the data and criteria, as well as numerical results. Section 4 describes the optimal release time, and finally, in Section 5, we present our conclusions

#### **2. New Dependent Software Reliability Model**

Software reliability refers to the probability that the software will not fail a system for a certain period of time under certain conditions. In other words, it evaluates "how long the software can be used without failure". The reliability function used to evaluate this is as follows:

$$R(t) = P(T > t) = \int\_{t}^{\infty} f(u) du\tag{1}$$

This denotes the probability of the software operating without failure over a specific time *t*. Here, the probability density function *f*(*t*) assumes the software failure time or lifetime as a random variable *T*. When measuring reliability function *<sup>R</sup>*(*t*), it is assumed that it follows an exponential distribution with parameter *λ*. In addition, it is assumed that the number of failures occurring in given unit time is a Poisson distribution with parameter *λ*. When *λ* is a constant, it is the most basic form, and is called a homogeneous Poisson process. Extending this process, many researchers adapt a model where *λ* is an intensity function *λ*(*t*) that changes with time rather than a single constant by setting *λ* as a non-homogeneous Poisson process(NHPP) rather than as a homogeneous Poisson process.

$$\Pr\{N(t) = n\} = \frac{\{m(t)\}^n}{n!} e^{-m(t)}, n = 0, 1, 2, \cdots, \ t \ge 0 \tag{2}$$

In Equation (2), *N*(*t*) is the Poisson probability density function with the time dependent parameter *<sup>m</sup>*(*t*). The *m*(*t*) is a mean value function which is the integral of *λ*(*t*) from 0 to *t* in Equation (3). The *λ*(*t*) is the intensity function indicating the number of instantaneous failures at time *t*.

$$m(t) = \mathbb{E}[N(t)] = \int\_0^t \lambda(s)ds\tag{3}$$

A general class of NHPP software reliability models was proposed by Equation (9) to summarize the existing NHPP models as follows:

$$\frac{dm(t)}{dt} = b(t)[a(t) - m(t)]\tag{4}$$

where, the *m*(*t*) is calculated using the relationship between the number of failures *a*(*t*) at each time point and a fault detection rate *b*(*t*) assuming point symmetry in Equation (4). Various software reliability models have been developed based on the assumption that software failures occur independently.

However, software failures occur not only independently but also dependently. If the failure is not completely fixed, it will continue to affect the next failure. In addition, as the system becomes more complex, the relationship between failure and failure also shows the dependent relationship because of the dependent combination of several software. Therefore, in this study, we assume that failure is dependent on other failures. The mean value function *m*(*t*) based on NHPP software reliability model using the differential equation is as follows:

$$\frac{dm(t)}{dt} = b(t)[a(t) - m(t)]m(t)\tag{5}$$

In Equation (5), the *m*(*t*) is multiplied once more to assume that the failure occurring from 0 to *t* affects another failure. We assume:

$$a(t) = a(1+at), \ b(t) = \frac{b}{1+ct^{-bt}} \tag{6}$$

where, *a*(*t*) is the number of software failures at each time point and *b*(*t*) is the fault detection rate. Parameter *a* is the expected number of faults, *α* is the increasing rate of the number of faults, *b* is the shape parameter, and *c* is the scale parameter. When time *t* changes, the change according to the values of parameters *b* and *c* in the fault detection rate *b*(*t*) are as shown in Figure 1. When *b* is 1, it is blue, and when it is 1.5, it is red. In addition, when *c* is 1, it is a dashed line, and when it is 2, it is a dotted line. It can be seen that the larger *b* is, the larger the *b*(*t*) is.

**Figure 1.** *b*(*t*) according to the changes in parameters *b* and *c*.

When solving the differential equation by substituting *a*(*t*) and *b*(*t*) for *m*(*t*) in Equations (5) and (6), we obtain Equation (7):

$$m(t) = \frac{\left(c + \varepsilon^{bt}\right)^{a} \left(\frac{\varepsilon + \varepsilon^{bt}}{\varepsilon}\right)^{aat} e^{\frac{a\varepsilon I\_{2}\left(\frac{bt}{\varepsilon} + \varepsilon\right)}{b}}}{\int \frac{\left(c + \varepsilon^{bt}\right)^{a} \left(\frac{\varepsilon + \varepsilon^{bt}}{\varepsilon}\right)^{aat} \frac{a\varepsilon I\_{2}\left(\frac{\varepsilon^{bt} + \varepsilon}{\varepsilon}\right)}{b}}} \tag{7}$$

where *Lis*(*x*) = ∑∞*<sup>n</sup>*=<sup>1</sup> *xnns* is a polylogarithm when *s* = 2. At this time, *α* = 0 in *<sup>a</sup>*(*t*).

$$m(t) = \frac{h\left(c + e^{ht}\right)^d}{h\left[\int\_0^t \frac{\left(e^{hx} + c\right)^a h e^{hx}}{c + e^{hx}} dx\right] + \left(1 + c\right)^d} \tag{8}$$

where *h* is the number of initial failures. In Equation (8), 5 *t*0 (*ebx*+*c*)*abebx c*+*ebt dx* is calculated through an integration using substitution. When *u* = *c* + *bebx* and *du* = *bebxdx*, it is the same as in Equation (9).

$$\int\_0^l \frac{\left(\mathbf{c^{bx}} + \mathbf{c}\right)^a b \mathbf{c^{bx}}}{\mathbf{c} + \mathbf{c^{bt}}} d\mathbf{x} = \int\_{\mathbf{c} + \mathbf{b}}^{\mathbf{c} + \mathbf{b} \mathbf{c^{bt}}} \frac{\mathbf{u}^a}{\mathbf{u}} d\mathbf{u} = \int\_{\mathbf{c} + \mathbf{b}}^{\mathbf{c} + \mathbf{b} \mathbf{c^{bt}}} \mathbf{u}^{a - 1} d\mathbf{u} = \frac{\mathbf{u}^a}{a} = \frac{\left(\mathbf{c} + \mathbf{c^{bt}}\right)^a}{a} \tag{9}$$

Substituting the result of the substitution integration into Equation (8), the final *m*(*t*) is given by Equation (10).

$$m(t) = \frac{a}{1 + \frac{a}{t} \left(\frac{1+c}{c+c^{kt}}\right)^a} \tag{10}$$

This can be presented as a general model of a dependent failure occurrence in the software reliability model. When *t* = 0, *m*(*t*) is *m*(0) = *ah*/(*a* + *h*). Table 1 shows the value of *m*(*t*) of the existing software reliability model and the model proposed in this study. From models 19–22, it is assumed that a failure occurs in a dependent manner.


**Table 1.** Software reliability models.
