Bug prediction modeling using complexity of code changes

“When you can measure what you are speaking about and express it in numbers, you know something about it; but when you cannot measure, when you cannot express it in numbers, your knowledge is of a meagre and unsatisfactory kind; it may be the beginning of knowledge, but you have scarcely, in your thoughts, advanced to the stage of science.” LORD WILLIAM KELVIN (1824 – 1907). During the last decade, the quantification of software engineering process has got a pace due to availability of a huge amount of software repositories. These repositories include source code, bug, communication among developers/users, changes in code, etc. Researchers are trying to find out useful information from these repositories for improving the quality of software.The absence of bugs in the software is a major factor that decides the quality of software. In the available literature, researchers have proposed and implemented a plethora of bug prediction approaches varying in terms of accuracy, complexity and input data. The code change metric based bug prediction is proven to be very useful. In the literature, decay functions have been proposed that decay the complexity of code changes over a period of time in either exponential or linear fashion but they do not fit in open source software development paradigm because in open source software development paradigm, the development team is geographical dispersed and there is an irregular fluctuation in the code changes and bug detection/fixing process. The complexity of code changes reduces over a period of time that may be less than exponential or more than linear. This paper presents the method that quantifies the code change metric and also proposed decay functions that capture the variability in the decay curves represented the complexity of code changes. The proposed decay functions model the complexity of code changes which reduces over a period of time and follows different types of decay curves. We have collected the source code change data of Mozilla components and applied simple linear regression (SLR) and support vector regression (SVR) techniques to validate the proposed method and predict the bugs yet to come in future based on the current year complexity of code changes (entropy). The performance of proposed models has been compared using different performance criteria namely R2, Adjusted R2, Variation and Root Mean Squared Prediction Error (RMSPE).

The purpose of this study is to analyze the reliability growth of Open Source Software (OSS) versus software developed in-house (i.e. Closed Source Software, CSS) using Software Reliability Growth Model. This study uses 22 datasets containing failure data of CSS and 18 datasets containing defect data of OSS projects. The failure data are modelled by eight SRGM (Musa Okumoto, Inflection S-Shaped, Goel Okumoto, Delayed S-Shaped, Logistic, Gompertz, Yamada Exponential, and Generalized Goel Model). These models are chosen due to their widespread use. The results can be summarized as follows All selected SRGM fit to defect data of the OSS projects in the same manner as that of CSS. OSS reliability grows similarly to that of CSS. Musa Okumoto and Inflection S-Shaped perform well for CSS, while for OSS Inflection S-Shaped and Gompertz are good performers. SRGM can be used for reliability characterization of OSS projects.

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

Number of software Reliability growth models has been proposed in the literature. A mathematical technique which describes the software testing phenomenon known as the software reliability growth model. Software reliability growth models are used to predict the number of faults and reliability of the software. In the view of this software reliability growth models are basically differentiated as the continuous and discrete models. There is a plenty of development in the continuous models but little towards the discrete models. In this paper we have presented a discrete reliability growth model with different discrete testing effort functions and the same time software release policy is discussed. A new imperfect debugging discrete software reliability growth model with testing effort is proposed. All calculations are done on real data. The results shows the proposed testing effort models are perfectly fit to the data.

This paper outlines a critical, textual approach for the analysis of the relationship between different actors in information technology (IT) production, and further concretizes the approach in the analysis of the role of users in the open source software (OSS) development literature. Central concepts of the approach are outlined. The role of users is conceptualized as reader involvement aiming to contribute to the configuration of the reader (to how users and the parameters for their work practices are defined in OSS texts). Afterwards, OSS literature addressing reader involvement is critically reviewed. In OSS context, the OSS writers as readers configure the reader and other readers are assumed to be capable of and interested in commenting the texts. A lack of OSS research on non-technical reader involvement is identified. Furthermore, not only are the OSS readers configured, but so are OSS writers. In OSS context while writers may be empowered, this clearly does not apply to the non-technical OSS readers. Implication for research and practice are discussed.

Many software reliability growth models have been proposed in the past decade. Those models tacitly assume that testing-effort expenditures are constant throughout software testing. This paper develops realistic software reliability growth models incorporating the effect of testing-effort. The software error detection phenomenon in software testing is modeled by a nonhomogeneous Poisson process. The software reliability assessment measures and the estimation methods of parameters are investigated. Testing-effort expenditures are described by exponential and Rayleigh curves. Least-squares estimators and maximum likelihood estimators are used for the reliability growth parameters. The software reliability data analyses use actual data. The software reliability growth models with testing-effort can consider the relationship between the software reliability growth and the effect of testing-effort. Thus, the proposed models will enable us to evaluate software reliability more realistically.

Reliability is the one of the important quality measure of software product. Testing is one important phase in software development life cycle whose intention is to find the bugs present in the software product. A mathematical model which describes the software testing in software development cycle termed as software reliability growth models. Past few decades many software reliability growth models were proposed. Estimating the accurate release time of software is an important challenging issue of software Development Company. If the software product is released early contain more errors makes software to be less reliable, where as late release will increase the development cost. It is observed that more than half of the total development cost is concentrated during the maintenance phase. Estimating the reliability and accurate development cost of software product by software reliability growth model at maintenance phase is an important issue. Warranty is defined to be an agreement between the customer and vendor of the software to provide the extra protection to the product. Several papers have concentrated on optimal release time by considering the warranty cost. All early proposed NHPP warranty cost models considered a perfect-debugging software reliability growth model while estimating the software maintenance cost. But it was observed that, the software product is influenced by several factors like environment, resources and nature of the faults during the operational phase. In such circumstances it is quite not right to consider a perfect NHPP software reliability growth model in operational phase. In this paper we proposed an imperfect debugging software reliability growth model by combining the cost and reliability at a given warranty period to estimate the optimal release time of software product.

Usability is an important quality characteristic of software products and information systems. Different approaches for introducing usability activities into open source software (OSS) development have not yet been fully evaluated. This paper experiments with the introduction of usability activities into OSS development through a participative approach. An empirical case study was carried out in a game development OSS project. The results of this study suggest that it is beneficial to introduce usability activities into OSS development through the participative approach. In the participative approach the usability experts become recognized part of the development community through adapting their ways of work into the culture of the OSS project and submitting code patches. This participative approach had a clear impact in the case project as seen in changes in the user interface and in improved usability. The challenge of adapting usability and OSS development philosophies and practices should, however, be researched further.

Multiple Software Reliability Growth Models (SRGM) has been illustrated to inspire designers and software developers to develop quality software. These models implicitly assume that expenditure is constant throughout testing effort. Recently importance was given to the testing phase by the development team and it requires controlled screening closely to raise its overall operational efficiency. Software Reliability Growth Models exhibits a precise relation between the failure patterns with time. Considering this as a basic building block a SRGM which is a Non-Homogeneous Poisson Process in nature is i in this work. The various aspects of our proposed model are testing effort function and fault detection rate (FDR). Mainly in Software Reliability Growth Model it was assumed that fault removal process are perfect which is not true in reality as new faults may get introduced during removal or some faults may not get removed due to its complexity. Thus in this model the concept of imperfect debugging was considered and assists us to justify the software reliability more convincingly through the help of testing effort function.

A significant number of software reliability growth models (SRGMs) have been proposed in the literature over the past three decades or so. Most of these models ignored the possibility of imperfect debugging with subsequent introduction of new errors into the software system. In this paper, we present an SRGM which consists of a dual process of debugging followed by introduction of errors in the event of an imperfect debugging. The model also allows for the process to be repeated over several stages. The reliability growth of this model is investigated and is shown to exhibit either an exponential or S-shaped curve. Finally, some reliability measures associated with the SRGM are presented together with illustrative numerical examples.

In this chapter we discuss the software reliability growth models (SRGMs) that describe the relationship between the number of faults removed and the number of test cases used. Firstly we describe the discrete exponential and S-shaped models in a perfect debugging environment. We also discuss flexible discrete SRGM, which can depict either exponential or S-shaped growth curves, depending upon the parameter values estimated from the past failure data. Further, we describe an SRGM for the fault removal phenomenon in a perfect debugging environment. Most testing processes are imperfect in practice, therefore we also discuss a discrete model that incorporates the impact of imperfect debugging and fault generation into software reliability growth modeling. Faults in the software are generally not of the same type, rather the faults contained in a large software may differ from each other in terms of the amount of time and skill of the removal team required to remove them. Three discrete models: the generalized Erlang model, modeling severity of faults with respect to testing time, and a model with faults of different severity incorporating logistic learning function have been discussed. A discrete model in a distributed environment is also discussed. The above discrete SRGMs assume a constant fault detection rate while testing the software under consideration. In practice, however, the fault detection rate varies because of changes in the testing skill, the system environment, and the testing strategy used to test the software. SRGMs for the fault removal phenomenon, the generalized Erlang model, and the generalized Erlang model with logistic function are discussed, incorporating the concept of change point. It is also shown how equivalent continuous models can be derived. This chapter describes the state-of-the-art in discrete modeling.

Software reliability assessment for an exponential-S-shaped reliability growth phenomenon

In recent years, more and more companies have moved from closed source software development to open source software (OSS) development. The reliability assessment of OSS has become an important issue. However, due to the lack of a standardized development process and uncertain number of participating developers, it is hard to measure the reliability of OSS compared to closed source software. This paper proposes a framework for reliability automatic assessment of OSS based on JIRA. It contains the failure data acquisition module, the reliability modeling module and the reliability attribute analysis module. The proposed framework is applied on popular OSS Kafka to assess the reliability. The experimental results show that the proposed framework is good for the reliability assessment of OSS.

In stark contrast with the fully participative “bazaar” imagery of open source software (OSS) development, some recent empirical research has pointed out that much of the OSS development is carried out by a small percentage of developers. This raises serious concerns that concentration of development effort on a few will limit knowledge sharing and underutilize the available resources. Using the notion of strategic interaction, this paper argues that individual developers often interact strategically with other highly resourceful developers by forming a smaller but better organized structure to intensify the types of epistemic interactions that matter most to the OSS development. A general framework of strategic interaction including participation inequality, conversational interactivity, and cross-thread connectivity is proposed to examine its impact on knowledge sharing, and validated using 128 discussion threads from the K Desktop Environment (KDE) developer mailing list. The findings indicate that strategic interaction has expanded knowledge sharing but with the caveat that extreme concentration of development could have an opposite effect. For researchers, this study dovetails the incentive logic by proposing and validating the strategic aspects of OSS participation to better understand the collective dynamics underpinning OSS development. Practitioners can use this approach to evaluate and better support existing knowledge-sharing initiatives.

Interest of scientific research on Open Source software and its development process is frequent. The number of articles available and the number of tracks or workshops on this topic in most relevant IS Conferences is high. The usability of Open Source Software has been scarcely considered until few years ago, probably due to the particular role that the user has in such a development environment. In Open Source software development, users and developers are not so different. Anyhow, the diffusion of the Open Source software outside the development community contributes to sharpen the distinction among these two groups that are no longer equivalent. This circumstance has contributed to increase the interest on usability of Open Source software. Nevertheless, studies on end-users in Open Source contexts are still young. This paper introduces a pilot study on end user's perception of Open Source software. The aim of this pilot study is to identify how the end user perceives the Open Source software (in terms of Usability, Functionality, Reliability, Efficiency and Quality in Use).