Bug Detection Research Articles

Hunting Energy Bugs in Embedded Systems: A Software-Model-In-The-Loop Approach

Power consumption has become a major design constraint, especially for battery-powered embedded systems. However, the impact of software applications is typically considered in later phases, where both software and hardware parts are close to their finalization. Power-related issues must be detected in early stages to keep the development costs low, satisfy time-to-market, and avoid cost-intensive redesign loops. Moreover, the variety of hardware components, architectures, and communication interfaces make the development of embedded software more challenging. To manage the complexity of software applications, approaches such as model-driven development (MDD) may be used. This article proposes a power-estimation approach in MDD for software application models in early development phases. A unified modeling language (UML) profile is introduced to model power-related properties of hardware components. To determine the impact of software applications, we defined two analysis methods using simulation data and a novel in-the-loop concept. Both methods may be applied at different development stages to determine an energy trace, describing the energy-related behavior of the system. A novel definition of energy bugs is provided to describe power-related misbehavior. We apply our approach to a sensor node example, demonstrate an energy bug detection, and compare the runtime and accuracy of the analysis methods.

Prediction of Software Bugs Using FCM Fused Artificial Neural Network Classifier

The software engineering technique makes it possible to create high-quality software. One of the most significant qualities of good software is that it is bug-free. Bug detection and prevention aims to provide high-quality software that reduces the cost and time required to fix a defect, increases productivity, and allows for complete customer satisfaction. While it will be impossible to eradicate all flaws, it will be able to reduce the number of problems and their negative influence on software quality. This may be accomplished by putting in place a bug prediction mechanism that focuses on increasing software quality by lowering defect density. To extract usable information, soft computing approaches such as data mining and machine learning algorithms can be used. Soft computing approaches have been used to solve the problem of software bug prediction in a number of researches. The ability to predict necessary bugs considerably sooner in the development process is a major incentive for this study. The purpose is to stimulate people's interest in software quality testing and encourage them to employ fuzzy c means clustering (FCM), artificial neural network (ANN), and machine learning approaches to solve challenges in the field of software project success prediction. The FCM fused ANN used for bug prediction model in this study to predict software reliability. With an accuracy of 98.237percent, this research effort exhibits the usefulness and applicability of FCM fused ANN technology.

Indexing source code and clone detection

Searching source code is a common task in code recommendation systems as well as in many other areas. Clone detection is used in software maintenance and bug detection. The paper introduces an algorithm for building the index structure of abstract syntax trees . When the index structure is built, a pattern tree can be found in time linear in the length of the pattern. Furthermore, the paper describes DrDup2 and DrDupLex , two open-source tools that use the index structure to find Type-2 clones. The index structure presented in this paper is based on the trie, which is a fundamental data structure in computer science. Evaluation of the presented clone detectors is done on BigCloneBench, which is a well-established benchmark for clone detection. Comparison with three state-of-the-art clone detectors ( NiCad , CloneWorks and SourcererCC ) shows that DrDup2 and DrDupLex are able to beat them in precision, recall and running time. The presented index structure can be used for example to speed up searching for code fragments in code recommendation systems. It is also shown that it can be used to detect Type-2 clones with high precision and recall.

An open-source natural language processing toolkit to support software development: addressing automatic bug detection, code summarisation and code search

This paper aims to introduce the innovative work carried out in the Horizon 2020 DECODER project – acronym for “DEveloper COmpanion for Documented and annotatEd code Reference” – (Grant Agreement no. 824231) by linking the fields of natural language processing (NLP) and software engineering. The project as a whole addresses the development of a framework, namely the Persistent Knowledge Monitor (PKM), that acts as a central infrastructure to store, access, and trace all the data, information and knowledge related to a given software or ecosystem. This meta-model defines the knowledge base that can be queried and analysed by all the tools integrated and developed in DECODER. Besides, the DECODER project offers a friendly user interface where each of the predefined three roles (i.e., developers, maintainers and reviewers) can access and query the PKM with their personal accounts. The paper focuses on the NLP tools developed and integrated in the PKM, namely the deep learning models developed to perform variable misuse, code summarisation and semantic parsing. These were developed under a common work package – “Activities for the developer” – intended to precisely target developers, who can perform tasks such as detection of bugs, automatic generation of documentation for source code and generation of code snippets from natural languages instructions, among the multiple functionalities that DECODER offers. These tools assist and help the developers in the daily work, by increasing their productivity and avoiding loss of time in tedious tasks such as manual bug detection. Training and validation were conducted for four use cases in Java, C and C++ programming languages in order to evaluate the performance, suitability, usability, etc. of the developed tools.

Context- and Fairness-Aware In-Process Crowdworker Recommendation

Identifying and optimizing open participation is essential to the success of open software development. Existing studies highlighted the importance of worker recommendation for crowdtesting tasks in order to improve bug detection efficiency, i.e., detect more bugs with fewer workers. However, there are a couple of limitations in existing work. First, these studies mainly focus on one-time recommendations based on expertise matching at the beginning of a new task. Second, the recommendation results suffer from severe popularity bias, i.e., highly experienced workers are recommended in almost all the tasks, while less experienced workers rarely get recommended. This article argues the need for context- and fairness-aware in-process crowdworker recommendation in order to address these limitations. We motivate this study through a pilot study, revealing the prevalence of long-sized non-yielding windows, i.e., no new bugs are revealed in consecutive test reports during the process of a crowdtesting task. This indicates the potential opportunity for accelerating crowdtesting by recommending appropriate workers in a dynamic manner, so that the non-yielding windows could be shortened. Besides, motivated by the popularity bias in existing crowdworker recommendation approach, this study also aims at alleviating the unfairness in recommendations. Driven by these observations, this article proposes a context- and fairness-aware in-process crowdworker recommendation approach, iRec2.0, to detect more bugs earlier, shorten the non-yielding windows, and alleviate the unfairness in recommendations. It consists of three main components: (1) the modeling of dynamic testing context, (2) the learning-based ranking component, and (3) the multi-objective optimization-based re-ranking component. The evaluation is conducted on 636 crowdtesting tasks from one of the largest crowdtesting platforms, and results show the potential of iRec2.0 in improving the cost-effectiveness of crowdtesting by saving the cost, shortening the testing process, and alleviating the unfairness among workers. In detail, iRec2.0 could shorten the non-yielding window by a median of 50%–66% in different application scenarios, and consequently have potential of saving testing cost by a median of 8%–12%. Meanwhile, the recommendation frequency of the crowdworker drop from 34%–60% to 5%–26% under different scenarios, indicating its potential in alleviating the unfairness among crowdworkers.

Software Bug Detection Causes a Shift From Bottom-Up to Top-Down Effective Connectivity Involving the Insula Within the Error-Monitoring Network.

The neural correlates of software programming skills have been the target of an increasing number of studies in the past few years. Those studies focused on error-monitoring during software code inspection. Others have studied task-related cognitive load as measured by distinct neurophysiological measures. Most studies addressed only syntax errors (shallow level of code monitoring). However, a recent functional MRI (fMRI) study suggested a pivotal role of the insula during error-monitoring when challenging deep-level analysis of code inspection was required. This raised the hypothesis that the insula is causally involved in deep error-monitoring. To confirm this hypothesis, we carried out a new fMRI study where participants performed a deep source-code comprehension task that included error-monitoring to detect bugs in the code. The generality of our paradigm was enhanced by comparison with a variety of tasks related to text reading and bugless source-code understanding. Healthy adult programmers (N = 21) participated in this 3T fMRI experiment. The activation maps evoked by error-related events confirmed significant activations in the insula [p(Bonferroni) < 0.05]. Importantly, a posterior-to-anterior causality shift was observed concerning the role of the insula: in the absence of error, causal directions were mainly bottom-up, whereas, in their presence, the strong causal top-down effects from frontal regions, in particular, the anterior cingulate cortex was observed.

Detecting Resource Release Bugs with Analogical Reasoning

The resource release bugs are a common type of serious programming bug. However, it is hard to catch them by using static detection for the lacking of comprehensive prior knowledge about the release functions. In this paper, a resource release bug detection method is proposed by introducing analogical reasoning on word vectors. First, the functions of the target source code are encoded into word vectors by the word embedding technique in natural language processing. Second, a two-stage reasoning method is developed for automatically identifying unknown resource release functions according to a few well-known seed functions. 3CosAvg algorithm is employed for the first stage, and a new algorithm is designed for the latter, called 3CosAddExchange. Finally, the identified release functions are translated into static analysis rules to detect potential bugs. The experiment shows that the proposed method is effective and efficient for the large-scale software project. Five unknown resource release bugs are successfully detected in the Linux kernel and confirmed by kernel developers.

ProcessPerformance: A portable and easy-to-use tool to measure resource consumption of running processes

<h2>Abstract</h2> The measurement of the resources consumed by an application at runtime is an important task in different scenarios such as program optimization, malware and bug detection, and hardware scaling. Although different tools exist for this purpose, they sometimes show some limitations such as operating system and hardware dependencies, performance overhead, and usage complexity. For this reason, we create ProcessPerformance, a portable and easy-to-use command-line tool that provides information about the CPU, memory, and network resources consumed by any combination of running processes. It also avoids the performance overhead caused by software and binary code injection.

Organizing for permanent beta: performance measurement before vs performance monitoring after release of digital services

PurposeDue to the complexity of digital services, companies are increasingly forced to offer their services “in permanent beta”, requiring continuous fine-tuning and updating. Complexity makes it extremely difficult to predict when and where the next service disruption will occur. The authors examine what this means for performance measurement in digital service supply chains.Design/methodology/approachThe authors use a mixed-method research design that combines a longitudinal case study of a European digital TV service provider and a system dynamics simulation analysis of that service provider's digital service supply chain.FindingsWith increased levels of complexity, traditional performance measurement methods, focused on detection of software bugs before release, become fragile or futile. The authors find that monitoring the performance of the service after release, with fast mitigation when service incidents are discovered, appears to be superior. This involves organizational change when traditional methods, like quality assurance, become less important.Research limitations/implicationsThe performance of digital services needs to be monitored by combining automated data collection about the status of the service with data interpretation using human expertise. Investing in human expertise is equally important as investing in automated processes.Originality/valueThe authors draw on unique empirical data collected from a digital service provider's struggle with performance measurement of its service over a period of nine years. The authors use simulations to show the impact of complexity on staff allocation.

Intraprocedural Analysis Based on Symbolic Execution for Bug Detection

Intraprocedural Analysis Based on Symbolic Execution for Bug Detection

Statistical model checking for variability-intensive systems: applications to bug detection and minimization

We propose a new Statistical Model Checking (SMC) method toidentify bugs in variability-intensive systems (VIS). Thestate-space of such systems is exponential in the number ofvariants, which makes the verification problem harder than forclassical systems. To reduce verification time, we propose tocombine SMC with featured transition systems (FTS)—amodel that represents jointly the state spaces of all variants. Ournew methods allow the sampling of executions from one or more(potentially all) variants. We investigate their utility in twocomplementary use cases. The first case considers the problem offinding all variants that violate a given property expressed inLinear-Time Logic (LTL) within a given simulation budget. To achievethis, we perform random walks in the featured transition systemseeking accepting lassos. We show that our method allows us to findbugs much faster (up to 16 times according to our experiments) thanexhaustive methods. As any simulation-based approach, however, therisk of Type-1 error exists. We provide a lower bound and an upperbound for the number of simulations to perform to achieve thedesired level of confidence. Our empirical study involving 59properties over three case studies reveals that our method managesto discover all variants violating 41 of the properties.This indicates that SMC can act as a coarse-grainedanalysis method to quickly identify the set of buggy variants.The second case complements the first one. In case thecoarse-grained analysis reveals that no variant can guarantee tosatisfy an intended property in all their executions, one shouldidentify the variant that minimizes the probability of violatingthis property. Thus, we propose a fine-grained SMC method thatquickly identifies promising variants and accurately estimates theirviolation probability. We evaluate different selection strategiesand reveal that a genetic algorithm combined with elitist selectionyields the best results.

SRGM Dependent Learning based Testing Effort for Refinement

Abstract: During the development of software code there is a pressing necessity to remove the faults or bugs and improve software reliability. To get the accurate result, in every phase of software development cycle assessments needs to be happen, so that in each phase early bugs detection takes place that leads to maintain accuracy at each level. The academic institutions and industries are enhancing the development techniques in software engineering and their by performing regular testing for finding faults in programmers of software during the development. New programs are composed by altered the original code by comprised more of a bias near statements that arise in pessimistic execution paths. Fault localization information technique is used in proposed method to indicate the position of fault. In experimental as well as regression based equations represent the soft computing techniques results is better compare to the other techniques. Evaluation of soft-computing techniques represented that accuracy of the ANN model is superior to the other models. Data bases for performing the training and testing stages were collected, these soft computing techniques had low computational errors than the empirical equations. Finally says that soft computing models are better compare to the regression models. Hence, finding faults and correcting a serious software problem would be better instead of recalling thousands of products, especially in automotive sector. SRGM success mainly reliable by gathering the accurate failure information. The functions of the software reliability growth model were predicted in terms of such information gathered only. SRGM techniques in the literature and it gives a reasonable capability of value for actual software failure data. Therefore, this model, in future, can be applied to operate a wide range of software and its applications. Keywords: SRGM, FDP, FCP

An optimal scheduling policy for upgraded software with updates

PurposeIn the current market scenario, software upgrades and updates have proved to be very handy in improving the reliability of the software in its operational phase. Software upgrades help in reinventing working software through major changes, like functionality addition, feature enhancement, structural changes, etc. In software updates, minor changes are undertaken which help in improving software performance by fixing bugs and security issues in the current version of the software. Through the current proposal, the authors wish to highlight the economic benefits of the combined use of upgrade and update service. A cost analysis model has been proposed for the same.Design/methodology/approachThe article discusses a cost analysis model highlighting the distinction between launch time and time to end the testing process. The number of bugs which have to be catered in each release has been determined which also consists of the count of latent bugs of previous version. Convolution theory has been utilized to incorporate the joint role of tester and user in bug detection into the model. The cost incurred in debugging process was determined. An optimization model was designed which considers the reliability and budget constraints while minimizing the total debugging cost. This optimization was used to determine the release time and testing stop time.FindingsThe proposal is backed by real-life software bug dataset consisting of four releases. The model was able to successfully determine the ideal software release time and the testing stop time. An increased profit is generated by releasing the software earlier and continues testing long after its release.Originality/valueThe work contributes positively to the field by providing an effective optimization model, which was able to determine the economic benefit of the combined use of upgrade and update service. The model can be used by management to determine their timelines and cost that will be incurred depending on their product and available resources.

Survey on Machine Learning Algorithms Enhancing the Functional Verification Process

The continuing increase in functional requirements of modern hardware designs means the traditional functional verification process becomes inefficient in meeting the time-to-market goal with sufficient level of confidence in the design. Therefore, the need for enhancing the process is evident. Machine learning (ML) models proved to be valuable for automating major parts of the process, which have typically occupied the bandwidth of engineers; diverting them from adding new coverage metrics to make the designs more robust. Current research of deploying different (ML) models prove to be promising in areas such as stimulus constraining, test generation, coverage collection and bug detection and localization. An example of deploying artificial neural network (ANN) in test generation shows 24.5× speed up in functionally verifying a dual-core RISC processor specification. Another study demonstrates how k-means clustering can reduce redundancy of simulation trace dump of an AHB-to-WHISHBONE bridge by 21%, thus reducing the debugging effort by not having to inspect unnecessary waveforms. The surveyed work demonstrates a comprehensive overview of current (ML) models enhancing the functional verification process from which an insight of promising future research areas is inferred.

Ethereum Smart Contract Bug Detection and Repair Approach Based on Regular Expressions, Program Instrumentation and Code Replacement

Ethereum Smart Contract Bug Detection and Repair Approach Based on Regular Expressions, Program Instrumentation and Code Replacement

JavaDL: automatically incrementalizing Java bug pattern detection

Static checker frameworks support software developers by automatically discovering bugs that fit general-purpose bug patterns. These frameworks ship with hundreds of detectors for such patterns and allow developers to add custom detectors for their own projects. However, existing frameworks generally encode detectors in imperative specifications, with extensive details of not only what to detect but also how . These details complicate detector maintenance and evolution, and also interfere with the framework’s ability to change how detection is done, for instance, to make the detectors incremental. In this paper, we present JavaDL, a Datalog-based declarative specification language for bug pattern detection in Java code. JavaDL seamlessly supports both exhaustive and incremental evaluation from the same detector specification. This specification allows developers to describe local detector components via syntactic pattern matching , and nonlocal (e.g., interprocedural) reasoning via Datalog-style logical rules . We compare our approach against the well-established SpotBugs and Error Prone tools by re-implementing several of their detectors in JavaDL. We find that our implementations are substantially smaller and similarly effective at detecting bugs on the Defects4J benchmark suite, and run with competitive runtime performance. In our experiments, neither incremental nor exhaustive analysis can consistently outperform the other, which highlights the value of our ability to transparently switch execution modes. We argue that our approach showcases the potential of clear-box static checker frameworks that constrain the bug detector specification language to enable the framework to adapt and enhance the detectors.

Detection and monitoring of bed bugs (Hemiptera: Cimicidae): review of the underlying science, existing products and future prospects.

Bed bugs, Cimex lectularius L. and C. hemipterus (F.) (Hemiptera: Cimicidae) are hematophagous ectoparasites of humans. Since the resurgence of bed bugs in the late 1990s there has been a corresponding emphasis on development and implementation of integrated pest management (IPM) programs to manage infestations. One critical requirement of IPM is the ability to detect and monitor the target pest. We outline and describe the majority of all known existing devices and technologies developed for bed bug detection and monitoring as well as much of the underlying science. Almost 40 detection and monitoring products have flooded the marketplace, but for various reasons, including price, size, complexity and lack of independent scientific evaluation, they have not been widely adopted for IPM in structures. One product, the ClimbUp® Insect Interceptor, has nine competitors that utilize a similar design. This review also discloses many other technologies and products that are either too expensive or too impractical for use as either consumer or industrial products. We conclude that there is a critical need for inexpensive and effective detection and monitoring traps and lures suitable for widespread adoption by the urban pest control industry. © 2021 Society of Chemical Industry.

Reading and Calculation Neural Systems and Their Weighted Adaptive Use for Programming Skills.

Software programming is a modern activity that poses strong challenges to the human brain. The neural mechanisms that support this novel cognitive faculty are still unknown. On the other hand, reading and calculation abilities represent slightly less recent human activities, in which neural correlates are relatively well understood. We hypothesize that calculus and reading brain networks provide joint underpinnings with distinctly weighted contributions which concern programming tasks, in particular concerning error identification. Based on a meta-analysis of the core regions involved in both reading and math and recent experimental evidence on the neural basis of programming tasks, we provide a theoretical account that integrates the role of these networks in program understanding. In this connectivity-based framework, error-monitoring processing regions in the frontal cortex influence the insula, which is a pivotal hub within the salience network, leading into efficient causal modulation of parietal networks involved in reading and mathematical operations. The core role of the anterior insula and anterior midcingulate cortex is illuminated by their relation to performance in error processing and novelty. The larger similarity that we observed between the networks underlying calculus and programming skills does not exclude a more limited but clear overlap with the reading network, albeit with differences in hemispheric lateralization when compared with prose reading. Future work should further elucidate whether other features of computer program understanding also use distinct weights of phylogenetically “older systems” for this recent human activity, based on the adjusting influence of fronto-insular networks. By unraveling the neural correlates of program understanding and bug detection, this work provides a framework to understand error monitoring in this novel complex faculty.

Deforestation effects on Attalea palms and their resident Rhodnius, vectors of Chagas disease, in eastern Amazonia.

Attalea palms provide primary habitat to Rhodnius spp., vectors of Trypanosoma cruzi. Flying from palms, these blood-sucking bugs often invade houses and can infect people directly or via food contamination. Chagas disease (CD) risk may therefore increase when Attalea palms thrive near houses. For example, Attalea dominate many deforested landscapes of eastern Amazonia, where acute-CD outbreaks are disturbingly frequent. Despite this possible link between deforestation and CD risk, the population-level responses of Amazonian Attalea and their resident Rhodnius to anthropogenic landscape disturbance remain largely uncharted. We studied adult Attalea palms in old-growth forest (OGF), young secondary forest (YSF), and cattle pasture (CP) in two localities of eastern Amazonia. We recorded 1856 Attalea along 10 transects (153.6 ha), and detected infestation by Rhodnius spp. in 18 of 280 systematically-sampled palms (33 bugs caught). Distance-sampling models suggest that, relative to OGF, adult Attalea density declined by 70–80% in CP and then recovered in YSF. Site-occupancy models estimate a strong positive effect of deforestation on palm-infestation odds (βCP-infestation = 4.82±1.14 SE), with a moderate decline in recovering YSF (βYSF-infestation = 2.66±1.10 SE). Similarly, N-mixture models suggest that, relative to OGF, mean vector density sharply increased in CP palms (βCP-density = 3.20±0.62 SE) and then tapered in YSF (βYSF-density = 1.61±0.76 SE). Together, these results indicate that disturbed landscapes may support between ~2.5 (YSF) and ~5.1 (CP) times more Attalea-dwelling Rhodnius spp. per unit area than OGF. We provide evidence that deforestation may favor palm-dwelling CD vectors in eastern Amazonia. Importantly, our landscape-disturbance effect estimates explicitly take account of (i) imperfect palm and bug detection and (ii) the uncertainties about infestation and vector density arising from sparse bug data. These results suggest that incorporating landscape-disturbance metrics into the spatial stratification of transmission risk could help enhance CD surveillance and prevention in Amazonia.

Context-Aware Personalized Crowdtesting Task Recommendation

Crowdsourced software testing (short for crowdtesting) is a special type of crowdsourcing. It requires that crowdworkers master appropriate skill-sets and commit significant effort for completing a task. Abundant uncertainty may arise during a crowdtesting process due to imperfect information between the task requester and crowdworkers. For example, a worker frequently chooses tasks in an ad hoc manner in crowdtesting context, and an inappropriate task selection may lead to the worker's failing to detect any bugs, and significant testing effort unpaid and wasted. Recent studies have explored methods for supporting task requesters to make informed decisions on task pricing, worker recommendation, and so on. Unfortunately, very few study offers decision making support from the crowdworkers’ perspectives. We motivate this study through a pilot study, revealing the large portion (74 percent) of unpaid crowdworkers’ effort due to the inappropriate task choice. Drawn from our previous work on context-aware crowdworker recommendations, we advocate a more effective alternative to manual task selection would be to provide contextualized and personalized task recommendation considering the diverse distribution of worker preference and expertise, with objectives to increase their winning chances and to potentially reduce the frequency of unpaid crowd work. This paper proposes a context-aware personalized task recommendation approach <italic xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">PTRec</i> , consisting of a testing context model and a learning-based task recommendation model to aid dynamic worker decision in selecting crowdtesting tasks. The testing context model is constructed in two perspectives, i.e., process context and resource context, to capture the in-process progress-oriented information and crowdworkers’ characteristics respectively. Built on top of this context model, the learning-based task recommendation model extracts 60 features automatically, and employs random forest learner to generate dynamic and personalized task recommendation which matches workers’ expertise and interest. The evaluation is conducted on 636 crowdtesting tasks involving 2,404 crowdworkers from one of the largest crowdtesting platforms, and results show our approach can achieve an average precision of 82 percent, average recall of 84 percent, and save an estimated average of 81 percent effort originally spent on exploring, significantly outperforming four commonly-used and state-of-the-art baselines. This indicates its potential in recommending proper tasks to workers so as to improve bug detection efficiency and increase their monetary earnings.