Do not neglect what's on your hands: localizing software faults with exception trigger stream

The identification of the appropriate distribution of faults is important for ensuring the reliability of a software system and its maintenance. It has been observed that different distributions explain faults in different types of software. Faults in large and complex software systems are best represented by Pareto distribution, whereas Weibull distribution fits enterprise software well. An analysis of faults in open-source software endorses generalized Pareto distribution. This paper presents a model, called the Tsallis distribution, derived using the maximum-entropy principle, which explains faults in many diverse software systems. The effectiveness of Tsallis distribution is ascertained by carrying out experiments on many real data sets from enterprise and open-source software systems. It is found that Tsallis distribution describes software faults better and more precisely than Weibull and generalized Pareto distributions, in both cases. The applications of the Tsallis distribution in (i) software fault-prediction using the Bayesian inference method, and (ii) the Goal and Okumoto software-reliability model, are discussed.

On the probability distribution of faults in complex software systems

Software defects are an indicator of software quality. Software with lesser number of defective modules are desired. Prediction of software defects using software measurements facilitates early identification of defect-prone modules. Association relationship between software measures and defects improves prediction of defective modules. To find association relationship between software measures and defects, each numeric measure is divided into bins. Each bin is called 1-itemset (or an itemset of length 1). When certain itemsets and defective modules appear together in a dataset, they are considered associated with each other. Frequency of their co-occurrence depicts the strength of the association relationship. Existing studies find the relationship between 1-itemsets and defective modules. Itemsets that have high association with defects are called focused itemsets. Focused itemsets can be used to build prediction models with higher Recall values. This paper explores the relationship between defective modules and itemsets with length greater than 1. Focused itemsets with length greater than 1 involve multiple bins at same time. Identification of the focused itemsets has improved the performance of decision tree based defect prediction model.

With the development of multicore hardware, concurrent, parallel and multicore software are becoming increasingly popular. Software companies are spending a huge amount of time and resources to nd and debug the bugs. Among all types of software bugs, concurrency bugs are also important and troublesome. This type of bugs is increasingly becoming an issue particularly due to the growing prevalence of multicore hardware. In this position paper, we propose a model for monitoring and debugging Starvation bugs as a type of concurrency bugs in multicore software. The model is composed into three phases: monitoring, detecting and debugging. The monitoring phase can support detecting phase by storing collected data from the system execution. The detecting phase can support debugging phase by comparing the stored data with starvation bug's properties, and the debugging phase can help in reproducing and removing the Starvation bug from multicore software. Our intention is that our model is the basis for developing tool(s) to enable solving Starvation bugs in software for multicore platforms.

A number of hardware and software techniques have been proposed to detect dynamic program behaviors that may indicate a bug in a program. Because these techniques suffer from high overheads they are useful in finding bugs in programs before they are released, but are significantly less useful in finding bugs in long-running programs on production systems -- the same bugs that are the most difficult to find using traditional techniques. In this paper we propose the Artemis1 is the Greek goddess of the hunt and wild animals. Our framework guides the hunt for wild bugs. compiler-based instrumentation framework that complements many pre-existing runtime monitoring techniques. The Artemis framework guides baseline monitoring techniques toward regions of the program where bugs are likely to occur, yielding a low asymptotic monitoring overhead. Artemis also facilitates system-load aware runtime monitoring that allows the monitoring coverage to be dynamically scaled up to take advantage of extra cycles when the system load is low, and dynamically scaled down to monitor only the most suspicious regions when the system load is high. Our experiments show that Artemis' asymptotic overhead can outperform the performance floor overhead of random sampling for many tools, and that Artemis can effectively guide a monitoring tool to the buggy regions of a program. Our experimental results show that Artemis applied to a hardware-based PC-invariance monitoring scheme and a value-based invariance detection and checking scheme significantly improves their runtime monitoring overhead (by up to 4.6 times) with moderate impact on their bug-detecting capabilities.

A number of hardware and software techniques have been proposed to detect dynamic program behaviors that may indicate a bug in a program. Because these techniques suffer from high overheads they are useful in finding bugs in programs before they are released, but are significantly less useful in finding bugs in long-running programs on production systems -- the same bugs that are the most difficult to find using traditional techniques. In this paper we propose the Artemis 1 is the Greek goddess of the hunt and wild animals. Our framework guides the hunt for wild bugs. compiler-based instrumentation framework that complements many pre-existing runtime monitoring techniques. The Artemis framework guides baseline monitoring techniques toward regions of the program where bugs are likely to occur, yielding a low asymptotic monitoring overhead. Artemis also facilitates system-load aware runtime monitoring that allows the monitoring coverage to be dynamically scaled up to take advantage of extra cycles when the system load is low, and dynamically scaled down to monitor only the most suspicious regions when the system load is high. Our experiments show that Artemis' asymptotic overhead can outperform the performance floor overhead of random sampling for many tools, and that Artemis can effectively guide a monitoring tool to the buggy regions of a program. Our experimental results show that Artemis applied to a hardware-based PC-invariance monitoring scheme and a value-based invariance detection and checking scheme significantly improves their runtime monitoring overhead (by up to 4.6 times) with moderate impact on their bug-detecting capabilities.

Block programming has been suggested as a way of engaging young learners with the foundations of programming and computational thinking in a syntax-free manner. Indeed, syntax errors—which form one of two broad categories of errors in programming, the other one being logic errors—are omitted while block programming. However, this does not mean that errors are omitted at large in such environments. In this exploratory case study of a learning environment for early programming (Kodetu), we explored errors in block programming of middle school students ( N = 123), using log files drawn from a block-based online. Analyzing 1033 failed executions, we found that errors may be driven by either learners’ knowledge and behavior, or by the learning environment design. The rate of error types was not associated with the learners’ and contextual variables examined, with the exception of task complexity (as defined by SOLO taxonomy). Our findings highlight the importance of learning from errors and of learning environment design.

Software metrics have direct linkage with software quality and defect. Thus, for a software engineer, it becomes very hard to estimate the software quality and provide product assurance to the client. Most of the software becomes failure due to several kinds of defects. The software industry uses different kinds of software models such as SDLC for software product development, and it becomes very difficult to choose the correct software model for software development. The objective of this chapter is to show how we can use machine learning and data mining for software defect, quality and software model prediction. We analyse different kinds of machine learning algorithms for application in software engineering domain. This chapter reviews the various classifications used to predict software defects using software measurements in the literature. In this chapter, we perform a detailed analysis of application of data mining and machine learning approaches used for software quality, defect and quality analysis.

Software defect detection is particularly important for modern society, as it is a crucial step in ensuring the quality and reliability of software systems. With the emergence of artificial intelligence (AI), research in software defect detection has evolved from traditional methods to more complex approaches that utilize deep learning and large language models (LLMs). The advent of LLMs has fundamentally changed the paradigm of software development and defect detection, bringing new challenges and confusion to the field of software defect prediction research. To address these issues, we compare software defect detection methods based on traditional techniques, deep learning approaches, and LLMs through a literature review. We analyze the changes brought about by the introduction of LLMs to software development and propose new insights. Additionally, we examine the progress and trends in software defect prediction to provide inspiration for subsequent research.

Software defect information represents the characteristics of software processes and it can provide feedback to software quality assurance activities. The basic principle of software defect baseline is discussed, and a software quality assurance framework based on defect baseline feedback information is proposed. The relation between software activities and defect information collected through the process is studied. The statistical characteristics of defect information and it development trends along with the software process advance can reflect the effectiveness and efficiency of different quality assurance activities as feedback. Combined with practical projects, software defect metrics based on Orthogonal Defect Classification framework is built. The effectiveness and efficiency evaluation of quality assurance activities using the result of defects analysis is carried out with this quality assurance model to determine the direction of the QA improvements and help the software process integral improvement.KeywordsSoftware defectsDefect analysisOrthogonal defect classificationSoftware quality assurance

Passive Optical Networks (PONs) are one of the 
\npreferred technologies to deploy
\n broadband access networks. As 
\ntime passes, end users presuppose network connectivity to be 
\nalways available, and expect PONs to be highly dependable. Yet 
\noperators, from an economic view, are interested in the costs 
\nrelated to failures. Thus, PONs dependability and associated 
\ncosts have been extensively studied, but only focusing on 
\nhardware failures. Contrarily, this paper performs a thorough 
\nanalysis of the impact of software failures in failure-related costs. 
\nBased on real empirical data, software failures are thoroughly 
\ncharacterized and classified in four different categories according 
\nto their severity. Also, the effect of software failures on the 
\nbehavior of PON’s fiber protection and recovery mechanisms is 
\ndetailed. Software failures are included into a Markov cost 
\nmodel, implementing a comprehensive cost framework. This way, 
\nthe dependability-related costs of
\n PONs are analyzed, accounting 
\nfor hardware and software failures, as well as for the 
\nconsequences of software failures on well-known PON protection 
\nmechanisms. Moreover, how the testing phase duration and user 
\nprofile (residential or business) impact these costs is pinpointed.

The paper describes a mathematical model, the Exposure Model, for the prediction of customer reported defects in a large software system. In the model, exposure is defined as the likely fraction of the original defects in the software system that is reported by any customer, in any month and against any version of the system. The basic idea is to try to model exposure as the product of the isolated effects of a few customer- and system-characteristics. The model has been used for several purposes: to better understand defect detection mechanisms, and to better predict the resources required for defect correction. Also, the model has enabled us to make an early estimate of product quality, and thereby give valuable input for other important purposes.

Correlated quality metrics extracted from a source code repository can be utilized to design a model to automatically predict defects in a software system. It is obvious that the extracted metrics will result in a highly unbalanced data, since the number of defects in a good quality software system should be far less than the number of normal instances. It is also a fact that the selection of the best discriminating features significantly improves the robustness and accuracy of a prediction model. Therefore, the contribution of this paper is twofold, first it selects the best discriminating features that help in accurately predicting a defect in a software component. Secondly, a cost-sensitive logistic regression and decision tree ensemble-based prediction models are applied to the best discriminating features for precisely predicting a defect in a software component. The proposed models are compared with the most recent schemes in the literature in terms of accuracy, area under the curve, and recall. The models are evaluated using 11 datasets and it is evident from the results and analysis that the performance of the proposed prediction models outperforms the schemes in the literature.

Both hardware and software of computer systems are subject to faults. However, traditional methods, ignoring the relationship between software fault and hardware fault, are ineffective to diagnose complex faults between software and hardware. On the basis of defining the interactive effect to describe the process of the interactive software and hardware fault, this paper present a new matrix-oriented negative selection algorithm to detect faults. Furthermore, the row vector distance and matrix distance are constructed to measure elements between the self set and detector set. The experiment on a temperature control system indicates that the proposed algorithm has good fault detection ability, and the method is applicable to diagnose interactive software and hardware faults with small samples.

The rapidly increasing application of software makes for the growing requirement of software quality. In key areas like aviation, aerospace and communication, a tiny software failure may brings serious consequences. Once the defects in the one or more software entities are triggered, the software faults may propagate to the extra entities and result in the partial failure of the software or even the system-wide failure. Therefore, to reduce software failure rate and assure software quality, the software fault propagation laws and influences on the software system demand more attention to be detected and controlled in the early phase. So in this paper, the complex network theories and methods are introduced into the fault propagation research of the structured software. By constructing the complex network model of structured software and abstracting the software faults into the status of nodes in the network, the software fault propagation laws and influence factors are analyzed, and the structured software fault propagation model is built.