Software Crashes Research Articles

Enhancing Practical Skills in Computer Networking: Evaluating the Unique Impact of Simulation Tools, Particularly Cisco Packet Tracer, in Resource-Constrained Higher Education Settings

This study examines the effectiveness of networking simulation tools, particularly Cisco Packet Tracer, in enhancing the learning experiences of exit-level students at a higher education institution based in the Eastern Cape of South Africa. Utilizing the Context, Input, Process, and Product (CIPP) evaluation model, the research assesses these tools’ impact, effectiveness, and sustainability in a resource-constrained, rural-based higher education context. The findings indicate that simulation tools significantly improve students’ practical skills, understanding of theoretical concepts, and preparedness for professional work in computer networking. Despite challenges such as software crashes and compatibility issues, the benefits of using simulation tools, including cost-effectiveness and convenience, are evident. The study concludes that, while simulation tools are valuable, continuous improvements and support are necessary to maximize their educational potential.

Developing a conceptual model for improving the software system reliability

In the Industry 4.0 environment, the software systems development methodology is rapidly evolving, flexible technologies and new programming languages are being applied. The development of the software industry has made the issue of the quality of software systems an urgent problem. A number of quality models have been proposed for determining the quality of software systems so far, and these models specify the parameters and criteria for evaluating quality. Software reliability is one of the key indicators among the quality parameters of software systems, as it quantifies software crashes which can bring down even the most powerful system, ensuring that software systems run correctly and unexpected incidents do not occur. The increasing difficulty of the software system, the expansion of the scope of issues assigned on them, and as a result, the significant increase in the volume and complexity of the software system have made the problem of the reliability of the software system even more urgent. The essence of the issue is to reveal the main factors affecting the reliability of software systems, demonstrate existing problems in this area and develop mathematical models for assessing reliability. Mathematical models estimate the number of errors remaining in the software system before commissioning, predict the time of occurrence of the next crash and when the testing process will end. It is necessary to comprehensively approach the issue of ensuring reliability at all stages of the life cycle of the software system. This paper proposes a conceptual model to solve this problem.

PREDICTING THE RELIABILITY OF SOFTWARE SYSTEMS USING RECURRENT NEURAL NETWORKS: LSTM MODEL

The dynamics and complexity of processes occurring in complex software systems, as well as the emergence of new types of malicious threats, further complicate the issues of ensuring software reliability. Despite the development of hundreds of models for increasing the reliability of software systems, this issue still remains relevant. Research shows that the use of neural networks in predicting the reliability of software systems allows one to obtain more accurate results. In this paper, to predict reliability, we used a neural network model with long short-term memory, which is a type of recurrent neural networks. Seven real-world software crash datasets were used to test the model's performance. The experiments were carried out in Python. Both parametric and nonparametric models were taken for comparison. The experimental results showed the practical significance of using the proposed model in predicting the reliability of software systems.

SSDTutor: A feedback-driven intelligent tutoring system for secure software development

Application Programming Interfaces (APIs) in cryptography typically impose concealed usage constraints. The violations of these usage constraints can lead to software crashes or security vulnerabilities. Several professional tools can detect these constraints (API misuses) in cryptography; however, in the educational programs, the focus has been less on helping students implement an application without cryptographic API misuses that are caused by either a lack of cryptographic knowledge or programming mistakes. To address the problem, we present an intelligent tutoring approach SSDTutor for educating Secure Software Development. Our tutoring approach helps students or developers repair cryptographic API misuse defects by leveraging an automated program repair technique based on the usage patterns of cryptographic APIs. We studied the best practices of cryptographic implementations and encoded eight cryptographic API usage patterns. For quality feedback, we leverage a clone detection technique to recommend related feedback for helping students understand why their programs are incorrect, rather than blindly accepting repairs. We evaluated SSDTutor on 456 open source subject projects implemented with cryptographic APIs. SSDTutor successfully detected 1,553 out of 1,573 misuse defects with 98.9% accuracy and repaired 1,551 out of 1,573 misuse defects with 99.3% accuracy. In a user study involving 22 students, the participants reported that interactive SSDTutor's feedback recommendation could be valuable for novice students to learn about the correct usages of cryptography APIs.

An unsupervised cross project model for crashing fault residence identification

It is a critical quality assurance activity to effectively detect the root cause of faults causing the software crashes (i.e. crashing faults). Previous studies extracted features to characterise crash instances and built models to identify whether the residences of crashing faults locate inside the stack traces. These models all belong to supervised learning methods which require labelled crash data to be involved. In this study, the introduction of an unsupervised model, called Transfer Spectral Clustering (TSC), for the task of crashing fault residence identification under the unlabelled data scenario is proposed. Unlike traditional unsupervised methods which are applied to individual project data, TSC transfers the knowledge of auxiliary unlabelled data from the source project to assist the clustering task on the unlabelled data from the target project. TSC is an unsupervised transfer learning method, and simultaneously considers the data manifold information of the individual project and feature manifold information across projects to facilitate the clustering effect. Extensive experiments are conducted on a benchmark dataset containing seven software projects. Five indicators were chosen for performance evaluation. The results show that TSC achieves better performance than four clustering based unsupervised methods, and competitive performance compared with eight supervised cross-project methods.

A Survey on Formal Specification and Verification of Smart Mass Transit Railway Interlocking System

Nowadays interest in Smart Mass Transit Rail has grown-up to a large extent in a metropolitan area as the need for urban mobility has increased steadily. The reliability of software being used in such mass transit rail is crucial for us, specifically when software crashes may lead to catastrophic loss of human life and assets. For example, when we travel by metro it is essential for us that the interlocking system software controlling the metros are accurate so collisions and derailment are prevented. The reliability and safety of such interlocking systems are made on the precise functional requirements specification and verification respectively. Therefore, the precise functional requirements specification and verification of such interlocking systems represent a challenge in an active research area, so in this paper, we survey various articles in this field and discuss their consequences.

A comprehensive investigation of the impact of feature selection techniques on crashing fault residence prediction models

Software crash is a serious form of the software failure, which often occurs during the software development and maintenance process. As the stack trace reported when the software crashes contains a wealth of information about crashes, recent work utilized classification models with the collected features from stack traces and source code to predict whether the fault causing the crash resides in the stack trace. This could speed-up the crash localization task. As the quality of features can affect the performance of the constructed classification models, researchers proposed to use feature selection methods to select a representative feature subset to build models by replacing the original features. However, only limited feature selection methods and classification models were taken into consideration for this issue in previous work. In this work, we look into this topic deeply and find out the best feature selection method for crash fault residence prediction task. We study the performance of 24 feature selection techniques with 21 classification models on a benchmark dataset containing crash instances from 7 real-world software projects. We use 4 indicators to evaluate the performance of these feature selection methods which are applied to the classification models. The experimental results show that, overall, a probability-based feature selection, called Symmetrical Uncertainty, performs well across the studied classification models and projects. Thus, we recommend such a feature selection method to preprocess the crash instances before constructing classification models to predict the crash fault residence. This work conducts a large-scale empirical study to investigate the impact of feature selection methods on the performance of classification models for the crashing fault residence prediction task. The results clearly demonstrate that there exist significant performance differences among these feature selection techniques across different classification models and projects.

Guided pattern mining for API misuse detection by change-based code analysis

Lack of experience, inadequate documentation, and sub-optimal API design frequently cause developers to make mistakes when re-using third-party implementations. Such API misuses can result in unintended behavior, performance losses, or software crashes. Therefore, current research aims to automatically detect such misuses by comparing the way a developer used an API to previously inferred patterns of the correct API usage. While research has made significant progress, these techniques have not yet been adopted in practice. In part, this is due to the lack of a process capable of seamlessly integrating with software development processes. Particularly, existing approaches do not consider how to collect relevant source code samples from which to infer patterns. In fact, an inadequate collection can cause API usage pattern miners to infer irrelevant patterns which leads to false alarms instead of finding true API misuses. In this paper, we target this problem (a) by providing a method that increases the likelihood of finding relevant and true-positive patterns concerning a given set of code changes and agnostic to a concrete static, intra-procedural mining technique and (b) by introducing a concept for just-in-time API misuse detection which analyzes changes at the time of commit. Particularly, we introduce different, lightweight code search and filtering strategies and evaluate them on two real-world API misuse datasets to determine their usefulness in finding relevant intra-procedural API usage patterns. Our main results are (1) commit-based search with subsequent filtering effectively decreases the amount of code to be analyzed, (2) in particular method-level filtering is superior to file-level filtering, (3) project-internal and project-external code search find solutions for different types of misuses and thus are complementary, (4) incorporating prior knowledge of the misused API into the search has a negligible effect.

Evaluating Automatic Program Repair Capabilities to Repair API Misuses

API misuses are well-known causes of software crashes and security vulnerabilities. However, their detection and repair is challenging given that the correct usages of (third-party) <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">api</small> s might be obscure to the developers of client programs. This paper presents the first empirical study to assess the ability of existing automated bug repair tools to repair <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">api</small> misuses, which is a class of bugs previously unexplored. Our study examines and compares 14 Java test-suite-based repair tools (11 proposed before 2018, and three afterwards) on a manually curated benchmark ( <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">APIRepBench</small> ) consisting of 101 <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">api</small> misuses. We develop an extensible execution framework ( <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">APIARTy</small> ) to automatically execute multiple repair tools. Our results show that the repair tools are able to generate patches for 28 percent of the <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">api</small> misuses considered. While the 11 less recent tools are generally fast (the median execution time of the repair attempts is 3.87 minutes and the mean execution time is 30.79 minutes), the three most recent are less efficient (i.e., 98 percent slower) than their predecessors. The tools generate patches for <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">api</small> misuses that mostly belong to the categories of missing <monospace xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">null</monospace> check, missing value, missing exception, and missing call. Most of the patches generated by all tools are plausible (65 percent), but only few of these patches are semantically correct to human patches (25 percent). Our findings suggest that the design of future repair tools should support the localisation of complex bugs, including different categories of <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">api</small> misuses, handling of timeout issues, and ability to configure large software projects. Both <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">APIRepBench</small> and <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">APIARTy</small> have been made publicly available for other researchers to evaluate the capabilities of repair tools on detecting and fixing <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">api</small> misuses.

WITHDRAWN: Fault prediction based on spatial correlation analysis using VSM in distributed sensor network

Abstract Wireless sensor network (WSN) relies on a wide range of sensors used to measure information from a variety of sensitive applications in different environments. The main challenge in WSN applications is to accurately identify faults in an uneven situation and establish if an incident has happened. The measurements are used to estimate the condition of the monitoring system or environment. However, the quality of the parameters must be verified to ensure the reliability of the system. Sensors can be successful in these areas and can do the normal operation, but the instability might cause adverse environmental conditions, resource limitation, and software crashes, and so on. In this paper, we use the Vector Space Model (VSM) to provide Fault Prediction with a spatial correlation Analysis (FP-SPA) in distributed sensor networks. The FP-SPA method uses a vector of data collected from sensors to implement a mechanism for predicting faults by correlating the variation in response time (RT) and packets routed (PR) observations to estimate the node reliable or faulty. The experiment analysis by varying a reliability threshold shows an enhancement in the fault prediction accuracy with a low false alarm rate compared to other mechanisms.

A Praise for Defensive Programming: Leveraging Uncertainty for Effective Malware Mitigation

A promising avenue for improving the effectiveness of behavioral-based malware detectors is to leverage two-phase detection mechanisms. Existing problem in two-phase detection is that after the first phase produces borderline decision, suspicious behaviors are not well contained before the second phase completes. This paper improves CHAMELEON, a framework to realize the uncertain environment. CHAMELEON offers two environments: standard–for software identified as benign by the first phase, and uncertain–for software received borderline classification from the first phase. The uncertain environment adds obstacles to software execution through random perturbations applied probabilistically. We introduce a dynamic perturbation threshold that can target malware disproportionately more than benign software. We analyzed the effects of the uncertain environment by manually studying 113 software and 100 malware, and found that 92% malware and 10% benign software disrupted during execution. The results were then corroborated by an extended dataset (5,679 Linux malware samples) on a newer system. Finally, a careful inspection of the benign software crashes revealed some software bugs, highlighting CHAMELEON's potential as a practical complementary antimalware solution.

Aspects of blockchain reliability considering its consensus algorithms

The reliability of blockchain as an information system is discussed in this article. There were considered two types of models for blockchain systems. One assumes an almost ideal decentralized network with the probability of a software crash on an independent nodes, other adds to this approach a probability of the communication channels corruption. We study consensus algorithms used in blockchain and make assumptions about their reliability and functioning in practice.

Imbalanced metric learning for crashing fault residence prediction

As the software crash usually does great harm, locating the fault causing the crash (i.e., the crashing fault) has always been a hot research topic. As the stack trace in the crash reports usually contains abundant information related the crash, it is helpful to find the root cause of the crash. Recently, researchers extracted features of the crash, then constructed the classification model on the features to predict whether the crashing fault resides in the stack trace. This process can accelerate the debugging process and save debugging efforts. In this work, we apply a state-of-the-art metric learning method called IML to crash data for crashing fault residence prediction. This method uses Mahalanobis distance based metric learning to learn high-quality feature representation by reducing the distance between crash instances with the same label and increasing the distance between crash instances with different labels. In addition, this method designs a new loss function that includes four types of losses with different weights to cope with the class imbalanced issue of crash data. The experiments on seven open source software projects show that our IML method performs significantly better than nine sampling based and five ensemble based imbalanced learning methods in terms of three performance indicators.

Analyzing Software Rejuvenation Techniques in a Virtualized System: Service Provider and User Views

Virtualization technology has promoted the fast development and deployment of cloud computing, and is now becoming an enabler of Internet of Everything. Virtual machine monitor (VMM), playing a critical role in a virtualized system, is software and hence it suffers from software aging after a long continuous running as well as software crashes due to elusive faults. Software rejuvenation techniques can be adopted to reduce the impact of software aging. Although there existed analytical model-based approaches for evaluating software rejuvenation techniques, none analyzed both application service (AS) availability and job completion time in a virtualized system with live virtual machine (VM) migration. This paper aims to quantitatively analyze software rejuvenation techniques from service provider and user views in a virtualized system deploying VMM reboot and live VM migration techniques for rejuvenation, under the condition that all the aging time, failure time, VMM fixing time and live VM migration time follow general distributions. We construct an analytical model by using a semi-Markov process (SMP) and derive formulas for calculating AS availability and job completion time. By analytical experiments, we can obtain the optimal migration trigger intervals for achieving the approximate maximum AS availability and the approximate minimum job completion time, and then service providers can make decisions for maximizing the benefits of service providers and users by adjusting parameter values.

A Systematic Evaluation of Static API-Misuse Detectors

Application Programming Interfaces (APIs) often have usage constraints, such as restrictions on call order or call conditions. API misuses , i.e., violations of these constraints, may lead to software crashes, bugs, and vulnerabilities. Though researchers developed many API-misuse detectors over the last two decades, recent studies show that API misuses are still prevalent. Therefore, we need to understand the capabilities and limitations of existing detectors in order to advance the state of the art. In this paper, we present the first-ever qualitative and quantitative evaluation that compares static API-misuse detectors along the same dimensions, and with original author validation. To accomplish this, we develop MuC , a classification of API misuses, and MuBenchPipe , an automated benchmark for detector comparison, on top of our misuse dataset, MuBench . Our results show that the capabilities of existing detectors vary greatly and that existing detectors, though capable of detecting misuses, suffer from extremely low precision and recall. A systematic root-cause analysis reveals that, most importantly, detectors need to go beyond the naive assumption that a deviation from the most-frequent usage corresponds to a misuse and need to obtain additional usage examples to train their models. We present possible directions towards more-powerful API-misuse detectors.

Progress on software crash research

Software crashes represent unexpected program interrupts that manifest as software faults and can be dangerous in that their frequent occurrence diminishes user experience, can damage the reputation of a company, and potentially cause significant losses to stakeholders. The increasing scale and complexity of modern software requires methods for preventing/handling software crashes. Here, we briefly review and summarize progress in three areas of the research field associated with handling software crashes: crash analysis, crash reproduction, and crash localization and repair.

Fault resilient FPGA design for 28 nm ZYNQ system-on-chip based radiation monitoring system at CERN

CERN's new generation of radiation monitoring devices for radiation protection, CROME (CERN RadiatiOn Monitoring Electronics) uses a fully reconfigurable 28 nm Xilinx Zynq SoC (System on Chip) for high-end embedded calculations, communication and data storage. In order to meet stringent safety requirements applicable for radiation protection instrumentation, CROME uses the FPGA section of the SoC for all safety critical functions. Whereas the SoC's dual core ARM processor is running an embedded operating system which is used both for communication with the CERN supervisory system and for data management. Due to the use of an embedded Linux OS without a virtualisation layer, the functional reliability of the SoC's FPGA section is considered much greater than the ARM processing system which can be subject to software crashes due to data corruption. This assumption had a central role in CROME's calculation architecture. In order to confirm the assumption and therefore the reliability and robustness of our design, random faults have been voluntarily induced in the SoC by exposing it to ionising radiation of sufficient energy in the CHARM facility, creating Single Event Upsets (SEU). CROME is the first known radiation monitoring system using the FPGA section of a SoC in a safety application. This paper presents the characterisation results of the system in the CHARM facility during a testing campaign of 6 months under an average dose rate of ≥0.1 Gy/day. The tests have provided valuable information on the suitability of this architecture for similar applications.

My Health Record implementation in private specialist practice.

My Health Record implementation in private specialist practice.

Does the fault reside in a stack trace? Assisting crash localization by predicting crashing fault residence

Given a stack trace reported at the time of software crash, crash localization aims to pinpoint the root cause of the crash. Crash localization is known as a time-consuming and labor-intensive task. Without tool support, developers have to spend tedious manual effort examining a large amount of source code based on their experience. In this paper, we propose an automatic approach, namely CraTer, which predicts whether a crashing fault resides in stack traces or not (referred to as predicting crashing fault residence). We extract 89 features from stack traces and source code to train a predictive model based on known crashes. We then use the model to predict the residence of newly-submitted crashes. CraTer can reduce the search space for crashing faults and help prioritize crash localization efforts. Experimental results on crashes of seven real-world projects demonstrate that CraTer can achieve an average accuracy of over 92%.

ChangeLocator: locate crash-inducing changes based on crash reports

Software crashes are severe manifestations of software bugs. Debugging crashing bugs is tedious and time-consuming. Understanding software changes that induce a crashing bug can provide useful contextual information for bug fixing and is highly demanded by developers. Locating the bug inducing changes is also useful for automatic program repair, since it narrows down the root causes and reduces the search space of bug fix location. However, currently there are no systematic studies on locating the software changes to a source code repository that induce a crashing bug reflected by a bucket of crash reports. To tackle this problem, we first conducted an empirical study on characterizing the bug inducing changes for crashing bugs (denoted as crash-inducing changes). We also propose ChangeLocator, a method to automatically locate crash-inducing changes for a given bucket of crash reports. We base our approach on a learning model that uses features originated from our empirical study and train the model using the data from the historical fixed crashes. We evaluated ChangeLocator with six release versions of Netbeans project. The results show that it can locate the crash-inducing changes for 44.7%, 68.5%, and 74.5% of the bugs by examining only top 1, 5 and 10 changes in the recommended list, respectively. It significantly outperforms the existing state-of-the-art approach.