Discrete Time-Space Stochastic Mathematical Modelling for Quantitative Description of Software Imperfect Fault-Debugging with Change-Point

—Statistics and stochastic-process theories, along with the mathematical modelling and the respective empirical evidence support, describe the software fault-debugging phenomenon. In software-reliability engineering literature, stochastic mathematical models based on the non-homogeneous Poisson process (NHPP) are employed to measure and boost reliability too. Since reliability evolves on account of the running of computer test-run, NHPP type of discrete time-space models, or difference-equation, is superior to their continuous time-space counterparts. The majority of these models assume either a constant, monotonically increasing, or decreasing fault-debugging rate under an imperfect fault-debugging environment. However, in the most debugging scenario, a sudden change may occur to the fault-debugging rate due to an addition to, deletion from, or modification of the source code. Thus, the fault-debugging rate may not always be smooth and is subject to change at some point in time called changepoint. Significantly few studies have addressed the problem of change-point in discrete-time modelling approach. The paper examines the combined effects of change-point and imperfect fault-debugging with the learning process on software-reliability growth phenomena based on the NHPP type of discrete time- space modelling approach. The performance of the proposed modelling approach is compared with other existing approaches on an actual software-reliability dataset cited in literature. The findings reveal that incorporating the effect of change-point in software-reliability growth modelling enhances the accuracy of software-reliability assessment because the stochastic character- istics of the software fault-debugging phenomenon alter at the change-point.


I. INTRODUCTION
Today, computer-based software systems are indispensable, and their successful operation depends mainly on software. A fault can be introduced at any point during the software development life cycle (abbreviated as SDLC) due to the deficiency of human-being. A failure is a consequence of a fault. The software development process's testing phase aims at debugging faults. Software reliability is typically defined as a statistical measure of a software system's ability to operate failurefree. To quantify software reliability, a number of analytical approaches to mathematical modelling the stochastic-behavior * Corresponding author. of software debugging phenomenon have been proposed. Nonhomogeneous Poisson process (abbreviated as NHPP) models are widely used in software-reliability engineering to quantitatively express reliability. They are broadly divided into discrete time-space and continuous time-space groups. However, discrete time-space models which adopt the number of executed computer test-run as a unit of fault-debugging period are more suited than their continuous time-space counterparts. Despite the difficulties in formulating them, many studies have highlighted their usefulness [1]- [4].
Several existing NHPP stochastic software-reliability models are based on constant or monotonically increasing faultdebugging rates under perfect and imperfect fault-debugging environments [1], [3], [5]- [16]. In practice, as the debugging grows, a sudden change may take place to the fault-debugging rate as a result of an addition to, deletion from, or modification of the source code. Thus, the fault-debugging rate may not always be smooth and is subject to change at some point in time called change-point [1], [17]- [23]. Many studies argue that considering the change-point concept in imperfect fault-debugging is expected to enhance the software-reliability assessment accuracy due to the stochastic characteristics of software fault-debugging phenomenon changed at the changepoint. Thus, the incorporation of change-point provides a notable enhancement in the reliability assessment. However, most of the endeavors are in continuous time-space. Lately, this area has received little attention and few studies have incorporated the change-point concept in developing discrete time-space software-reliability modelling [1], [24], [25]. However, the study of the change-point problem is still very limited in the discrete-time modelling approach. As a result, the paper studies the effect of incorporating a change-point concept in modelling the imperfect fault-debugging phenomenon.
The rest of the paper is structured as follows: Section II reviews related work and models the change-point problem into an imperfect fault-debugging environment through a discrete time-space NHPP based approach. Data analyses and parameter estimation techniques, model validation, comparison criteria, and software-reliability measures are discussed in Sections III and IV, respectively. The descriptive-performance and predictive-capability, and software-reliability evaluation measures based on the proposed modelling approach are shown in Section V. Finally, Section VI concludes the paper and presents future works. In this approach, we model the debugged faults by n computer test-run as a pure-birth counting process (N n ; n ≥ 0), [1]- [3] subject to • No fault debugged at n = 0, that is, N (0) = 0.
• For any number of computer test-run n i and n j , where here λ be the fault-debugging intensity function.
Accordingly, the NHPP software-reliability model can be formulated here N n be the expected value number of faults whose meanvalue function (abbreviated as MVF) is known as m n .

A. Model Development
In this section, we review some of the well-documnetd NHPP type of discrete time-space models 1) Exponential Model [3], [26]: This model considers that the average number of faults debugged between n th and the (n + 1) th computer test-run, is corresponding to the current number of undebugged faults after the execution of the n th computer test-run, meets the resulting difference equation: here a be a fault-content, and the constant b represents a faultdebugging per undebugged faults per test case.
To solve the difference equation (3), we employ the probability generating function (abbreviated as PGF) computational technique, multiply both sides by w n , and sum over n from 0 to ∞, we get: Comparing the coefficients of like powers of w on both sides in (4) and under the initial-condition m n=0 = 0, yields The closed-form solution, by mathematical-induction, obtained as Accordingly, the fault-debugging intensity function is The equivalent continuous time-space model [27] corresponding to (6) is which derived as a limiting case of discrete time-space model substituting t = nδ, lim x→0 (1 + x) 1/x = e, and taking limit δ → 0.
2) Delayed S-shaped Model [1], [16]: This model considers that the fault-debugging phenomenon as a two-stage process namely, detection and correction. Accordingly, we have Solving the system of difference equation (9), using the PGF computational technique in terms of the initial condition that at n = 0, m d (n) = m c (n) = 0, we can obtain the closedform exact solution as An alternate formulation of (9), to obtain it in single stage, is Solving (11), using the PGF computational technique in terms of the initial condition that at n = 0, m n = 0, we can obtain the closed-form exact solution as It can be noticed that (12) and (11) are same.
3) Inflection S-shaped Model [1], [29], [30]: The primary assumption of the models mentioned above is that the fault-debugging rate depends linearly upon the number of undebugged faults. In practice, it has been observed that as debugging progress, the fault debugging rate has three possible trends: decreasing, constant, and increasing. To analyze these trends, we interpret the fault debugging rate as a function of the number of executed computer test-run. Accordingly, we have the following difference equation: Solving (15), using the PGF computational technique in terms of the initial condition that at n = 0, m n = 0, we can obtain the closed-form exact solution as The growth curve's shape is determined by the parameters b i and b f and can be either exponential or S-shaped. However, (16) can be rewritten to define a constant fault-debugging rate, as An alternate formulation of the model, where the faultdebugging rate per undebugged fault, b n+1 , is a non-decreasing S-shape curve that captures the learning-process phenomenon of the debugging-team, as Substituting (18) in (15) and solving using the PGF computational technique in terms of the initial condition that at n = 0, m n = 0, we can obtain the closed-form exact solution as Setting (19) and (16) are identical.
The fault-debugging rate for the above-specified model is a logistic function and b n+1 → b as n → ∞. here β is the learning factor, and it represents the skill and experience gained by the debuggers during debugging. If β = 0, then b n+1 = b, that is, constant. The fault-debugging intensity function can be obtained as The equivalent continuous time-space model [1], [16], [31] corresponding to (19) or (16) is which derived as a limiting case of discrete time-space model substituting t = nδ, lim x→0 (1 + x) 1/x = e, and taking limit δ → 0. [29], [30]: The primary assumption of the models mentioned above is that the debugged fault is perfectly-debugged with certainty. However, due to human-imperfection and softwarecomplexity, the debugging-team incapable to debug the faultperfectly, and the debugged fault persist, resulting in a phenomenon known as imperfect fault-debugging. As a result, we write

4) Imperfect Fault-Debugging Inflection S-shaped Model
here p is the probability of perfectly debugging the fault.
Solving (22), using the PGF computational technique in terms of the initial condition that at n = 0, m n = 0, we can obtain the closed-form exact solution as The equivalent continuous time-space model [1], [32] corresponding to (23) is which derived as a limiting case of discrete time-space model substituting t = nδ, lim x→0 (1 + x) 1/x = e, and taking limit δ → 0.
In the following section, the approach is extended to address the concept of the change-point.

B. Model Formulation
In addition to the software-reliability models above, several models assume a constant or monotonically increasing fault-debugging rate. However, in reality, as the debugging progress, the fault-debugging rate function may be changed at some point in time. The change point's position need not be estimated; it can be judged from the plotted graph of the actual software-reliability data or using a change point analyzer tool. To incorporate the change-point concept in (26), both fault-debugging rate and probability of perfect fault-debugging before and after the change-point τ , are subject to change. Accordingly, we write here b 1 (b 2 ) represent the fault-debugging rates before(after) the change-point, p 1 (p 2 ) represent the probability of perfect faultdebugging before(after) the change-point, and the change-point τ represents the computer test-run number from whose execution onwards change in the fault-debugging rate is noticed.
Substituting (25) in (22) and solving using the PGF computational technique in terms of the initial conditions at n = 0, m n = 0 and at n = τ , m n = m τ respectively, we can obtain the closed-form exact solution as (IJACSA) International Journal of Advanced Computer Science and Applications, Vol. 12, No. 6, 2021 when n ≥ τ here α 1 = 1 − δb 1 p 1 and α 2 = 1 − δb 2 p 2 The proposed modelling approach given by (26) integrates the joint effects of change-point concept and learning of the debugging personnel in an imperfect fault-debugging environment into software-reliability modelling.

III. DATA ANALYSES AND PARAMETER ESTIMATION TECHNIQUES
To evaluate the progress of the debugging-process during the testing phase of the SDLC, reliability trend analysis is employed. Therefore, before applying the model, it is reasonable to decide whether the dataset exhibits software-reliability growth. In other words, assessing reliability is pointless if the software-reliability dataset during debugging does not exhibit growth. The trend tests that are widely adopted with f fault debugged are [2], [11], [33]: • Arithmetic Average Test.
Decreasing values promote reliability growth.
Negative values promote reliability growth.
To estimate the unknown parameters of the softwarereliability models, either the maximum likelihood estimate (abbreviated as MLE) or the least-square estimate (abbreviated as LSE) methods is employed. Software reliability dataset can be collected during debugging in the form of ordered pairs (n i , y i ),(i = 0, 1, 2, . . . , f ) where y i is the cumulative number of faults debugged by n i computer test-run (0 < n 1 < n 2 < . . . < n f ). Table I tabulated the software-reliability dataset used. The dataset had been obtained in twenty weeks of debugging release 1 of Tandem computer project, and 100 faults were debugged [34]. In other words, the dataset consisted of 20 data pairs (n i , y i ), (i = 0, 1, 2, . . . , 20; n 20 = 20; y 20 = 100). To fit and estimate the parameters of the models, all data points have been utilized. The graphical plot of the dataset reveals a change-point occurs in the 11 th week of debugging, that is, τ = 11.
The Likelihood function L for the unknown parameters with the MVF, that is, m n takes on the form: The statistical package for social sciences (abbreviated as SPSS) is applied to estimate the software-reliability model's parameters for quicker and more precise computations.

A. Goodness-of-Fit Criteria
To test the validity of the proposed modelling approach in (26), we evaluate three goodness-of-fit test indices based on a real software-reliability dataset [34]. The goodness-of-fit test indices adopted for the purpose are [1]- [3]: • Sum of squared error (abbreviated as SSE). It assesses the dispersion between estimated values m ni and the actual data y i of the dependent variable.
• The Akaike information criterion (abbreviated as AIC). AIC = −2logL + 2N (31) here N is the number of parameters of a model and the likelihood function L for the parameters with the MVF in (29).
• Root mean square prediction error (abbreviated as RMSPE). where • Coefficient of multiple determination (abbreviated as R 2 ).
It should be noted that the smaller value of SSE, AIC and RMSE, indicates the better the fit of the model. On the contrary, the larger the value of R 2 indicates better the fit of the model.

B. Predictive Validity Criterion
The predictive validity of the software-reliability model is defined as its ability to predict the future behavior of the debugging process based on its current and past behavior [35]. Suppose we have corrected x f faults after the execution of the last computer test-run n f . First, we utilize the softwarereliability dataset up to a computer test-run say n e (≤ n f ) to obtain the MVF, that is, m n f . Then, put estimated values in m n to obtain the number of faults corrected by n f . Next, we compare it with the actually corrected number x f . Last, his method is iterated for different values of n e . The predicted relative error (abbreviated as PRE) is given as When the PRE value is positive/negative, the model overestimates or underestimates the future debugging phenomenon. Acceptable values are within the range ±10% [1], [2], [16].

C. Software-Reliability Evaluation Measures
Based on Section II, the following quantitative assessment are derived [1]- [3], [26]: • Number of residual faults. Let ξ(t) denotes the number of residual faults after the executing of the computer test-run n th , then here a ∞ denotes the number of faults eventually corrected.
• Software-reliability. The probability of no faults debugged between the n th and (n+n • ) th computer testrun, given that x d faults have been debugged by the n th computer test-run, is here n • (n • ≥ 0) is the mission time.

V. DATASET ANALYSES AND MODEL COMPARISON
To validate the proposed modelling approach, we perform the following dataset analyses and model comparisons. First, we use both of the trend tests presented in Section III to determine whether or not the given software-reliability dataset promotes reliability growth. The parameters of the models under comparison [1], [3], [16], [26], [30] including the proposed modelling approach given in (26) are then estimated using SPSS. Then we perform the goodness-of-fit test described in Section IV-A. Based on the obtained results, we conduct a comparative assessments of the models under comparison. Finally, for the proposed modelling approach, we perform the predictive-validity test described in Section IV-B and estimate the software-reliability evaluation measures defined in Section IV-C.
It is worth noting that, while formulating the proposed modelling approach, we set δ = 1 for simplification and τ = 11 by following the stochastic-behavior of debugging phenomenon on the basis of the adopted dataset.
• The proposed modelling approach given in (26).

A. Software-Reliability Trend Analysis
The fitting result of the reliability dataset for arithmetic average and Laplace trend tests are demonstrated in Fig. 1 and 2, respectively. It is quite clear that the arithmetic average and the Laplace trend factor values are decreasing and entirely negative from the beginning, respectively. Negative Laplace factor values indicate that more faults were debugged in the first half of the debugging time, indicating an increase in reliability. Thus, they point to growth in reliability. Consequently, the dataset is suitable for applying software-reliability models. Table II shows the estimated parameters of the models under comparison using the statistical package statistical package for social sciences (abbreviated as SPSS) and their goodnessof-fit test indices. It can be seen that, when compared to all other models using the SSE, AIC, RMSPE, and R 2 indices, the proposed modelling approach has the lowest SSE, AIC and RMSPE values and the highest R 2 value. Therefore, among the models under comparison, the proposed modelling approach outperformed the others. The enhancement in the performance of the proposed modelling approach is attributed to the inclusion of the change-point concept in modelling software-reliability. These results agree with the findings of previously published works [1], [25].

B. Goodness-of-Fit Analysis
It is worth noting that the proposed modelling approach's estimated value of a is the closest to the number of debugged faults actually present in the software, and the fault-debugging rates b 2 < b 1 clearly show a varying trend that first increases and then decreases following the change-point with an Sshaped varying trend. The latter finding is attributed to the presence of imperfect fault-debugging and learning-process phenomena. Fig. 3 and 4 show the fitting results of the noncumulative and cumulative reliability dataset for the proposed modelling approach. It is quite clear that the proposed modelling approach fits the dataset perfectly.

C. Predictive Validity Analysis
To estimate the proposed modelling approach parameters, the software-reliability dataset is truncated into several parts. It is noticed that the PRE values differ from one truncation to the next. As a result, Fig. 5 depicts the fitting result of the predictive-validity of the proposed modelling approach.
It is noticed that the proposed modelling approach overestimates the debugging-process from the truncated n e (70% approx.) onwards. Therefore, the dataset is truncated at t e     (60% approx.) to obtain the whole dataset. The fitting result of the retrodictive and predictive capabilities is shown in Fig.  6. The points below n e (marked by the intersection of the horizontal line with the curve) show the retrodictive-capability while the points above n e show the predictive-capability of the proposed modelling approach.
The proposed modelling approach reveals that about 60% of the debugging-time is enough to predict the debuggingfuture process's behavior satisfactorily. Following the change-point, every three faults were debugged, one of which was imperfectly debugged according to the parameters' estimated values in Table II. Fig. 8 depicts the fitting result of the estimated software-reliability (three cases: when the mission time is one, two, and three days respectively) for the proposed modelling approach. It is noticeable that the proposed modelling approach reveals that software-reliability    These types of information provided by the proposed modelling approach enable the developer to decide how best to allocate resources during the software testing and maintenance phases of the SDLC.

VI. CONCLUSIONS
Quantitative measures provided by software-reliability models play a pivotal role in the decision-making process during testing and fault debugging-process. To some extent, the concept of change-point is novel in the discrete timespace software-reliability modelling approach. The NHPP type of discrete time-space software-reliability modelling is welldocumented with well-established concepts in the softwarereliability engineering literature and can be used to describe the stochastic-behavior of the fault-debugging process.
The proposed discrete time-space NHPP based stochastic software-reliability model integrates the debugger's learning phenomenon with a single change-point under an imperfect fault-debugging environment. The results explained through a numerical example in the tables and figures provided in Section V are encouraging compared with other wellestablished models built under imperfect and perfect faultdebugging environments. The conducted numerical example concludes that incorporating the concept of change-point into software-reliability modelling yields the most promising results concerning the descriptive and predictive performances of the proposed modelling approach and software-reliability quantitative measures. As a result, the paper demonstrates a high level of numerical agreement between the results of the proposed modelling approach obtained here and other results presented in the literature.
Finally, the paper shows how starting with fundamental assumptions, the discrete time-space NHPP based modelling approach is becoming more useful with the inclusion of the learning process in debugging and introducing the changepoint concept in an imperfect fault-debugging environment. However, we confined ourselves to introducing just a single change-point, and we did not consider the debugging effort expenditures. Hence, it is essential to track and account for the reliability growth concerning the costs spent on software www.ijacsa.thesai.org debugging. Studying the effect of multiple change-point occurrences and software debugging efforts on reliability growth is an ongoing and future research effort.