Software Fault Research Articles

Automatic software bug prediction using adaptive golden eagle optimizer with deep learning

In the software maintenance and development process, the software bug detection is an essential problem because it related with the complete software successes. So, the earlier software bug detection is essential to enhance the software efficiency, reliability, software quality and software cost. Moreover, the efficient software bug prediction is a critical as well as challenging operation. Hence, the efficient software bug prediction model is developed in this article. To achieve this objective, optimized long short-term memory is developed. The important stages of the proposed model is preprocessing, feature selection and bug detection. At first the input bug dataset is preprocessed. In preprocessing, the duplicate data instances are removed from the dataset. After the preprocessing, the feature selection is done by Adaptive Golden Eagle Optimizer (AGEO). Here the traditional GEO algorithm is altered by means of opposition-based learning (OBL). Finally, the proposed approach utilizes a long short-term memory (LSTM) based recurrent neural network (RNN) for bug prediction. Long Short-Term Memory (LSTM) network is a type of recurrent neural network. The promise and NASA dataset are considered as the input for bug prediction. the performance of proposed approach is analysed based on various metrics namely, accuracy, F- measure, G-measure and Matthews Correlation Coefficient (MCC).

Study of a New Software Reliability Growth Model under Uncertain Operating Environments and Dependent Failures

The coronavirus disease (COVID-19) outbreak has prompted various industries to embark on digital transformation efforts, with software playing a critical role. Ensuring the reliability of software is of the utmost importance given its widespread use across multiple industries. For example, software has extensive applications in areas such as transportation, aviation, and military systems, where reliability problems can result in personal injuries and significant financial losses. Numerous studies have focused on software reliability. In particular, the software reliability growth model has served as a prominent tool for measuring software reliability. Previous studies have often assumed that the testing environment is representative of the operating environment and that software failures occur independently. However, the testing and operating environments can differ, and software failures can sometimes occur dependently. In this study, we propose a new model that assumes uncertain operating environments and dependent failures. In other words, the model proposed in this study takes into account a wider range of environments. The numerical examples in this study demonstrate that the goodness of fit of the new model is significantly better than that of the existing SRGM. Additionally, we show the utilization of the sequential probability ratio test (SPRT) based on the new model to assess the reliability of the dataset.

Exploring knowledge management from a software engineering perspective

Context: The knowledge domain of software engineering (SE) gradually expands due to fast emerging technologies and complex organisational processes. The software industry represents a special focus of interest from a Knowledge Management (KM) perspective, as it is characterized by high employee turnover, a high level of outsourced projects, and an accelerated pace of technology innovations. Knowledge management can substantially influence SE knowledge's life cycle, contributing to better structuring of organisational processes of knowledge creation, knowledge transfer, and knowledge sharing. Reflecting on the trends for SE automation with artificial intelligence tools, KM approaches can enable companies and professionals to reconsider the future of SE work. Purpose: The present research aims to identify and investigate how implementing knowledge management principles and processes within the software engineering domain can facilitate the future transformation of software-related jobs. Based on a conceptual model, built upon the literature review, the paper analyses the quantitative data, collected from 91 software experts. Evaluating the impact of both organizational and domain types of SE knowledge, the discussion evaluates the unique value-adding SE processes along with models of how to explore AI applications to automate the SE domain. Results: The outcomes of the analysis identify the models of structuring knowledge management processes in SE both within the technological domain and organisational layers. The discussion section establishes suitable KM methods and approaches for supporting SE job transformation. It identifies the main knowledge management integration practices, demonstrating how combining KM with AI-based innovations may change the SE knowledge flow, improving substantially SE activities like onboarding new team members, monitoring software documentation, version control, and error tracking.

Dynamic Service Chaining for Ultra-Reliable Services in Softwarized Networks

Network softwarization is a paradigm shift for the next generation of network. Network Function Virtualization (NFV) softwarizes network functions as virtual network function (VNF) instances on top of a network infrastructure. Along with the merits of flexibility, programmability and reduced function provisioning cost, softwarization of network functions introduces new challenges of service’s reliability due to possible hardware failures, software bugs and hacker attacks. Currently reliable service provisioning schemes based on first-order statistics fails in accounting for the ultra-reliable needs of mission-critical services. In this paper, we propose a dynamic service chaining (DSC) framework to provision ultra-reliable services where the reliability is characterized by the probability distribution using extreme value theory. Our design objective is to minimize the number of backup VNF modules subject to reliability and resource constraints. Due to the dynamic nature of network, primary and backup VNFs are re-mapped to higher reliable physical machines in order to provide ultra-reliable services. Using Lyapunov stochastic optimization, primary VNF mapping and backup VNF selection are performed in the large and small timescales respectively. Numerical results show that the proposed DSC framework can guarantee ultra-reliable network services efficiently.

Enhanced Approach for Bug Severity Prediction: Experimentation and Scope for Improvements

Software development is an iterative process, where developers create, test, and refine their code until it is ready for release. Along the way, bugs and issues are inevitable. A bug can be any error identified in requirement specification, design or implementation of any project. These bugs need to be categorized and assigned to developers to be resolved. the number of bugs generated in any large scale project are vast in number. These bugs can have significant or no impact on the project depending on the type of bug. The aim of this study is to develop a deep learning-based bug severity prediction model that can accurately predict the severity levels of software bugs. This study aims to address the limitations of the current manual bug severity assessment process and provide an automated solution using various classifiers e.g. Naïve Bayes, Logistic regression, KNN and Support vector machine along with Mutual information as feature selection method, that can assist software development teams in giving severity code to bugs effectively. It seeks to improve the overall software development process by reducing the time and effort required for bug resolution and enhancing the quality and reliability of software.

On the validity of retrospective predictive performance evaluation procedures in just-in-time software defect prediction

Just-In-Time Software Defect Prediction (JIT-SDP) is concerned with predicting whether software changes are defect-inducing or clean. It operates in scenarios where labels of software changes arrive over time with delay, which in part corresponds to the time we wait to label software changes as clean (waiting time). However, clean labels decided based on waiting time may be different from the true labels of software changes, i.e., there may be label noise. This typically overlooked issue has recently been shown to affect the validity of continuous performance evaluation procedures used to monitor the predictive performance of JIT-SDP models during the software development process. It is still unknown whether this issue could potentially also affect evaluation procedures that rely on retrospective collection of software changes such as those adopted in JIT-SDP research studies, affecting the validity of the conclusions of a large body of existing work. We conduct the first investigation of the extent with which the choice of waiting time and its corresponding label noise would affect the validity of retrospective performance evaluation procedures. Based on 13 GitHub projects, we found that the choice of waiting time did not have a significant impact on the validity and that even small waiting times resulted in high validity. Therefore, (1) the estimated predictive performances in JIT-SDP studies are likely reliable in view of different waiting times, and (2) future studies can make use of not only larger (5k+ software changes), but also smaller (1k software changes) projects for evaluating performance of JIT-SDP models.

An investigation of online and offline learning models for online Just-in-Time Software Defect Prediction

Just-in-Time Software Defect Prediction (JIT-SDP) operates in an online scenario where additional training data is received over time. Existing online JIT-SDP studies used online Oza ensemble learning methods with Hoeffding Trees as base learners to learn and update JIT-SDP models over time in this scenario. However, it is unknown how these approaches compare against offline learning approaches adapted to operate in online scenarios, and how the use of any other online or offline base learners would affect online JIT-SDP in terms of predictive performance and computational cost. We therefore propose a new approach called Batch Oversampling Rate Boosting (BORB) that is able to use offline base learners in an online JIT-SDP scenario. Based on 10 open source projects, we provide a comprehensive evaluation of BORB with 5 different base learners and the existing online approach Oversampling Rate Boosting with 4 different base learners, both in within-project and cross-project online JIT-SDP scenarios. The results show that offline learning can lead to better predictive performance than the top performing online learning approaches considered in our study, at a higher computational cost. Cross-project data was helpful to improve predictive performance both for offline and online learning, but especially for online learning.

Programmable In-memory Computing Circuit of Fast Hartley Transform

Discrete Hartley transform is a core component of digital signal processing because of its advantages of fast computing speed and less power consumption. Traditional FPGA-based implementation methods have the disadvantage of high latency, which cannot meet the needs of energy-efficient computing in the Internet of Things era. Therefore, A programmable analog memory computing circuit is proposed to accelerate FHT and IFHT calculations for large-scale one-step matrix computation. By adjusting the weight of memristor, different scales of FHT calculation can be achieved. PSPICE simulation results show that the average accuracy of the proposed circuit can reach 99.9%, and the speed can also reach the level of 0.1 μ s. The robustness analysis shows that the circuit can tolerate a certain degree of programming error and resistance tolerance. The designed analog circuit is applied to image compression processing, and the image compression accuracy can reach 99.9%.

Penanganan Data Tidak Seimbang Menggunakan Hybrid Method Resampling Pada Algoritma Naive Bayes Untuk Software Defect Prediction

Software defect prediction is software data that is used to identify a software module and can also be used to predict software defects. Before carrying out further trials, it is necessary to carry out special handling, especially by using algorithm models as predictions of software defects with the aim of obtaining information from the device being developed. Therefore, it is necessary to predict software defects using appropriate classification and prediction methods, so that the resulting accuracy results are better. In this study, the naïve Bayes algorithm was used as a classification with a resampling technique approach to handle unbalanced data, including SMOTEENN and SMOTETomek. The best accuracy results in the research conducted were 92.5% on the Nasa Repository PC4 dataset

An Innovative Approach for Predicting Software Defects by Handling Class Imbalance Problem

From last decade unbalanced data has gained attention as a major challenge for enhancing software quality and reliability. Due to evolution in advanced software development tools and processes, today’s developed software product is much larger and complicated in nature. The software business faces a major issue in maintaining software performance and efficiency as well as cost of handling software issues after deployment of software product. The effectiveness of defect prediction model has been hampered by unbalanced data in terms of data analysis, biased result, model accuracy and decision making. Predicting defects before they affect your software product is one way to cut costs required to maintain software quality. In this study we are proposing model using two level approach for class imbalance problem which will enhance accuracy of prediction model. In the first level, model will balance predictive class at data level by applying sampling method. Second level we will use Random Forest machine learning approach which will create strong classifier for software defect. Hence, we can enhance software defect prediction model accuracy by handling class imbalance issue at data and algorithm level.

Optimized Deeplearning Algorithm for Software Defects Prediction

Accurate software defect prediction (SDP) helps to enhance the quality of the software by identifying potential flaws early in the development process. However, existing approaches face challenges in achieving reliable predictions. To address this, a novel approach is proposed that combines a two-tier-deep learning framework. The proposed work includes four major phases:(a) pre-processing, (b) Dimensionality reduction, (c) Feature Extraction and (d) Two-fold deep learning-based SDP. The collected raw data is initially pre-processed using a data cleaning approach (handling null values and missing data) and a Decimal scaling normalisation approach. The dimensions of the pre-processed data are reduced using the newly developed Incremental Covariance Principal Component Analysis (ICPCA), and this approach aids in solving the “curse of dimensionality” issue. Then, onto the dimensionally reduced data, the feature extraction is performed using statistical features (standard deviation, skewness, variance, and kurtosis), Mutual information (MI), and Conditional entropy (CE). From the extracted features, the relevant ones are selected using the new Euclidean Distance with Mean Absolute Deviation (ED-MAD). Finally, the SDP (decision making) is carried out using the optimized Two-Fold Deep Learning Framework (O-TFDLF), which encapsulates the RBFN and optimized MLP, respectively. The weight of MLP is fine-tuned using the new Levy Flight Cat Mouse Optimisation (LCMO) method to improve the model's prediction accuracy. The final detected outcome (forecasting the presence/ absence of defect) is acquired from optimized MLP. The implementation has been performed using the MATLAB software. By using certain performance metrics such as Sensitivity, Accuracy, Precision, Specificity and MSE the proposed model’s performance is compared to that of existing models. The accuracy achieved for the proposed model is 93.37%.

Modularity, Code Specialization, and Zero-Cost Abstractions for Program Verification

For all the successes in verifying low-level, efficient, security-critical code, little has been said or studied about the structure, architecture and engineering of such large-scale proof developments. We present the design, implementation and evaluation of a set of language-based techniques that allow the programmer to modularly write and verify code at a high level of abstraction, while retaining control over the compilation process and producing high-quality, zero-overhead, low-level code suitable for integration into mainstream software. We implement our techniques within the F proof assistant, and specifically its shallowly-embedded Low toolchain that compiles to C. Through our evaluation, we establish that our techniques were critical in scaling the popular HACL library past 100,000 lines of verified source code, and brought about significant gains in proof engineer productivity. The exposition of our methodology converges on one final, novel case study: the streaming API, a finicky API that has historically caused many bugs in high-profile software. Using our approach, we manage to capture the streaming semantics in a generic way, and apply it “for free” to over a dozen use-cases. Six of those have made it into the reference implementation of the Python programming language, replacing the previous CVE-ridden code.

Formal Specification and Testing for Reinforcement Learning

The development process for reinforcement learning applications is still exploratory rather than systematic. This exploratory nature reduces reuse of specifications between applications and increases the chances of introducing programming errors. This paper takes a step towards systematizing the development of reinforcement learning applications. We introduce a formal specification of reinforcement learning problems and algorithms, with a particular focus on temporal difference methods and their definitions in backup diagrams. We further develop a test harness for a large class of reinforcement learning applications based on temporal difference learning, including SARSA and Q-learning. The entire development is rooted in functional programming methods; starting with pure specifications and denotational semantics, ending with property-based testing and using compositional interpreters for a domain-specific term language as a test oracle for concrete implementations. We demonstrate the usefulness of this testing method on a number of examples, and evaluate with mutation testing. We show that our test suite is effective in killing mutants (90% mutants killed for 75% of subject agents). More importantly, almost half of all mutants are killed by generic write-once-use-everywhere tests that apply to any reinforcement learning problem modeled using our library, without any additional effort from the programmer.

Predicting software defects with swarm-intelligence-based machine learning algorithm for improved process quality

The quality and effectiveness of software systems may be significantly impacted by Software Defects (SD). Therefore, enhancing process quality is essential for controlling and minimizing the incidence of faults. Implementing reliable Software Development (SDe) processes and best practices is one way to do this information. SD, commonly referred to as software bugs or software mistakes, are defects or errors that occur in computer programs and cause them to act up or create unintended outcomes. These vulnerabilities may appear for several causes, including programming mistakes, poor design choices, or issues with the SDe cycle. The prediction of software problems based on Machine Learning (ML) using an Enhanced Artificial Neural Network (E-ANN) is implemented in this study to increase software quality and testing effectiveness. Particle swarm optimization and grey wolf optimization, these two algorithms named grey wolf swarm optimization algorithm (GWSA), are combined to recognize the corresponding compensation of the methods following the respective benefits and drawbacks. The hybrid algorithm-based model to the conventional hyperparameter optimization strategy and a single swarm intelligence algorithm's investigation of investigational consequences from six data sets shows that the hybrid algorithm-based model has high and enhanced indicators. Processed by the autoencoder, the model's performance has also improved.

Software Testing: A Prediction Techniques

Prediction of software defects using machine learning techniques has attracted more attention from researchers due to its importance in producing successful software. On the other side, it reduces the cost of software development and facilitates procedures to identify the reasons for determining the percentage of defect-prone software in the future. There is no conclusive evidence for specific types of machine learning that will be more efficient and accurate in predicting software defects. However, some of the previous related work proposes ensemble learning techniques as a more accurate alternative. The paper presents the resample technique with three types of ensemble learners; Boosting, Bagging, and Rotation Forest, using eight base learners tested on seven types of benchmark datasets provided in the PROMISE repository. Results indicate that accuracy has been improved using ensemble techniques more than single leaners especially in conjunction with Rotation Forest with the resample technique in most of the algorithms used in the experimental results.

Cervical cancer screening and treatment for PLWHIV: experiences from an innovative program in Nigeria

BackgroundWe evaluated cervical cancer program for women living with HIV (WLHIV) to determine program screening rate, primary case finder screening accuracy and treatment and post-treatment screening rate among screen-positive patients.MethodsA ten-month review of cervical cancer program data among WLHIV aged 15–49 years on HIV care across forty-one comprehensive ART sites, supported by APIN (a PEPFAR implementing partner) for cervical cancer screening and treatment in Nigeria, was conducted from October 2020 to July 2021. Initial screening was done using visual inspection with acetic acid (VIA) followed by a gynaecologist expert review through a program-designed software named AVIVA, as a confirmatory test. Associations were measured between the primary case finder screening accuracy and study covariates at p-value of 0.05.ResultsAbout 10,289 asymptomatic women aged 15–49 years living with HIV were screened for cervical cancer by primary case finders using VIA-based screening test. About 732 (7.1%) had a positive screening test suggestive of precancerous lesions or cervical cancer. Three hundred and fifteen (43.0%) of VIA positive women had treatment using thermal ablation and less than one-third (21.6%) of those treated came back for post-treatment screening test. Primary case finder screening sensitivity, specificity, positive predictive and negative predictive accuracy using gynaecologist review as confirmatory test were 60.8%, 71.5%, 41.7% and 84.5% respectively. Overall screening accuracy was 68.8%.Conclusion and recommendationsThis innovative approach to cervical cancer screening among WLHIV yielded modest results in preventing program error and wastages. Wider deployment of expert-based reviews of VIA though AVIVA software might be a veritable approach to improve screening accuracy in low resource settings.

An Exploratory Study Gathering Security Requirements for the Software Development Process

Software development stands out as one of the most rapidly expanding markets due to its pivotal role in crafting applications across diverse sectors like healthcare, transportation, and finance. Nevertheless, the sphere of cybersecurity has also undergone substantial growth, underscoring the escalating significance of software security. Despite the existence of different secure development frameworks, the persistence of vulnerabilities or software errors remains, providing potential exploitation opportunities for malicious actors. One pivotal contributor to subpar security quality within software lies in the neglect of cybersecurity requirements during the initial phases of software development. In this context, the focal aim of this study is to analyze the importance of integrating security modeling by software developers into the elicitation processes facilitated through the utilization of abuse stories. To this end, the study endeavors to introduce a comprehensive and generic model for a secure software development process. This model inherently encompasses critical elements such as new technologies, human factors, and the management of security for the formulation of abuse stories and their integration within Agile methodological processes.

Software defect prediction method based on the heterogeneous integration algorithm

A software defect is a common cyberspace security problem, leading to information theft, system crashes, and other network hazards. Software security is a fundamental challenge for cyberspace security defense. However, when researching software defects, the defective code in the software is small compared with the overall code, leading to data imbalance problems in predicting software vulnerabilities. This study proposes a heterogeneous integration algorithm based on imbalance rate threshold drift for the data imbalance problem and for predicting software defects. First, the Decision Tree-based integration algorithm was designed following sample perturbation. Moreover, the Support Vector Machine (SVM)-based integration algorithm was designed based on attribute perturbation. Following the heterogeneous integration algorithm, the primary classifier was trained by sample diversity and model structure diversity. Second, we combined the integration algorithms of two base classifiers to form a heterogeneous integration model. The imbalance rate was designed to achieve threshold transfer and obtain software defect prediction results. Finally, the NASA-MDP and Juliet datasets were used to verify the heterogeneous integration algorithm’s validity, correctness, and generalization based on the Decision Tree and SVM.

Automatic Software Bug Prediction Using Adaptive Artificial Jelly Optimization With Long Short-Term Memory

AbstractIn the software maintenance and development process, software bug detection is an essential problem because it is related to complete software success. It is recommended to begin anticipating defects at the early stages of creation rather than during the assessment process due to the high expense of fixing the found bugs. The early stage software bug detection is used to enhance software efficiency, reliability, and software quality. Nevertheless, creating a reliable bug-forecasting system is a difficult challenge. Therefore, in this paper, an efficient, software bug forecast is developed. The presented technique consists of three stages namely, pre-processing, feature selection, and bug prediction. At first, the input datasets are pre-processed to eliminate the identical data from the dataset. After the pre-processing, the important features are selected using an adaptive artificial jelly optimization algorithm (A2JO) to eliminate the possibility of overfitting and reduce the complexity. Finally, the selected features are given to the long short-term memory (LSTM) classifier to predict whether the given data is defective or non-defective. In this paper, investigations are shown on visibly obtainable bug prediction datasets namely, promise and NASA which is a repository for most open-source software. The efficiency of the presented approach is discussed based on various metrics namely, accuracy, F- measure, G-measure, and Matthews Correlation Coefficient (MCC). The experimental result shows our proposed method achieved the extreme accuracy of 93.41% for the Promise dataset and 92.8% for the NASA dataset.

Parameter tuning for software fault prediction with different variants of differential evolution

The cost of software testing could be reduced if faulty entities were identified prior to the testing phase, which is possible with software fault prediction (SFP). In most SFP models, machine learning (ML) methods are used, and one aspect of improving prediction accuracy with these methods is tuning their control parameters. However, parameter tuning has not been addressed properly in the field of software analytics, and the conventional methods (such as basic Differential Evolution, Random Search, and Grid Search) are either not up-to-date, or suffer from shortcomings, such as the inability to benefit from prior experience, or are overly expensive. This study aims to examine and propose parameter tuners, called DEPTs, based on different variants of Differential Evolution for SFP with the Swift-Finalize strategy (to reduce runtime), which in addition to being up-to-date, have overcome many of the challenges associated with common methods. An experimental framework was developed to compare DEPTs with three widely used parameter tuners, applied to four common data miners, on 10 open-source projects, and to evaluate the performance of DEPTs, we used eight performance measures. According to our results, the three tuners out of five DEPTs improved prediction accuracy in more than 70% of tuned cases, and occasionally, they exceeded benchmark methods by over 10% in case of G-measure. The DEPTs took reasonable amounts of time to tune parameters for SFP as well.