Search

The software testing process basically aims at building confidence in the software for its use in real world applications. The reliability of a software system is always important to us. As we carry out the error detection and correction phenomenon on our software, the reliability of the software grows. With an aim to model this growth in the software reliability, many formulations in the form of Software Reliability Growth Models have been proposed. Many of these are based on Non-Homogeneous Poisson Process framework. In this paper, a parallel comparison of the performance of the proposed software reliability growth models is carried out, considering linear and exponential fault content functions for study of imperfect debugging situations. The performance of the proposed models has been compared with some famous existing software reliability models and the proposed models have been validated on some real-world datasets. Three goodness-of-fit criteria that include mean square error, predictive-ratio risk and predictive power are used to carry out the performance comparison of the models. Using these comparison criteria on six actual failure datasets, it is concluded that the proposed Model-2 which always outperforms Model-1, fits the actual failure data better and has better predictive power than other considered SRGMs for at least two data sets.

In allusion to the flaws in software cost model and optimal release policy, inadequate consideration for real debugging, a cost model and optimal release policy for SRGM (Software Reliability Growth Model) incorporating imperfect debugging is proposed. A SRGM is presented, based on incomplete debugging, introduction of new faults and TE (Testing Effort). It is verified to describe real testing process well by actual failure data set and has better performance as compared to other models. Based on the proposed SRGM, a formulation of cost function is also established especially considering the impact of imperfect debugging on cost. Furthermore, the optimal release policies given limited reliability objective and the uncertainty in actual total cost exceeding expected one are developed and elaborated. Finally, a numerical example and related data analyses are illustrated and parameter sensitivity analysis is performed.

Software industry has reached far beyond since its origin. Technical advancements are taking place at a speed faster than ever. This has further enhanced the pressure on software developers. They are trying hard to keep a pace with these rapid developments by coming out with strategies to increase the pace of their work without significantly affecting the software quality and reliability. One such strategy is distributed development of software in which the software is composed of two different types of components viz. newly developed and re-used component. Software developed in Distributed Development Environment (DDE) is characterized by enhanced availability and reliability. At the same time, the ever growing contention in the market and increasing needs of customers obligate the developers to come out with enhanced functionalities in the software from time to time leading to multiple releases of a software. The added functionalities further enhance the existing complexity of the software and testing team may not be able to perfectly remove the faults leading to imperfect debugging or add more bugs due to lack of knowledge about the software in the initial phase known as error generation. In this paper, we incorporated this real-life phenomenon to come out with a multi up-gradations modeling for removal of software fault in a distributed environment. In the present framework we described a cost model to obtain optimal release time in multi up-gradation of software under distributed environment. To validate the analytical results of the proposed framework, numerical illustration is provided. [ABSTRACT FROM AUTHOR]

Fault reduction factor (FRF) is one of the most important factors which plays a vital role in software reliability growth. In the past, few studies on the influence of different environmental factors into FRF have been carried out. In these studies, FRF has been defined using some particular functions such as constant, increasing, decreasing and inflection S-shaped. These functions may not be realistic and reasonable to represent the actual behavior of FRF. Therefore, in this study, it has been tried to represent the realistic behavior of FRF using Weibull curve. Moreover, a new approach of software reliability modeling has been proposed in which FRF has been incorporated in fault detection and correction process. Thus, in this paper, a general frame work of software reliability growth model (SRGM) has been proposed considering the fault detection and correction process. The concepts of imperfect debugging and change point have also been incorporated in the present study. Different parameters of the proposed SRGM are estimated using the SPSS and 'R' software. Different comparison criteria have been used for comparison of the proposed SRGM with other existing SRGMs. Chi-square goodness-of-fit test has been used for validation of the proposed SRGM. [ABSTRACT FROM AUTHOR]

In the past, various Software Reliability Growth Models (SRGMs) have been proposed using different parameters to improve software worthiness. Testing Coverage is one such parameter that has been studied in numerous models of software in the past and it has proved its influence on the reliability models. To sustain themselves in the market, software firms keep upgrading their software with new features or enhancements by rectifying previously reported faults. Also, there is an impact of the random effect on testing coverage during both the testing and operational phase. In this paper, we have proposed a Software reliability growth model based on testing coverage with random effect along with imperfect debugging. Later, the multi-release problem is presented for the proposed model. The proposed model is validated on the dataset from Tandem Computers. The results for each release of the models have been discussed based on the different performance criteria. The numerical results illustrate that models fit the failure data significantly.•The random effect in the testing coverage rate is handled using Stochastic Differential Equations (SDE).•Three testing coverage functions used are Exponential, Weibull, and S-shaped.•Four Releases of the software model has been presented., Competing Interests: The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper., (© 2023 The Author(s).)

Copyright of Journal of Harbin Institute of Technology. Social Sciences Edition / Haerbin Gongye Daxue Xuebao. Shehui Kexue Ban is the property of Harbin Institute of Technology 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.)

Fault reduction factors (FRFs) play an important role in software reliability and are generally defined as the ratio of the total number of reduced faults to the total number of failures experienced. The behavior of FRFs is not fixed and can be affected by many factors, e.g., imperfect debugging, resource allocations, and debugging time lag. In most studies, either constant, increasing or decreasing FRFs have been considered. These are not sufficient to represent the realistic behavior of FRFs. We present three models in this study. In the first two models, an inflection S-shaped curve is considered as the FRF, and in the third model the FRF is constant. The first model functions in a perfect debugging environment whereas the second and third models function in an imperfect debugging environment. Here, the first two models are developed for single release software systems and the third is developed for multi-release software systems. Finally, a comparison is made with existing models in literature. [ABSTRACT FROM AUTHOR]

Quality of software system generally depends on how much time testing takes and what testing methodologies are used. One attribute of quality is reliability which can be increased by removing more faults from the software and this can be done by spending more time on testing. However, spending more time on testing will increase cost of the software development process. On the other hand, if testing time is too short, testing cost of software may be reduced but it will increase the chance of getting unreliable software and customers may not take higher risk of buying unreliable software. Highly competitive market conditions have forced developers to offer highly reliable products to the users. Software warranty is one such indicator used by the users to judge its reliability with the perception that a longer warranty period indicates higher reliability. Software warranty is a tool which provides assurance about the quality. Warranty cost may be reduced by providing more reliable product. Therefore software reliability, testing, warranty period and cost needs to be considered jointly. In this paper, we propose a new method to estimate the optimal software release time of a software with warranty under imperfect debugging environment by using Multi Attribute Utility Theory. More precisely, three significant attributes, namely Reliability, Cost and Detection rate indicator are used to determine the optimal release time of software under warranty. The proposed new decision model based on multi-attribute utility analysis is tested on the real world data set. [ABSTRACT FROM AUTHOR]

Software reliability models are used to estimate and predict the reliability, number of remaining faults, failure intensity, total software development cost, etc., of a software. Testing coverage is very important for both software developers and customers of software products. Testing converge is a measure that enables software developers to evaluate the quality of tested software and determine how much additional effort is needed to improve the reliability of the software. This paper proposes a software reliability growth model based on a non-homogeneous Poisson process (NHPP) that incorporates a logistic-exponential testing coverage function with imperfect debugging. The proposed model relates the test coverage to fault detection phenomena in debugging. Goodness-of-fit test of the proposed model is conducted using different criteria for two sets of software failure data. The proposed model is compared with other existing NHPP models. A software cost model incorporating testing coverage and an optimal release policy based on the number of remaining faults are developed. [ABSTRACT FROM AUTHOR]

Abstract: This paper studies the fault detection process (FDP) and fault correction process (FCP) with the incorporation of testing effort function and imperfect debugging. In order to ensure high reliability, it is essential for software to undergo a testing phase, during which faults can be detected and corrected by debuggers. The testing resource allocation during this phase, which is usually depicted by the testing effort function, considerably influences not only the fault detection rate but also the time to correct a detected fault. In addition, testing is usually far from perfect such that new faults may be introduced. In this paper, we first show how to incorporate testing effort function and fault introduction into FDP and then develop FCP as delayed FDP with a correction effort. Various specific paired FDP and FCP models are obtained based on different assumptions of fault introduction and correction effort. An illustrative example is presented. The optimal release policy under different criteria is also discussed. [Copyright &y& Elsevier]

When a product is purchased and used by a customer then it might be possible that a difference between the product performance and customer expectation crops in. A warranty is simply a formal promise by a vendor that the product is defect free, meaning that it will do what it promises to do and that if it fails to do so, then how the vendor will go about rectifying defects. Warranties are also an effective means of promoting a product in the market when the company or product is not well known. Or in other words warranty serves as a source for spread of an innovation in the market. But servicing a warranty engages additional costs to the manufacturer and this has an effect on the profit levels. Warranty cost may be reduced by providing higher reliable product. The conflict existing in the context of software reliability, warranty period and selling price need to be considered jointly. In this paper, we formulate an optimization problem that determines the optimal testing time and price under two types of imperfect debugging of software product with warrant. The factors like fixed cost of testing and debugging during testing phase and warranty period, cost of testing up to the release time are considered in order to maximize profit. Results are illustrated in the numerical example. [ABSTRACT FROM AUTHOR]

In this paper, we propose a non-homogeneous Poisson process (NHPP) based software reliability growth model (SRGM) in the presence of modified imperfect debugging and fault generation phenomenon. The testing team may not be able to remove a fault perfectly on observation of a failure due to the complexity of software systems and incomplete understanding of software, and the original fault may remain, or get replaced by another fault causing error generation. We have proposed an exponentially increasing fault content function and constant fault detection rate. The total fault content of the software for our proposed model increases rapidly at the beginning of the testing process. It grows gradually at the end of the testing process because of increasing efficiency of the testing team with testing time. We use the maximum likelihood estimation method to estimate the unknown parameters of the proposed model. The applicability of our proposed model and comparisons with established models in terms of goodness of fit and predictive validity have been presented using five known software failure data sets. Experimental results show that the proposed model gives a better fit to the real failure data sets and predicts the future behavior of software development more accurately than the traditional SRGMs. [ABSTRACT FROM AUTHOR]

In order to overcome the limitations of debugging process, insufficient consideration of imperfect debugging and testing-effort (TE) in software reliability modeling and analysis, a software reliability growth model (SRGM) explicitly incorporating imperfect debugging and TE is developed. From the point of view of incomplete debugging and introduction of new fault, software testing process is described and a relatively unified SRGM framework is presented considering TE. The proposed framework models are fairly general models that cover a variety of the previous works on SRGM with ID and TE. Furthermore, a special SRGM incorporating an improved Logistic testing-effort function (TEF) into imperfect debugging modeling is proposed. The effectiveness and reasonableness of the proposed model are verified by published failure data set. The proposed model closer to real software testing has better descriptive and predictive power than other models. [ABSTRACT FROM AUTHOR]

To incorporate the effect of test coverage, we proposed two novel discrete nonhomogeneous Poisson process software reliability growth models in this article using failure data and test coverage, which are both regarding the number of executed test cases instead of execution time. Because one of the most important factors of the coverage-based software reliability growth models is the test coverage function (TCF), we first discussed a discrete TCF based on beta function. Then we developed two discrete mean value functions (MVF) integrating test coverage and imperfect debugging. Finally, the proposed discrete TCF and MVFs are evaluated and validated on two actual software reliability data sets. The results of numerical illustration demonstrate that the proposed TCF and the MVFs provide better estimation and fitting under comparisons. Copyright © 2012 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

This article presents a software reliability growth model based on non-homogeneous Poisson process. The main focus of this article is to deliver a method for software reliability modelling incorporating the concept of time-dependent fault introduction and fault removal rate with change point. Also in this article, a cost model with change point has been developed. Based on the cost model optimal release policy with change point has been discussed. Maximum likelihood technique has been applied to estimate the parameters of the model. The proposed model has been validated using some real software failure data. Comparison has been made with models incorporating change point and without change point. The application of the proposed cost model has been shown using some numerical examples. [ABSTRACT FROM PUBLISHER]

Most Software Reliability Growth Models (SRGMs) ignore either the learning phenomenon of the testing team or quality of debugging or both for the sake of simplicity. Some SRGMs consider imperfect debugging tightly integrated with the learning phenomenon. In practice, imperfect debugging and the learning phenomenon of the testing team are independent of each other since the former indicates quality of debugging process and the latter the quality of the testing process, usually carried out by different teams. Furthermore, sometimes the debugging team may find and correct some more faults in addition to the faults which caused the failures leading to what is known as efficient debugging. In this paper, a new mathematically derived SRGM is proposed, which also provides estimates of various quality metrics such as the number of faults in the software system, debugging and the learning indices. The proposed SRGM seems to describe the time to failure data of many software projects satisfactorily. [ABSTRACT FROM AUTHOR]

This paper proposes a special redundant model for describing the s-dependency of multi-version programming software during testing and debugging. N-version programming (NVP) is one of the most important software fault tolerance techniques. Many papers have studied the issue of fault correlation among versions. However, only a few of them consider this issue during the testing and debugging part of the software development life cycle. During testing and debugging, faults may not be successfully removed. Imperfect debugging may result in unsuccessful removal, and the introduction of new faults. Different from existing NVP models, the model proposed in this paper allows an assessment of s-dependency when correlated failures may not necessarily occur at the same execution time point. The model focuses on 2 VP systems. It is developed to be a bivariate counting process by assuming positive s-dependency among versions. Considering imperfect debugging, this bivariate process characterizes dynamic changes of fault contents for each version during testing and debugging. The system reliability, expected number of faults, probability of perfect debugging, and parameter estimation of model parameters are presented. An application example is given to illustrate the proposed model. The paper provides an alternative approach for evaluating the reliability of 2 VP software systems when there is positive s-dependency between versions. [ABSTRACT FROM AUTHOR]

Computer software has progressively turned out to be an essential component in modern technologies. Testability is the probability whether tests will detect a fault, given that a fault in the program exists. How efficiently the faults will be uncovered depends upon the testability of the software. Various researchers have proposed qualitative and quantitative techniques to improve and measure the testability of software. Furthermore, it is well known fact that the progress of software testing is influenced by various uncertainty factors like effort expenditure, skill of test personal, testing tool, defect density and irregular state of software fault-report phenomena on the bug tracking system. Hence, there is an irregular fluctuation in fault detection/removal rate during testing phase. In this paper, distribution based software reliability growth models have been developed by applying Itô type Stochastic Differential Equations in order to incorporate (i) the irregular fluctuation in the fault detection process due to various uncertainty factor during testing phase; (ii) two types of imperfect debugging and (iii) change-point concept. The proposed stochastic differential equation based models have been validated using real data sets. Various comparison criteria results for goodness of fit have also been presented in the paper. [ABSTRACT FROM AUTHOR]

During a debugging operation, there is a high probability that an additional fault will be introduced into the program when removing an existing fault. Thus, perfect debugging is an ideal but impractical assumption when modeling software reliability. If the debugging of a software system is imperfect, more faults may be introduced and detected. In such cases, it may be necessary to add more staff to the debugging team to share the load and ensure the quality of the software. To investigate the effects of imperfect debugging, we simulate the fault detection and correction processes by a single-queue multichannel queuing model with feedback. In this paper, two debugging procedures are discussed. The first, called Procedure_perfect_debugging, is based on a single-queue multichannel queuing model and deals with the case of perfect debugging. Then, we relax the restriction on perfect debugging, and further propose Procedure_imperfect_debugging based on a queuing model with feedback to address the case of imperfect debugging. We demonstrate the implementation of the procedures via two case studies in which we quantify the effects of imperfect debugging in terms of throughput, time consumption, and debugger utilization. Finally, based on the measurement results, we determine the most suitable staffing level (i.e., the number of debuggers required) for a debugging system under different degrees of imperfect debugging. [ABSTRACT FROM AUTHOR]

In this paper, we propose two general frameworks for deriving several software reliability growth models based on a non-homogeneous Poisson process (NHPP) in the presence of imperfect debugging and error generation. The proposed models are initially formulated for the case when there is no differentiation between failure observation and fault removal testing processes, and then extended for the case when there is a clear differentiation between failure observation and fault removal testing processes. During the last three decades, many software reliability growth models (SRGM) have been developed to describe software failures as a random process, and can be used to evaluate development status during testing. With SRGM, software engineers can easily measure (or forecast) the software reliability (or quality), and plot software reliability growth charts. It is not easy to select the best model from a plethora of models available. There are few SRGM in the literature of software engineering that differentiates between failure observation and fault removal processes. In real software development environments, the number of failures observed need not be the same as the number of faults removed. Due to the complexity of software systems, and an incomplete understanding of software, the testing team may not be able to remove the fault perfectly on observation of a failure, and the original fault may remain, resulting in a phenomenon known as imperfect debugging, or get replaced by another fault causing error generation. In the case of imperfect debugging, the fault content of the software remains the same; while in the case of error generation, the fault content increases as the testing progresses. Removal of observed faults may result in the introduction of new faults. [ABSTRACT FROM AUTHOR]

Due to demand of new features and highly reliable software system, the software industries are speeding their up-gradations/add-ons in the software. The life of software is very short in the environment of perfect competition. Therefore the software developers have to come up with successive up gradations to survive. The reported bugs from the existing software and Features added to the software at frequent time intervals lead to complexity in the software system and add to the number of faults in the software. The developer of the software can lose on market share if it neglects the reported bugs and up gradation in the software and on the other hand a software company can lose its name and goodwill in the market if the reported bugs and functionalities added to the software lead to an increase in the number of faults in the software. To capture the effect of faults due to existing software and generated in the software due to add-ons at various points in time, we develop a multi up-gradation, multi release software reliability model. This model uniquely identifies the faults left in the software when it is in operational phase during the testing of the new code i.e. developed while adding new features to the existing software. Due to complexity and incomplete understanding of the software, the testing team may not be able to remove/correct the fault perfectly on observation/detection of a failure and the original fault may remain resulting in the phenomenon known as imperfect debugging, or get replaced by another fault causing error generation The model developed is validated on real data sets with software which has been released in the market with new features four times. [ABSTRACT FROM AUTHOR]

The number of faults removed need not always be same as the number of failures observed in real software development environment. If number of failures observed is more than number of faults removed then we have the case of imperfect debugging. Due to complexity of software system and incomplete understanding of software, testing team may not be able to remove the fault perfectly on detection of failure and the original fault may remain leading to imperfect fault removal, or get replaced by another fault/error causing error generation. Attempts have been made to study the above cases separately. Most of the SRGMs are based upon constant or monotonically increasing fault detection rate (FDR). In practice, as testing grows, so does skill and efficiency of the testers. With introduction of new testing strategies and new test cases, there comes a change in FDR. The time point where the change in removal curve appears is termed as "change point". In this paper, we incorporate the concept of change point in software reliability growth in presence of imperfect fault removal and error generation. The models have been validated, evaluated and compared with other existing NHPP models by applying it on actual failure/fault removal data sets cited from real software development projects. [ABSTRACT FROM AUTHOR]

Abstract: Software reliability testing is concerned with the quantitative relationship between software testing and software reliability. Our previous work develops a mathematically rigorous modeling framework for software reliability testing. However the modeling framework is confined to the case of perfect debugging, where detected defects are removed without introducing new defects. In this paper the modeling framework is extended to the case of imperfect debugging and two models are proposed. In the first model it is assumed that debugging is imperfect and may make the number of remaining defects reduce by one, remain intact, or increase by one. In the second model it is assumed that when the number of remaining defects reaches the upper bound, the probability that the number of remaining defects is increased by one by debugging is zero. The expected behaviors of the cumulative number of observed failures and the number of remaining defects in the first model show that the software testing process may induce a linear or nonlinear dynamic system, depending on the relationship between the probability of debugging introducing a new defect and that of debugging removing a detected defect. The second-order behaviors of the first model also show that in the case of imperfect debugging, although there may be unbiased estimator for the initial number of defects remaining in the software under test, the cumulative number of observed failures and the current number of remaining defects are not sufficient for precisely estimating the initial number of remaining defects. This is because the variance of the unbiased estimator approaches a non-zero constant as the software testing process proceeds. This may be treated as an intrinsic principle of uncertainty for software testing. The expected behaviors of the cumulative number of observed failures and the number of remaining defects in the second model show that the software testing process may induce a nonlinear dynamic system. However theoretical analysis and simulation results show that, if defects are more often removed from than introduced into the software under test, the expected behaviors of the two models tend to coincide with each other as the upper bound of the number of remaining defects approaches infinity. [Copyright &y& Elsevier]

Imperfect debugging of software development faults (called primary faults) will lead to the creation of new software faults denoted secondary faults. Secondary faults are typically fewer in numbers than the initial primary faults and are introduced late in the testing phase. As such it is unlikely that they will be observed during testing and their failure characteristics are unlikely to be assessed accurately. This is an issue since they may possibly display different propagation characteristics than the primary faults that led to their creation. In particular their location will be distributed non-uniformly around the fault being fixed. This paper proposes a methodology to assess the impact of secondary faults on reliability-based on predicting their possible types and locations. The methodology combines a fault taxonomy, code mutation and Bayesian statistics. The methodology is applied to portions of the application software code of a nuclear reactor protection system. This paper concludes with a discussion on the integration of the results within existing Software Reliability Growth Models. [ABSTRACT FROM AUTHOR]

Earlier software reliability models have been criticised for their unrealistic assumption of perfect debugging and that they give their answers far too late. Although several software reliability models that incorporate imperfect debugging have been presented during the last several years only few attempts have been made to predict further into the future. These attempts were confined to models that assume perfect debugging. In the present study the imperfect debugging variant of the JMNHPP model is used to obtain one and further step ahead predictions of the reliability of a program. The preliminary results of the study are encouraging. When imperfect debugging is incorporated in the JMNHPP model, predictions can be obtained much earlier in the development and are reasonably consistent with their one step ahead predictions. [ABSTRACT FROM AUTHOR]

Several software reliability growth models have been presented in the literature in the last three decades. They have been developed for uniform and non-uniform operational profile. Some of them are flexible whereas others are not. Model selection becomes an uphill task. Of late, some authors have tried to develop a unifying approach so as to capture different growth curves, thus easing the model selection process. Some of these approaches use (a) Random lag function (b) Infinite server queuing theory (c) Hazard rate function. The purpose of this paper is to show that all these approaches are equivalent and further show that hazard rate approach is more general and can handle both Imperfect Debugging and Fault generation. This paper thus provides a new insight into the model development and it is shown that how a wide variety of existing software reliability can be unified. [ABSTRACT FROM AUTHOR]

Advances in software technologies have promoted the growth of computer-related applications to a great extent. Building quality in terms of reliability of the software has become one of the main issues for software developers. Software testing is necessary to build highly reliable software. Monitoring and controlling the resource utilization, measuring and controlling the progress of testing, efficiency of testing and debugging personals and reliability growth are important for effective management the testing phase and meeting the quality objectives. Over the past 35 years many Software reliability growth models (SRGM) are proposed to accomplish the above-mentioned activities related to the software testing. From the literature it appears that most of the SRGM do not account the changes in the testing effort consumption. During the testing process especially in the beginning and towards the end of the testing frequent changes are observed in testing resource consumption due to changes in testing strategy, team constitution, schedule pressures etc. Apart from this testing efficiency plays a major role determining the progress of the testing process. In this paper we incorporate the important concept of testing resource consumption variations for Weibull type testing effort functions and testing efficiency in software reliability growth modeling. The performance of the proposed models is demonstrated through two real life data sets existing in literature. The experimental result shows fairly accurate estimating capabilities of the proposed models. [ABSTRACT FROM AUTHOR]

Over the last several decades, many Software Reliability Growth Models (SRGM) have been developed to greatly facilitate engineers and managers in tracking and measuring the growth of reliability as software is being improved. However, some research work indicates that the delayed S-shaped model may not fit the software failure data well when the testing-effort spent on fault detection is not a constant. Thus, in this paper, we first review the logistic testing-effort function that can be used to describe the amount of testing-effort spent on software testing. We describe how to incorporate the logistic testing-effort function into both exponential-type, and S-shaped software reliability models. The pro- posed models are also discussed under both ideal, and imperfect debugging conditions. Results from applying the proposed models to two real data sets are discussed, and compared with other traditional SRGM to show that the proposed models can give better pre- dictions, and that the logistic testing-effort function is suitable for incorporating directly into both exponential-type, and S-shaped software reliability models. [ABSTRACT FROM AUTHOR]

Since the early 1970's numerous Software Reliability Growth Models (SRGM) have been proposed in the literature to estimate the software reliability measures such as the remaining number of faults, failure rate and reliability growth during the testing phase. These models are applied to the software testing data collected during the testing phase and then are often used to predict the software failures in operational phase. In practice simulating mirror image of the diverse testing environment representative of the operational environment is difficult in practice and hence the simulated testing environment during the testing phase may not be similar to the conditions that exist in the operational phase. During testing phase testing is performed under a controlled environment whereas during the operational phase failure phenomenon depends on the operational environment and usage of software. Therefore an SRGM developed for the testing phase is not suitable for estimating the reliability growth during the operational phase. In this paper, we propose a generalized Software Reliability Growth Model, which can be used to estimate number of faults during the testing phase and can be easily extended to the operation phase. In the testing phase, it is appropriate to estimate the reliability growth with respect to the amount of testing resources spent on testing whereas in the operational phase the amount of effort to be spent on removing a fault reported by a user is fixed by the developer. The number of failures detected and hence the reliability growth during the user phase depends on the usage of software. The proposed model appropriately incorporates these changes. Further we categorize the software into two-categories- (a) project and (b) product type software. Appropriate usage functions are linked to both project and product type software. To describe the fault removal phenomenon, imperfect debugging environment is incorporated into the model building. The paper highlights an interdisciplinary mathematical modeling approach in Software Reliability Engineering and Marketing. The proposed model is validated for both phases using the software failure data sets obtained from different sources. Model describes the failure phenomenon for these data sets fairly. [ABSTRACT FROM AUTHOR]

One of the challenging problems for software companies is to find the optimal time of release of the software so as to minimize the total cost expended on testing and potential penalty cost due to unresolved faults. If the software is for a safety critical system, then the software release time becomes more important. The criticality of a failure caused by a fault also becomes an important issue for safety critical software. In this paper we develop a total cost model based on criticality of the fault and cost of its occurrence during different phases of development for N-version programming scheme, a popular fault-tolerant architecture. The mathematical model is developed using the reliability growth model based on the non-homogeneous Poisson process. The models for optimal release time under different constraints are developed under the assumption that the debugging is imperfect and there is a penalty for late release of the software. The concept of Failure Mode Effects and Criticality Analysis is used for measuring criticality. [ABSTRACT FROM AUTHOR]

A large number of software reliability growth models have been proposed to analyse the reliability of a software application based on the failure data collected during the testing phase of the application. To ensure analytical tractability, most of these models are based on simplifying assumptions of instantaneous & perfect debugging. As a result, the estimates of the residual number of faults, failure rate, reliability, and optimal software release time obtained from these models tend to be optimistic. To obtain realistic estimates, it is desirable that the assumptions of instantaneous & perfect debugging be amended. In this paper we discuss the various policies according to which debugging may be conducted. We then describe a rate-based simulation framework to incorporate explicit debugging activities, which may be conducted according to the different debugging policies, into software reliability growth models. The simulation framework can also consider the possibility of imperfect debugging in conjunction with any of the debugging policies. Further, we also present a technique to compute the failure rate, and the reliability of the software, taking into consideration explicit debugging. An economic cost model to determine the optimal software release time in the presence of debugging activities is also described. We illustrate the potential of the simulation framework using two case studies. [ABSTRACT FROM AUTHOR]