Modeling hierarchical usage context for software exceptions based on interaction data

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.

While software systems are being developed and released to consumers more rapidly than ever, security remains an important issue for developers. Shorter development cycles means less time for these critical security testing and review efforts. The attack surface of a system is the sum of all paths for untrusted data into and out of a system. Code that lies on the attack surface therefore contains code with actual exploitable vulnerabilities. However, identifying code that lies on the attack surface requires the same contested security resources from the secure testing efforts themselves. My research proposes an automated technique to approximate attack surfaces through the analysis of stack traces. We hypothesize that stack traces user crashes represent activity that puts the system under stress, and is therefore indicative of potential security vulnerabilities. The goal of this research is to aid software engineers in prioritizing security efforts by approximating the attack surface of a system via stack trace analysis. In a trial on Mozilla Firefox, the attack surface approximation selected 8.4% of files and contained 72.1% of known vulnerabilities. A similar trial was performed on the Windows 8 product.

The benefits of the analysis of software faults and failures have been widely recognized. However, detailed studies based on empirical data are rare. In this paper, we analyze the fault and failure data from two large, real-world case studies. Specifically, we explore: 1) the localization of faults that lead to individual software failures and 2) the distribution of different types of software faults. Our results show that individual failures are often caused by multiple faults spread throughout the system. This observation is important since it does not support several heuristics and assumptions used in the past. In addition, it clearly indicates that finding and fixing faults that lead to such software failures in large, complex systems are often difficult and challenging tasks despite the advances in software development. Our results also show that requirement faults, coding faults, and data problems are the three most common types of software faults. Furthermore, these results show that contrary to the popular belief, a significant percentage of failures are linked to late life cycle activities. Another important aspect of our work is that we conduct intra- and interproject comparisons, as well as comparisons with the findings from related studies. The consistency of several main trends across software systems in this paper and several related research efforts suggests that these trends are likely to be intrinsic characteristics of software faults and failures rather than project specific.

Even though exception handling mechanisms have been proposed as a means to improve software robustness, empirical evidence suggests that exception handling code is still poorly implemented in industrial systems. Moreover, it is often claimed that the poor quality of exception handling code can be a source of faults in a software system. However, there is still a gap in the literature in terms of better understanding exceptional faults, i.e., faults whose causes regard to exception handling. In particular, there is still little empirical knowledge about what are the specific causes of exceptional faults in software systems. In this paper we start to fill this gap by presenting a categorization of the causes of exceptional faults observed in two mainstream open source projects. We observed ten different categories of exceptional faults, most of which were never reported before in the literature. Our results pinpoint that current verification and validation mechanisms for exception handling code are still not properly addressing these categories of exceptional faults.

A Social-aware Gaussian Pre-trained model for effective cold-start recommendation

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.

For the detection of moving objects, background subtraction methods are widely used. In case the background changes, we need to update the background in real-time for the reliable detection of foreground objects. An adaptive Gaussian mixture model (GMM) combined with probabilistic learning is one of the most popular methods for the real-time update of the complex and dynamic background. However, the probabilistic learning approach does not work well in high traffic regions. In this paper, we classify each pixel into four different types: still background, dynamic background, moving object, and still object, and update the background model based on the classification. For the classification, we analyze a sequence of frame differences at each pixel and its neighborhood. We experimentally show that the proposed method learn complex and dynamic backgrounds in high traffic regions more reliably, compared with traditional methods.

Entropy-based closure for probabilistic learning on manifolds

Intervention studies often rely on microcoded data of social interactions to provide evidence of change due to development or treatment. Traditionally these data have been collapsed into small contingency tables. Such an approach can introduce spurious findings. Instead of treating each unit’s contingency table independently, or collapsing the tables into single aggregate table, it is more efficient to analyze associations in all units simultaneously using hierarchical models. This article presents Bayesian hierarchical models to analyze several two-way categorical data with random effects that allow different levels of variation across several events. To illustrate this approach, the authors present an analysis of couples’ interaction data from a recent study investigating how couples cope when one partner has become unemployed.

Software defects and quality assurance are crucial aspects of software development that should be considered during the software development cycle. To ensure high-quality software, it is essential to have a robust quality assurance process in place. System reliability and quality are very key components that must be considered during software development, and this can only be achieved when software undergoes a thorough test process for errors, anomalies, defects, omissions, and bugs. Early software defect prediction and detection play an essential role in ensuring the reliability and quality of software systems, ensuring that software companies discover errors or defects early enough and allocate more resources to defect-prone modules. This study proposes the development of an enhanced classifier model for software defect prediction and detection. The aim is to harness the collective intelligence of selected base classifiers like Support Vector Machine, Logistic regression, Decision Trees, Random Forest, AdaBoost, Gradient Boosting, K-Nearest Neighbor, GaussianNB, and Multi-Layer Perception to improve accuracy, robustness, and generalization in identifying potential defects using a soft voting ensemble technique. The ensemble model leveraged the confidence probability of the soft voting technique and the generalization advantage of cross-validation leading to a more robust and dynamic model. The performance of the model with existing classifiers was evaluated using accuracy, F1 score, Precision, and area under the ROC curve (ROC- AUC) as the evaluation metrics. The results of the experiment revealed that the Proposed Classifier produced an overall Accuracy rate of 93%, and ROC AUC of 98%. The results demonstrate the effectiveness of our enhanced ensemble classifier in software defect detection and prediction. By harnessing the strengths of diverse base classifiers, our approach provides a robust and adaptive solution to the challenges of early detection and mitigating defects in software systems. This research contributes to the advancement of reliable software development practices and lays the foundation for future enhancements in ensemble-based defect detection methodologies.

Software is not perfect and may contain bugs that cannot be detected by tests, or that will manifest themselves only over time. Sometimes problems can occur even in the code of third-party libraries or services that are used in the software system. To improve the reliability of software systems and timely detection of problems, data logging is used. Logging is a very important aspect of software development. By studying application logs, software developers can detect anomalies and errors in software systems, find the cause and provide an update or patch with fixes. Nevertheless, despite the importance of data logging practice, in most cases this process is chaotic. Developers write logging code solely based on their own considerations or neglect it altogether. This study points to the need to improve the state of research on data logging practices. For example, more efforts should be made to define what exactly to log, to generate logging data in a clear way and from the developer’s point of view with enough information to recreate the events even without having to run the application. This article describes ways in which this can be achieved. This research aims to establish a comprehensive understanding of the state of the art in data logging research with an emphasis on identifying possible problems and gaps that will further shed light on potential future research directions. This paper describes a study that focused on logging strategies used on real projects of different types. It investigated logging methods for desktop and web applications, and proposed improvements to the logging methodology that make it more flexible and convenient for software development teams regardless of the types of applications being developed.

Software quality assurance is concerned with the efficient and effective development of large, reliable, and high-quality software systems. In agile software development and maintenance, refactoring is an important phase for the continuous improvement of a software system by removing quality defects like code smells. As time is a crucial factor in agile development, not all quality defects can be removed in one refactoring phase (especially in one iteration). Documentation of quality defects that are found during automated or manual discovery activities (e.g., pair programming) is necessary to avoid wasting time by rediscovering them in later phases. Unfortunately, the documentation and handling of existing quality defects and refactoring activities is a common problem in software maintenance. To recall the rationales why changes were carried out, information has to be extracted from either proprietary documentations or software versioning systems. In this chapter, we describe a process for the recurring and sustainable discovery, handling, and treatment of quality defects in software systems. An annotation language is presented that is used to store information about quality defects found in source code and that represents the defect and treatment history of a part of a software system. The process and annotation language can not only be used to support quality defect discovery processes, but is also applicable in testing and inspection processes.

A generic approach for the extraction and recognition of gesture using raw grey-level images is presented. The probabilistic visual learning approach, a learning method recently proposed by B. Moghaddam and A. Pentland (1997), is used to create a set of compact statistical representations of gesture appearance on low dimensional eigenspaces. The same probabilistic modeling framework is used to extract and track gesture and to perform gesture recognition over long image sequences. Gesture extraction and tracking are based on maximum likelihood gesture detection in the input image. Recognition is performed by using the set of learned probabilistic appearance models as estimates of the emission probabilities of a continuous density hidden Markov model (CDHMM). Although the segmentation and CDHMM-based recognition use raw grey-level images, the method is fast, thanks to the data compression obtained by probabilistic visual learning. The approach is comprehensive and may be applied to other visual motion recognition tasks. It does not require application-tailored extraction of image features, the use of markers or gloves. A real-time implementation of the method on a standard PC-based vision system is under consideration.

Software development is a collaborative process in which programmers build software by integrating all the stages of the software development life cycle (SDLC). A software repository is a central file storage location where various software packages are stored, and these packages are retrieved and shared between all the software development team members at various locations. The software repositories are divided into various categories based on cooperation, coordination, and communication among the stakeholders as well as evolutionary changes to various software arti-facts such as source code repositories, software bug repositories, historical repositories, run-time repositories and requirement documents, and other documentation. The software bug repository is an essential repository among the entire repositories since the completion of the software is entirely dependent on the bug fixing mechanism associated with this repository in software development. Today's software systems are larger and more complex as they go through various stages from the requirement 98analysis phase to the maintenance phase. A variety of tasks and activities are carried out in each stage of software development, and these are expensive and vulnerable to errors. During software development, a large number of software bugs are continuously generated, and that has become the main reason for the delay in software completion. Hence, there is a vast demand for computational intelligent techniques to accomplish various tasks of software development. In recent years, fuzzy logic techniques emerged and played an important role in various fields of data mining and text mining. Since most of the content related to software bug repositories is text in nature, it is possible to effectively use fuzzy logic techniques to analyze these software bugs.

The traditional software defects prediction methods just evaluate the software defects based the unweighted undirected network, which do not reflect the real complex software system. Therefore, this paper proposes a software security defects prediction method based on the complex network. This method improves the PageRank algorithm and develops a KeyNodeRank algorithm based on the complex network. In this method, the software system is divided into different classes and these classes constitute a weighted directed network. In addition, the KeyNodeRank algorithm evaluates and ranks the importance of class nodes in the global network. In order to examine the validity of the software defects prediction method, this paper carries out an experiment. It is found that this method not only is accurate to predict and locate software defects and but also is very significant for improving software quality and maintaining software.