Bug Reports Research Articles

Characterizing and Detecting WebAssembly Runtime Bugs

WebAssembly (abbreviated WASM) has emerged as a promising language of the Web and also been used for a wide spectrum of software applications such as mobile applications and desktop applications. These applications, named WASM applications, commonly run in WASM runtimes. Bugs in WASM runtimes are frequently reported by developers and cause the crash of WASM applications. However, these bugs have not been well studied. To fill in the knowledge gap, we present a systematic study to characterize and detect bugs in WASM runtimes. We first harvest a dataset of 311 real-world bugs from hundreds of related posts on GitHub. Based on the collected high-quality bug reports, we distill 31 bug categories of WASM runtimes and summarize their common fix strategies. Furthermore, we develop a pattern-based bug detection framework to automatically detect bugs in WASM runtimes. We apply the detection framework to seven popular WASM runtimes and successfully uncover 60 bugs that have never been reported previously, among which 13 have been confirmed and 9 have been fixed by runtime developers.

Novel method of building train and test sets for evaluation of machine learning models related to software bugs assignment

Nowadays many tools are in use in processes related to handling bug reports, feature requests, supporting questions or similar related issues which should be handled during software development or maintenance. Part of them use machine learning techniques. In introduction is presented a review of fundamental methods used for evaluation of machine learning models. This paper points out weak points of currently used metrics for evaluation in specific context of the cases related to software development especially bug reports. The disadvantages of state of the art are related to disregarding time dependencies which are important to be applied for creating train and test sets as they may have impact on results. Extensive research of the art has been conducted and has not been found any article with the use of time dependencies for evaluation of machine learning models in the context of works related to software development applications like machine learning solutions to supporting bug tracking systems. This paper introduces a novel solution which is devoid of these drawbacks. Experimental research showed the effectiveness of the introduced method and significantly different results obtained compared to the state-of-the-art methods.

Retracted: An Automated Approach for the Prediction of the Severity Level of Bug Reports Using GPT-2

Retracted: An Automated Approach for the Prediction of the Severity Level of Bug Reports Using GPT-2

Duplicate Bug Report detection using Named Entity Recognition

Software bugs pose significant challenges in management. The Bug Tracking System (BTS) serves as a standard platform to chronicle, oversee, and manage bugs throughout software development and maintenance. While BTS aggregates numerous bug reports for tracking purposes, identical bugs often get reported by various individuals. This redundancy leads to excessive duplicate reports, straining manual inspection efforts, risking repeated bug assignment tasks, and diminishing the efficiency of bug resolution. Notably, many contemporary DBR detection techniques tend to overlook the structured data abundant in descriptive information about bug report behaviors. To mitigate this oversight, this study introduces a groundbreaking method named CorNER. This technique enhances DBR detection precision by converting unstructured textual content into structured data via named entity recognition (NER). Specifically, CorNER employs Random Forest with context (RNER) to annotate entities in the title and description sections of bug reports and subsequently harnesses Text Convolutional Neural Networks (TextCNN) for feature extraction. Empirical evidence indicates a commendable improvement in CorNER’s F1-Score by 6.24% and 4.96% on average, surpassing the benchmarks of two prevalent DBR detection methods across five datasets.

AttSum: A Deep Attention-Based Summarization Model for Bug Report Title Generation

Concise and precise bug report titles help software developers to capture the highlights of the bug report quickly. Unfortunately, it is common that bug reporters do not create high-quality bug report titles. Recent long short-term memory (LSTM)-based sequence-to-sequence models such as iTAPE were proposed to generate bug report titles automatically, but the text representation method and LSTM employed in such model are difficult to capture the accurate semantic information and draw the global dependencies among tokens effectively. This article proposes a deep attention-based summarization model (i.e., <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">AttSum</small> ) to generate high-quality bug report titles. Specifically, the <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">AttSum</small> model employs the encoder.decoder framework, which utilizes the robustly optimized bidirectional-encoder-representations-from-transformers approach to encode the bug report bodies to capture contextual semantic information better, the stacked transformer decoder to automatically generate titles, and the copy mechanism to handle the rare token problem. To validate the effectiveness of <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">AttSum</small> , we conduct automatic and manual evaluations on 333563 “ <inline-formula xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"><tex-math notation="LaTeX">$&lt; body, title&gt;$</tex-math></inline-formula> ” pairs of bug reports and perform a practical analysis of its ability to improve low-quality titles. The result shows that <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">AttSum</small> is superior to the state-of-the-art baselines by a substantial margin both on automatic evaluation metrics (e.g., by 3.4%–58.8% and 7.7%–42.3% in terms of recall-oriented understudy for gisting evaluation in F1 and bilingual evaluation understudy, separately) and three human-set modalities (e.g., by 1.9%–57.5%). Moreover, we analyze the impact of the training data size on <sc xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">AttSum</small> and the results imply that our approach is robust enough to generate much better titles.

Multi-View Feature Fusion Model for Software Bug Repair Pattern Prediction

Many search-based Automatic Program Repair (APR) techniques employ a set of repair patterns to generate candidate patches. Regarding repair pattern selection, existing search-based APR techniques either randomly select a repair pattern from the repair pattern set to apply or prioritize all repair patterns based on the bug's context information. In this paper, we introduce PatternNet, a multi-view feature fusion model capable of predicting the repair pattern for a reported software bug. To accomplish this task, PatternNet first extracts multi-view features from the pair of buggy code and bug report using different models. Specifically, a transformer-based model (i.e., UniXcoder) is utilized to obtain the bimodal feature representation of the buggy code and bug report. Additionally, an Abstract Syntax Tree (AST)-based neural model (i.e., ASTNN) is employed to learn the feature representation of the buggy code. Second, a co-attention mechanism is adopted to capture the dependencies between the statement trees in the AST of the buggy code and the textual tokens of the reported bug, resulting in co-attentive features between statement trees and reported bug's textual tokens. Finally, these multi-view features are combined into a unified representation using a feature fusion network. We quantitatively demonstrate the effectiveness of PatternNet and the feature fusion network for predicting software bug repair patterns.

A data-driven approach for understanding invalid bug reports: An industrial case study

A data-driven approach for understanding invalid bug reports: An industrial case study

버그 심각도 예측에 버그 리포트의 다중 토픽 분석 및 CNN 알고리즘 적용

버그 심각도 예측에 버그 리포트의 다중 토픽 분석 및 CNN 알고리즘 적용

Empirical Study And Analysis Of Software Bug Localization Approaches Using Deep Learning

Bugs comes in high volume and documenting them properly in a specific format in the bug reports is difficult. Locating these bugs in correctly identified buggy files is a challenging task which needs to be automated. Numerous tools and techniques are proposed by researchers to support developers and testers to detect buggy files and automate the process of bug localization with greater accuracy. Recent research deal with the automation of Bug Localization process by using different techniques and tools. In this paper, we presented a comprehensive review of few papers in the domain of bug localization. This review helps us to know the benchmark datasets that are used in this process of bug localization, the major techniques that are worked upon, the findings and evaluation criteria and the architecture of various models and frameworks developed by researchers to automate the task of bug localization. This paper works on IR and DNN approaches and attempted to improve the previous results of DNNLOC successfully. The optimized version of the model improved the accuracy from 0.815 to 0.969 for enhanced rvsm and 0.83 to 0.971 for enhanced dnn. It is apparent that information retrieval approach and deep learning approach complement together in the domain of bug localization.

Exploring the Integration of Machine Learning Models in Programming Languages on GitHub: Impact on Compatibility to Address Them

GitHub repositories are often used for collaborative development, allowing multiple developers to work on the same codebase and contribute their changes. Each repository is typically associated with a specific project, and it can contain everything from code files to documentation, bug reports, and feature requests. Depending on the context, it can contain files, directories, other resources related to a project, and it is often associated with a particular programming language. By default, GitHub automatically detects the primary programming language used in a repository based on the file extensions and content within the repository. However, this detection is not true all the time; there are some potential issues to consider. One of these problems is that the detected language may not accurately reflect the actual programming languages used in the project, especially if the project utilizes multiple programming languages or has undergone language migrations. In this study, we apply an alternative technology to resolve problems with classifying the programming language of a GitHub repository by analysing file extensions and identifying all programming languages used in the project. We also determine the appropriate primary programming language for the repository. This paper investigates how this technology can address the issues surrounding GitHub’s automatic detection of a repository’s primary programming language and how it can provide information on all the programming languages used in a project.

Software bug severity and priority prediction using SMOTE and intuitionistic fuzzy similarity measure

A software bug tracking system receives several bug reports in a rapid manner during the maintenance of software. In order to fix the important and urgent bugs, the triager has to assign severity and priority to individual bugs on time. However, there are a lot of uncertainties in the bug reports due to bias, noise, and abnormal data. At the same time, the presence of common terms in multiple severity and priority classes creates confusion in the mind of the triager. Furthermore, machine learning and deep learning approaches generally belong to discriminative learning with a clear-cut outcome. Instances of software bug reports are textual in nature. As a result, these are fuzzy and cannot be classified with a clear-cut outcome. To overcome the above problems, in this paper, an Intuitionistic Fuzzy Similarity Measure (IFSM) based severity prediction technique (IFSMSP) and priority prediction technique (IFSMPP) are proposed for predicting the severity and priority of a new bug by using already labeled bugs. Initially, the Synthetic Minority Oversampling Technique (SMOTE) is used to balance the severity and priority label of software bugs. Then the severity-term dictionary or priority-term dictionary is created by extracting the most frequent terms from the bug summary using text mining and Natural Language Processing (NLP). Then the data is represented using an intuitionistic fuzzy set (IFS) by calculating the membership, non-membership, and hesitancy degrees. Then 15 different IFSM techniques are investigated for predicting the severity and priority of software bugs. Experiments are carried out on large software bug repositories (Eclipse, Mozilla, Apache, and NetBeans) with a 10-fold cross-validation technique. IFSMSP outperformed other state-of-the-art priority models by obtaining an accuracy of 92.3%, 90.6%, 91.9%, and 91.2%, and IFSMPP outperformed other state-of-the-art models by obtaining an accuracy of 93.2%, 91.9%, 92.7%, and 92.3% on the Eclipse, Mozilla, Apache, and NetBeans software bug repositories, respectively.

BERT based severity prediction of bug reports for the maintenance of mobile applications

Mobile application maintenance is crucial to ensuring the accurate operation and continuous improvement of mobile applications (mobile apps). To effectively address issues and enhance the user experience, developers utilize issue-tracking systems that gather bug reports to refine mobile apps. Users can submit bugs through these systems, allowing them to determine the severity of each reported issue. The severity level plays a pivotal role in prioritizing bug resolution, enabling developers to address critical bugs promptly. Nonetheless, manually assessing the severity of each issue can be laborious and prone to errors. To overcome this challenge, this paper presents Bidirectional Encoder Representations from Transformers (BERT) based severity prediction of bug reports (called BERT-SBR) that leverages a deep neural network for automatic bug severity classification for mobile app maintenance. We collect the publicly available mobile apps bug reports dataset from the Hugging Face. BERT-SBR first computes the sentiment of reporters of bug reports and preprocesses them by leveraging BertTokenizer input formatting techniques. Next, it passes the formatted text and computed sentiment of each bug report to generate word embeddings. Then, it introduces a fine-tuned BERT classifier for bug report severity prediction. After that, it passes the generated word embeddings to the fine-tuned BERT classifier for training and testing. Finally, the proposed classifier’s performance is evaluated. The BERT-SBR assessment results confirm that the fine-tuned BERT classifies bug reports significantly more effectively than other deep learning classifiers. On average, BERT-SBR achieves a remarkable improvement of 40.43%, 67.78%, 40.71%, and 58.14% in the accuracy, precision, recall, and f-measure. This indicates its superiority in accurately predicting the severity of bug reports for mobile application maintenance.

App store mining for feature extraction: analyzing user reviews

A recent study shows that the most commonly used app stores, iOS app store and Android's play store had up to 2 million apps from where users can explore, purchase, share, download and install applications on a single click. More and more apps are being added daily which makes the app stores a large software repository. An enormous amount of data is provided by the end users in the form of user reviews. This data can provide valuable insights for acquiring requirements. User reviews include plenty of information as they contain information about faulty features (Bug reports), ideas for new features and improvements (feature requests), or user experience that can help app developers and vendors to achieve software enhancement and evolution tasks. As feature requests are the ones that are most helpful for the purpose of eliciting new requirements, the work is done on feature requests out of the 3 categories mentioned above. This study is conducted to provide a general approach that extracts feature request from user reviews. The proposed approach has five main building blocks, namely, (i) Extraction of Feature Requests, (ii) Feature Extraction from Feature Requests, (iii) topic modelling, (iv) sentiment analysis and (v) Classification into Functional Requirements (FR) and Non-Functional Requirements (NFR). Firstly, it finds the feature requests out of the reviews, then perform extraction of features from feature requests, then further work on grouping the features into topics, next apply sentiment analysis to mine the user opinions on the extracted topic and finally group them into Functional and Non-Functional requirements. This article provides the app developers a more user-centred definition of requirements and improvements. At the topic modelling phase, the results received the highest coherence score, 0.70, with k=22 topics. Sentiment analysis is used to classify feature request, with an accuracy of 80.20%, precision of 84.25%, and recall of 80.42%. With an accuracy of 84.4%, requirements are classified quite successfully as well.

BL-GAN: Semi-Supervised Bug Localization via Generative Adversarial Network

Various automated bug localization technologies have recently emerged that require adequate bug-fix records available to train a predictive model. However, many projects in practice might not provide these necessities, especially for new projects in the first release, due to the expensive human effort for constructing a large amount of bug-fix records. Aiming to capture the potential relevance distribution between the bug report and code file from a limited number of available bug-fix records, we present the first semi-supervised bug localization model named BL-GAN in this paper. For this purpose, the promising Generative Adversarial Network is introduced in BL-GAN, in which synthetic bug-fix records close to the real ones are constructed by searching the project directory tree to generate file paths instead of traversing the contents of all code files. For processing bug reports, the proposed BL-GAN adopts an attention-based Transformer architecture to capture semantic and sequence information. In order to capture the proprietary structural information in code files, BL-GAN incorporates a novel multilayer Graph Convolutional Network to process the source code in a graphical view. Extensive experiments on large-scale real-world datasets reveal that our model BL-GAN significantly outperforms the state-of-the-art on all evaluation measures.

COPS: An improved information retrieval-based bug localization technique using context-aware program simplification

Information Retrieval Based Bug Localization (IRBL) techniques are well suited for large-scale software debugging with fewer external dependencies and lower execution costs. However, existing IRBL techniques have several challenges, including localization granularity and applicability. First, existing IRBL techniques have not yet achieved statement-level bug localization. Second, almost all studies are limited to Java-based projects, while their effectiveness for other popular programming languages (e.g., Python) is unknown. The reason for these deficiencies is that existing IRBL techniques mainly rely on conventional NLP techniques to analyze the bug reports and have not yet fully utilized the stack traces attached to the bug reports. To improve the IRBL technique, we propose a context-aware program simplification technique – COPS – that can localize defective statements in suspicious files by analyzing the stack traces in bug reports, enabling statement-level bug localization for Python-based projects. Our experiment is based on 948 bug reports, and the results show that COPS can effectively localize buggy statements. First, compared to the original stack traces, Top@10 is improved by 102.6%, MAP@10 by 56.2%, and MRR@10 by 95.6%. We found that actual buggy code entities are more likely to appear in the first five frames of the stack trace. Second, COPS can achieve equally good localization performance compared to state-of-the-art statement-level bug localization techniques and achieve 92% buggy statement coverage with a full-scope search. Finally, experiments found that the stack trace’s first two-thirds of information is more conducive to localizing buggy statements.

BugRadar: Bug localization by knowledge graph link prediction

: Information Retrieval-based Bug Localization (IRBL) aims to design automatic systems that find buggy files according to bug reports, which can reduce the time consumption to fix bugs for programmers. There has been extensive research on IRBL techniques in recent years. However, these methods cannot make full use of the structure information in bug reports and source files. : In this paper, we propose a novel scheme BugRadar. It combines text features and structure features from bug reports and source files for bug localization. Especially, BugRadar leverages a knowledge graph to make use of structure features. : We originally propose a knowledge graph named TriGraph based on structure features and apply hyperbolic attention embedding to get the link prediction scores. For text features, we propose Partial Text Similarity which improves traditional Text Similarity and Method Level Text Similarity. We also propose Word Collaborative Filtering Score which leverages historical bug reports with more attention on important terms. Finally, we calculate the final suspicious scores based on the structure features, text features, and fixing time information from bug fixing history with a neural network. : We apply our scheme to four projects (Tomcat, SWT, JDT, and Birt) in a popular dataset and get approving results. BugRadar gets better results than other state-of-the-art methods on three projects out of the four. It achieves a relative improvement of 8.8% in SWT and 9.8% in JDT for Mean Average Precision compared to the previous best scheme KGBugLocator and 11.4% in Birt compared to Adaptive Regression. : BugRadar can achieve approving performance on large-scale projects with enough historical bug reports. It verifies that knowledge graphs are capable of representing the structure features for bug localization. The novel Partial Text Similarity and Word Collaborative Filtering Score are both effective improvements for using text features.

Photographing the game glitch: Between ghost photography and immaterial labour

This article explores the properties of glitch within practices of in-game photography. It argues that capturing the breaking of game textures and graphics reveals the process of creation of photorealism and the remediation of traditional photography within digital and playable spaces. On the other hand, it proposes that screenshotting game glitches acts as an involuntary bug report and part of an economy of ever-optimizing networked images.

Bug report priority prediction using social and technical features

SummarySoftware stakeholders report bugs in issue tracking system (ITS) with manually labeled priorities. However, the lack of knowledge and standard for prioritization may cause stakeholders to mislabel the priorities. In response, priority predictors are actively developed to support them. Prior studies trained machine learners based on textual similarity, categorical, and numeric technical features of bug reports. Most models were validated by time‐insensitive approaches, and they were producing suboptimal results for practical usage. While they ignored the social aspects of ITS, the technical aspects were also limited in surface features of bug reports. To better model the bug report, we extract their topic and most similar code structures. Since ITS bridges users and developers as the main contributors, we also integrate their experience, sentiment, and socio‐technical features to construct a new dataset. Then, we perform two‐classed and multiclassed bug priority prediction based on the dataset. We also introduce adversarial training using generated training data with random word swap and random word deletion. We validate our model in within‐project, cross‐project, and time‐wise scenarios, and it outperforms the two baselines by up to 15% in area under curve‐receiver operating characteristics (AUC‐ROC) and 19% in Matthews correlation coefficient (MCC). We reveal involving contributor (i.e., assignee and reporter) features such as sentiment that could boost prediction performance. Finally, we test statistically the mean and distribution of the features that reflect the differences in social and technical aspects (e.g., quality of communication and resource distribution) between high and low priority reports. In conclusion, we suggest that researchers should consider both social and technical aspects of ITS in bug report priority prediction and introduce adversarial training to boost model performance.

Application Monitoring for bug reproduction in web-based applications

Web applications are often built as Single Page Applications (SPA), for example applications offered by Google, Facebook, Twitter or Netflix. Users interact with SPAs through a single HTML page that is dynamically rewritten with new data from the web server (instead of a web browser that loads entire new HTML pages). Just like with any type of software system, debugging is a common activity during the development and maintenance of SPAs. In order to fix bugs observed during runtime, developers often try to reproduce the bug first to better understand it. However, research has shown that reproducing bugs is not always possible. In this paper we (i) develop a technique for Application Monitoring (AM) to collect data to support bug reproduction; and (ii) apply the monitoring technique in a SPA test bed as well as a real-world SPA application to show its feasibility. As part of our research we developed an initial version of the AM technique and implemented it in a prototype. Our evaluation using this prototype showed that it not only improves the efficiency of the bug reproduction process but also reduces information gaps caused by incomplete bug reports submitted by users. Additionally, compared to the information provided by users, data provided by AM is more accurate and detailed and covers a wider range of data. Future work includes deploying the AM framework in more SPAs and investigating how AM can be integrated into software developer workflows.

RoseMatcher: Identifying the impact of user reviews on app updates

The release planning of mobile apps has become an area of active research, with most studies centering on app analysis through release notes in the Apple App Store and tracking user reviews via issue trackers. However, the correlation between these release notes and user reviews in App Store remains understudied. In this paper, we introduce RoseMatcher, a novel automatic approach to match relevant user reviews with app release notes, and identify matched pairs with high confidence. We collected 944 release notes and 1,046,862 user reviews from 5 mobile apps in the Apple App Store as research data to evaluate the effectiveness and accuracy of RoseMatcher, and conducted deep content analysis on matched pairs. Our evaluation shows that RoseMatcher can reach a hit ratio of 0.718 for identifying relevant matched pairs, and with the manual labeling and content analysis of 984 relevant pairs, we identify 8 roles that user reviews play in app updates according to the relationship between release notes and user reviews in the relevant matched pairs. Our findings indicate that both app development teams and users pay close attention to release notes and user reviews, with release notes typically addressing feature requests, bug reports, and complaints, and user reviews offering positive, negative, and constructive feedback. Overall, the study highlights the importance of the communication between app development teams and users in the release planning of mobile apps, with relevant reviews tending to be posed within a short period before and after the release of release notes, with the average time interval between the post time of release notes and user reviews being approximately one year.