Search

Open Source Software (OSS) is one of the most trusted technologies for implementing industry 4.0 solutions. The study aims to assist a community of OSS developers in quantifying the product's reliability. This research proposes reliability growth models for OSS by incorporating dynamicity in the debugging process. For this, stochastic differential equation-based analytical models are developed to represent the instantaneous rate of error generation. The fault introduction rate is modeled using exponential and Erlang distribution functions. The empirical applications of the proposed methodology are verified using the real-life failure data of the Open Source Software projects, GNU Network Object Model Environment, and Eclipse. A soft computing technique, Genetic Algorithm, is applied to estimate model parameters. Cross-validation is also performed to examine the forecasting efficacy of the model. The predictive power of the developed models is compared with various benchmark studies. The data analysis is conducted using the R statistical computing software. The results demonstrate the proposed models' efficacy in parameter estimation and predictive performance. In addition, the optimal release time policy based on the proposed mathematical models is presented by formulating the optimization model that intends to minimize the total cost of software development under reliability constraints. The numerical illustration and sensitivity analysis exhibit the proposed problem's practical significance. The findings of the numerical analysis exemplify the proposed study's capability of decision-making under uncertainty. [ABSTRACT FROM AUTHOR]

In the current technological era, the reliability growth model depicts the failure in software that is employed for estimating the reliability of software. Conventional software reliability growth model (SRGMs) usually presume that faults in software are immediately corrected once a software fault is found and no new faults are introduced. This consideration can be impractical. However, introduction of several new faults is possible throughout debugging, which is called imperfect debugging. During such a process of debugging and introduction of new faults, consumption of testing effort also plays an important role. Hence, in this paper, two models are proposed that incorporate testing effort along with imperfect debugging during fault correction. Additionally, the combined testing effort is the addition of two efforts, specifically detection effort as well as correction effort. The formulated models are validated for real data set and contrasted with additional famous SRGMs. These inferences indicate that Model 2 performs best in terms of fitting and prediction capability. [ABSTRACT FROM AUTHOR]

Research on software reliability growth models (SRGMs) has been extensively conducted for decades, and the models were often developed based on two assumptions: (1) once the errors are detected, they can be completely removed instantly, and (2) errors can be removed eternally, and the debugging tasks will not produce any new errors. However, both assumptions are unrealistic. This study proposes an SRGM that ignores these restricted assumptions by introducing a detection process that may remove an error after a period of time once it has been detected and by considering imperfect debugging, which indicates that new errors may emerge through corresponding debugging tasks. In addition, because software can be upgraded to respond on a timely basis to constantly changing consumer expectations and thus extend product life in the market, the proposed SRGM also considers software upgrades for the multiversion software, and a dynamic programming approach is used to effectively obtain the optimal release schedule with consideration of the constraint of budget. Real data sets are used to examine the effectiveness of the proposed model, and the fitting results show that the proposed model outperforms other existing models. The results of numerical validation indicate that the proposed dynamic programming method with information updating outperforms the sequential solution method in determining the optimal release time for each version. Moreover, decision makers should carefully evaluate the parameters because overestimating the parameters of the mean value functions will cause serious software risk due to excessively shortening the testing time. History: Accepted by Pascal Van Hentenryck, Area Editor for Computational Modeling: Methods & Analysis. Supplemental Material: The software that supports the findings of this study is available within the paper and its Supplemental Information (https://pubsonline.informs.org/doi/suppl/10.1287/ijoc.2021.0141) as well as from the IJOC GitHub software repository (https://github.com/INFORMSJoC/2021.0141). The complete IJOC Software and Data Repository is available at https://informsjoc.github.io/. [ABSTRACT FROM AUTHOR]

Copyright of Journal of Zhengzhou University (Natural Science Edition) is the property of Journal of Zhengzhou University (Natural Science Edition) Editorial Office and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Software debugging is the process of detecting and removing bugs during software development. Although the intent of modifications to the software is to remove bugs, one cannot rule out the possibility of introducing new bugs as a result of these modifications. We consider a self‐exciting point process, which can incorporate the case of reliability deterioration due to the potential introduction of new bugs to the software during the development phase. In order to account for the unobservable process of introducing bugs, latent variables are incorporated into the self‐exciting point process models. The models are then applied to two data sets in software reliability and additional insights that can be obtained from these models are discussed. Our results suggest that the self‐exciting processes with latent factors perform better than the standard point process models in describing the behavior of software failures during the debugging process. [ABSTRACT FROM AUTHOR]

Software reliability growth models (SRGMs) based on the non-homogeneous Poisson process have played a significant role in predicting the number of remaining errors in software, enhancing software reliability. Software errors are commonly attributed to the mental errors of software developers, which necessitate timely detection and resolution. However, it has been observed that the human error-making mechanism is influenced by factors such as learning and fatigue. In this paper, we address the issue of integrating the fatigue factor of software testers into the learning process during debugging, leading to the development of more realistic SRGMs. The first model represents the software tester's learning phenomenon using the tangent hyperbolic function, while the second model utilizes an exponential function. An exponential decay function models fatigue. We investigate the behavior of our proposed models by comparing them with similar SRGMs, including two corresponding models in which the fatigue factor is removed. Through analysis, we assess our models' quality of fit, predictive power, and accuracy. The experimental results demonstrate that the model of tangent hyperbolic learning with fatigue outperforms the existing ones regarding fit, predictive power, or accuracy. By incorporating the fatigue factor, the models provide a more comprehensive and realistic depiction of software reliability. [ABSTRACT FROM AUTHOR]

In this paper, a scheme for constructing software reliability growth model based on Non-Homogeneous Poisson Process is proposed. Here, we consider the software reliability growth model that incorporates with imperfect debugging, change point and testing effort. However, most researchers assume a constant detection rate per fault in deriving their software reliability models. They suppose that all faults have equal probability of being detected during the software testing process, and the rate remains constant over the intervals between fault occurrences. In reality, the fault detection rate strongly depends on the skill of test teams, program size, and software testability. Also in most realistic situations, fault repair has associated with a fault re-introduction rate due to imperfect debugging phenomenon. In this case, the fault detection rate and fault introduction rate will be changed during the software development process. Therefore, here we incorporate both generalized logistic testing-effort function, change-point parameter into software reliability modelling. The Least Square Estimation approach is used to estimate the unknown parameters of the new model. So in our new proposed model we collect software testing data from real application and utilize it to illustrate the proposed model. Experimental results show that the proposed framework to incorporate both testing-effort and change-point for Imperfect-Debugging SRGM has a fairly accurate prediction capability. [ABSTRACT FROM AUTHOR]

In order to further improve the fitting and prediction performance of the existing Non-Homogeneous Poisson Process class software reliability growth models, this paper first conducts an in-depth study of imperfect fault exclusion models from the perspective of the total number of faults growth trend. Considering the linear and differential relationships between the total number of faults function and the cumulative detected faults function, this paper proposes two general imperfect fault exclusion framework models, and the expressions of the cumulative detected faults and the total number of faults function in software are derived. Secondly, this paper compares the performance of the two general imperfect debugging models and the six imperfect debugging models proposed in this paper on six real failure datasets for fitting prediction performance. The results of the case validation show that the general imperfect debugging framework model proposed in this paper has excellent fitting and prediction performance on most of the failure datasets, which proves the effectiveness and practicality of the new modeling framework. Again, this paper presents an in-depth analysis of the performance of the model proposed in this paper and other imperfect debugging models on the datasets to suggest the selection of imperfect debugging models for practical applications. Finally, this paper prospects the future research directions of modeling imperfect debugging models. [ABSTRACT FROM AUTHOR]

Software reliability growth models (SRGMs) based on the non-homogeneous Poisson process have played a significant role in predicting the number of remaining errors in software, enhancing software reliability. Software errors are commonly attributed to the mental errors of software developers, which necessitate timely detection and resolution. However, it has been observed that the human error-making mechanism is influenced by factors such as learning and fatigue. In this paper, we address the issue of integrating the fatigue factor of software testers into the learning process during debugging, leading to the development of more realistic SRGMs. The first model represents the software tester’s learning phenomenon using the tangent hyperbolic function, while the second model utilizes an exponential function. An exponential decay function models fatigue. We investigate the behavior of our proposed models by comparing them with similar SRGMs, including two corresponding models in which the fatigue factor is removed. Through analysis, we assess our models’ quality of fit, predictive power, and accuracy. The experimental results demonstrate that the model of tangent hyperbolic learning with fatigue outperforms the existing ones regarding fit, predictive power, or accuracy. By incorporating the fatigue factor, the models provide a more comprehensive and realistic depiction of software reliability.

Due to the continuous dependence of society on technology and the fast growth of Open Source Software (OSS), there is a need for the software industry to shift to multi‐release software development. To include the revisions in user demands and testing environment, factors that affect OSS reliability have to be considered. Here, we propose a quantitative method for assessing the reliability of multi‐release OSS by using Software Reliability Growth Models based on the Non‐Homogenous Poisson Process. Various factors like imperfect debugging, error generation, change‐point have been considered. The model has been estimated on Statistical Package for Social Sciences using three releases of the Apache dataset. It is concluded that the results obtained are improved than the existing ones. [ABSTRACT FROM AUTHOR]

In the software development life cycle, the quality and reliability of software are critical to software developers. Poor quality and reliability not only cause the loss of customers and sales but also increase the operational risk due to unreliable codes. Therefore, software developers should try their best to reduce such potential software defects by undertaking a software testing project. However, to pursue perfect and faultless software is unrealistic since the budget, time, and testing resources are limited, and the software developers need to reach a compromise that balances software reliability and the testing cost. Using the model presented in this study, software developers can devise multiple alternatives for a software testing project, and each alternative has its distinct allocation of human resources. The best alternative can therefore be selected. Furthermore, the allocation incorporates debuggers' learning and negligent factors, both of which influence the efficiency of software testing in practice. Accordingly, the study considers both human factors and the nature of errors during the debugging process to develop a software reliability growth model to estimate the related costs and the reliability indicator. Additionally, the issue of error classification is also extended by considering the impacts of errors on the system, and the expected time required to remove simple or complex errors can be estimated based on different truncated exponential distributions. Finally, numerical examples are presented and sensitivity analyses are performed to provide managerial insights and useful directions to inform software release strategies. [ABSTRACT FROM AUTHOR]

In this study, an imperfect debugging software reliability growth model (SRGM) with Bayesian analysis was proposed to determine an optimal software release in order to minimize software testing costs and also enhance the practicability. Generally, it is not easy to estimate the model parameters by applying MLE (maximum likelihood estimation) or LSE (least squares estimation) with insufficient historical data. Therefore, in the situation of insufficient data, the proposed Bayesian method can adopt domain experts' prior judgments and utilize few software testing data to forecast the reliability and the cost to proceed with the prior analysis and the posterior analysis. Moreover, the debugging efficiency involves testing staff's learning and negligent factors, and therefore, the human factors and the nature of debugging process are taken into consideration in developing the fundamental model. Based on this, the estimation of the model's parameters would be more intuitive and can be easily evaluated by domain experts, which is the major advantage for extending the related applications in practice. Finally, numerical examples and sensitivity analyses are performed to provide managerial insights and useful directions for software release strategies. [ABSTRACT FROM AUTHOR]

Due to change requests for up-gradation of adding new features, software organizations always develop new versions of the software by adding new features and improving the existing software. Various software reliability growth models have been proposed considering realistic issue which affects the reliability growth of software. Testing coverage is a crucial realistic issue that influences the fault detection and correction process. The difficulty level for removing different faults is different, same kind of testing coverage function can't capture the fault detection process for all types of faults. Also, there exist random effects in the field environment due to the change between the testing environment and the operational environment. This randomness also affects the reliability growth of software. In this paper, a software reliability growth model has been proposed considering imperfect debugging, faults removal proportionality, two types of testing coverage function in the presence of random effect of the testing environment. Here different categories of faults have been considered. Though reliability is an important issue for software professionals, they are worried about the optimal release of software at an optimal cost. Considering the testing cost and debugging cost random, a cost model has been proposed for release time analysis. [ABSTRACT FROM AUTHOR]

In this research, a novel approach is developed where a testing team delivers the software product first and extends the testing process for additional time in the user environment. During the operational phase, users also participate in the fault detection process and notify the defects to the software. In this study, a reliability growth model is proposed using a unified approach based on the expenditure of efforts during the testing process. Besides, debugging process is considered imperfect as new faults may enter the software during each fault removal. The developed model further considers that the developer’s rate of defect identification changes with a software release. Thus, the software time-to-market acts as a change-point for the failure observation phenomenon. It is asserted that the accuracy of a software reliability estimation improves by implementing the concept of change-point. The main aim of the paper is to evaluate the optimal release time and testing termination time based on two attributes, particularly, reliability, and cost. A multi-attribute utility theory (MAUT) is applied to find a trade-off between the two conflicting attributes. Finally, a numerical example is presented by using the historical fault count data. The behavior of two decision variables is measured and compared with the existing release time strategy.

In software engineering literature, numerous software reliability growth models have been designed to evaluate and predict the reliability of the software products and to measure the optimal time-to-market of the software systems. Most existing studies on software release time assessment assumes that when software is released, its testing process is terminated. In practice, however, the testing team releases the software product first and continues the testing process for an added period in the operational phase. Therefore, in this study, a coherent reliability growth model is developed to predict the expected reliability of the software product. The debugging process is considered imperfect as new faults can be introduced into the software during each fault removal. The proposed model assumes that the fault observation rate of the testing team modifies after the software release. The release time of the software is therefore regarded as the change-point. It has been established that the veracity of the performance of the growth models escalates by incorporating the change-point theory. A unified approach is utilized to model the debugging process wherein both testers and users simultaneously identify the faults in the post-release testing phase. A joint optimization problem is formulated based on the two decision criteria: cost and reliability. In order to assimilate the manager’s preferences over these two criteria, a multi-criteria decision-making technique known as multi-attribute utility theory is employed. A numerical illustration is further presented by using actual data sets from the software project to determine the optimal software time-to-market and testing termination time.

Summary: This paper proposes a generalization of the exponential software reliability model to characterize several factors including fault introduction and time‐varying fault detection rate. The software life cycle is designed based on module structure such as testing effort spent during module testing and detected software faults etc. The resource allocation problem is a critical phase in the testing stage of software reliability modelling. It is required to make decisions for optimal resource allocation among the modules to achieve the desired level of reliability. We formulate a multi‐objective software reliability model of testing resources for a new generalized exponential reliability function to characterizes dynamic allocation of total expected cost and testing effort. An enhanced particle swarm optimization (EPSO) is proposed to maximize software reliability and minimize allocation cost. We perform experiments with randomly generated testing‐resource sets and varying the performance using the entropy function. The multi‐objective model is compared with modules according to weighted cost function and testing effort measures in a typical modular testing environment. [ABSTRACT FROM AUTHOR]

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. [ABSTRACT FROM AUTHOR]

With the current advancement of technology, real-time software has been extensively utilized in several complex systems. The eternally rising complexity of software formulates it exceptionally hard to maintain the reliability of software and has strained extraordinary awareness in software industries. Nearly all reliability-based software reliability growth models (SRGMs) are formulated using a general consideration that during the testing phase, all detected faults are instantly corrected without introducing any new fault. Therefore, both detection and correction of faults are considered as similar processes. In this paper, inclusive modeling is done for investigating the detection and correction of faults under an imperfect debugging scenario. This formulation is modeled by considering the postulation that new faults are involved throughout the correction of a hard type of fault. Numerous qualitative measures for assessment of reliability are considered and least square estimations of unidentified model parameters are assessed. The validation of the derived proposed models is verified through actual datasets. The measures of accuracy are the mean square error (MSE), root mean square error (RMSE), bias, variance and root mean square prediction error (RMSPE) are calculated employing valid datasets. The goodness of fit criteria is verified based on such qualitative measures. [ABSTRACT FROM AUTHOR]

With the improvement of innovation, software developers consistently build up a new version of software by adding new features in the previously existing version of the software. In resent day's competitive market, the reliability and release time of multi‐upgradation software are very important issues to both: customers and developers. Many researchers have proposed various software reliability growth models (SRGMs) to improve the precision of assessing the reliability of programming. For reliability estimation, a detailed study is necessary to know the characteristics of different types of faults. It has been noticed that some faults present in software remove independently at the same time some faults remove some other faults. During upgradation, new faults generate due to many reasons. Though dependency of faults is an important issue, there is no such SRGM exist for multi‐release problem. Hence, an SRGM has been proposed for multi‐release problems here with the dependency of faults under the imperfect debugging phenomenon. The effect of change point has been incorporated in SRGM due to changes in testing strategy, changes in testing environments, and so forth, during up‐gradation. Based on datasets, it can be said the performance of the proposed model is better than some other existing models. Also, it is very important for software companies to know the optimal time of release a new version of software. As testing charges change with time, it cannot be constant throughout testing phase. Hence, a new random cost model has also been proposed for release time analysis in case of a multi‐release problem. [ABSTRACT FROM AUTHOR]

This paper proposes a generalized model to cover imperfect debugging and the uncertainty of the 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 developed 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 the uncertain 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 environments, which provides the flexibility in considering a 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. The 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 study, an imperfect debugging software reliability growth model (SRGM) with Bayesian analysis was proposed to determine an optimal software release in order to minimize software testing costs and also enhance the practicability. Generally, it is not easy to estimate the model parameters by applying MLE (maximum likelihood estimation) or LSE (least squares estimation) with insufficient historical data. Therefore, in the situation of insufficient data, the proposed Bayesian method can adopt domain experts’ prior judgments and utilize few software testing data to forecast the reliability and the cost to proceed with the prior analysis and the posterior analysis. Moreover, the debugging efficiency involves testing staff’s learning and negligent factors, and therefore, the human factors and the nature of debugging process are taken into consideration in developing the fundamental model. Based on this, the estimation of the model’s parameters would be more intuitive and can be easily evaluated by domain experts, which is the major advantage for extending the related applications in practice. Finally, numerical examples and sensitivity analyses are performed to provide managerial insights and useful directions for software release strategies.

In the software development life cycle, the quality and reliability of software are critical to software developers. Poor quality and reliability not only cause the loss of customers and sales but also increase the operational risk due to unreliable codes. Therefore, software developers should try their best to reduce such potential software defects by undertaking a software testing project. However, to pursue perfect and faultless software is unrealistic since the budget, time, and testing resources are limited, and the software developers need to reach a compromise that balances software reliability and the testing cost. Using the model presented in this study, software developers can devise multiple alternatives for a software testing project, and each alternative has its distinct allocation of human resources. The best alternative can therefore be selected. Furthermore, the allocation incorporates debuggers’ learning and negligent factors, both of which influence the efficiency of software testing in practice. Accordingly, the study considers both human factors and the nature of errors during the debugging process to develop a software reliability growth model to estimate the related costs and the reliability indicator. Additionally, the issue of error classification is also extended by considering the impacts of errors on the system, and the expected time required to remove simple or complex errors can be estimated based on different truncated exponential distributions. Finally, numerical examples are presented and sensitivity analyses are performed to provide managerial insights and useful directions to inform software release strategies.

In the field of software engineering, optimal scheduling of software is a well-studied concept. However, attention to cost analysis in the field of multi-upgradation is still limited to certain well- known works. In the present work, a mathematical framework for multi-upgraded software under the concept of imperfect debugging has been analyzed. With due consideration of the fact that upgraded version might contain some newly generated bugs and few latent bugs of its preceding version, the cost components have been designed in accordance. The parameter estimates of multi-upgraded software under the influence of imperfect fault removal process are used for optimal determination of release time. For validation purpose, a numerical illustration has been carried out on three releases of software and the optimal release time is estimated accordingly. [ABSTRACT FROM AUTHOR]

Generally, it is assumed in the software reliability growth model that the fault is independent When a faut is detected, it can be eliminated. But in engineering, some detected fautts can not be eliminated and new faults may be introduced during the ellimination process. In this paper, a model based on a non-homogeneous Poisson process (NHPP) is proposed. It is assumed that the fault introduction process has a nonlinear ship with time. The software failure rate is based on the testing coverage. To avoid the restriction on Continuity and existence of model function derivative, an adaptive change real-valued genetic algorithm is applied to calculation in this paper. Finally, the model parameters are calculated through a set off real software failure data. The performance of the proposed model is compared with several existing NHPP sRGMs based in several criteria. The simplicity and accuracy in the proper model are discuss. [ABSTRACT FROM AUTHOR]

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. [ABSTRACT FROM AUTHOR]

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.

How to assess the reliability of open source software is an important issue. Compared with the traditional closed source software, two factors, i. e. fault introduction and the delay time between the fault detection and correction are necessarily considered when building software reliability model of open source software. This paper proposed software reliability models for open source software considering the correction process and imperfect debugging. It used the experiment to validate the goodness-of-fit and predictive performance of the proposed model using two fault data sets of open source software. The experimental results show that the proposed models have a good fitting and predictive power in the reliability evaluation of open source software. The proposed models can be used to evaluate the reliability of open source software in the real-world development of open source software. [ABSTRACT FROM AUTHOR]

In this study, reliability analysis of open source software in an imperfect debugging environment has been discussed by considering the effect of detection rate and the remaining faults in successive releases. First, a modified non-homogeneous Poisson process model is developed in an imperfect debugging environment by assuming that new faults may be introduced in fault detection and correction process. Then, the detection rate and remaining faults of previous release are considered in the modeling and analysis of reliability of the current release. The optimal version-update time is computed using multi-attribute utility theory for these software systems, considering the two main utility factors, namely, rapid release strategy and level of reliability. The proposed models are verified on real data sets and are compared with other existing models. The proposed decision models may be helpful for the software developing management to decide the optimal version update time for open source software. [ABSTRACT FROM AUTHOR]

Most existing software reliability growth models (SGRMs) often assume software faults are mutually independent and the detected faults can be perfectly removed. However, those two assumptions are not realistic in practice since the dependent faults can also exist in the program. At the same time, it is unlikely to correct all the detected faults in the testing phase due to the limitation of testing resource, the skill and experience of the programmer, and multi-release consideration for software organization. This paper presents a new non-homogeneous Poisson process (NHPP) software reliability model with a pioneering idea by considering software fault dependency and imperfect fault removal. In order to clearly explain software fault dependency, some facts and examples are discussed in Section 1. Two types of software faults are defined, Type I (independent) fault and Type II (dependent) fault, according to fault dependency. Two phases debugging processes, Phase I and Phase II, are proposed according to the debugged software fault type. A small portion of software faults that software testers are not able to remove is also considered in both phases in the proposed model. The illustration of the model effectiveness is based on the three datasets collected from industries. Some limitations of the proposed model are also discussed in the last section. [ABSTRACT FROM AUTHOR]