Bug Tracking Systems Research Articles

Blockchain Based Analytical Bug Tracking in Software Engineering

This article examines a blockchain-based bug tracking system in detail, focusing on its four main components: the Blockchain Platform, the Consensus Mechanism (also known as Proof of Work, PoW), the Data Structure, and Smart Contracts. To improve the efficiency, security, and transparency of bug tracking in software development, we use mathematical models to dissect the operational framework and functionalities that underpin this cutting-edge system. The Blockchain Platform is the foundational layer. It stores data in multiple locations, cannot be changed, and provides a secure environment for fixing software bugs. We use mathematical abstractions to demonstrate how the blockchain is put together, emphasizing the importance of cryptographic hashes in maintaining data integrity and connecting blocks. People pay close attention to the Consensus Mechanism, particularly Proof of Work (PoW), because it is so important for verifying transactions and maintaining the blockchain's integrity. Using a mathematical model, we demonstrate how Proof of Work (PoW) prevents bad behavior while keeping the network safe and democratic by requiring work to be done on a computer to add blocks. The Data Structure module is examined using a model that depicts how bug reports are stored and found on the blockchain. This model demonstrates the efficiency of storing bug reports as transactions, which allows for quick access and unchangeable record-keeping. People associate smart contracts with self-running programs that manage permissions, automate workflows, and provide incentives for reporting bugs. Mathematical models are used to demonstrate how these contracts' conditions and actions are documented, emphasizing their importance in automating tasks and improving system reliability. This article uses mathematical modeling to provide a clear and structured understanding of a blockchain-based bug tracking system and demonstrate how it could change the way bugs are tracked by leveraging blockchain technology's strengths.

Predicting Software Defect Complexity and Accuracy using Bug Tracking and Clustering

Many open sources, free and commercial bug tracking tools have been developed and are currently under development. There are number of issues are related to software projects are daily increasing and the developers are started to use bug tracking systems in that order to manages the bug reports. The industry needs that the criteria to select the best system tool among the available set of system tools which will helps to fix and track the progressive report of bug fixes. While, collection of useful information from the large and not organized set of these reports is still difficult problem because there are various bug tracking systems are provide the data via many resources like web interfaces. We try to present these comprehensive classification criteria to manage the reviews for available tools and propose a new modified tool for the bug tracking and reporting system. It also helps in reporting the bugs which are founded by that process, assigning the bug to the developer for monitoring and fixing the progress of bug fixing by various graphical/charting facility and status updates. It also providing the reliability of bug prediction and tries to find the bugs for complexity measurements, and allows to distributing.

Enhancing bug allocation in software development: a multi-criteria approach using fuzzy logic and evolutionary algorithms.

A bug tracking system (BTS) is a comprehensive data source for data-driven decision-making. Its various bug attributes can identify a BTS with ease. It results in unlabeled, fuzzy, and noisy bug reporting because some of these parameters, including severity and priority, are subjective and are instead chosen by the user's or developer's intuition rather than by adhering to a formal framework. This article proposes a hybrid, multi-criteria fuzzy-based, and multi-objective evolutionary algorithm to automate the bug management approach. The proposed approach, in a novel way, addresses the trade-offs of supporting multi-criteria decision-making to (a) gather decisive and explicit knowledge about bug reports, the developer's current workload and bug priority, (b) build metrics for computing the developer's capability score using expertise, performance, and availability (c) build metrics for relative bug importance score. Results of the experiment on five open-source projects (Mozilla, Eclipse, Net Beans, Jira, and Free desktop) demonstrate that with the proposed approach, roughly 20% of improvement can be achieved over existing approaches with the harmonic mean of precision, recall, f-measure, and accuracy of 92.05%, 89.04%, 90.05%, and 91.25%, respectively. The maximization of the throughput of the bug can be achieved effectively with the lowest cost when the number of developers or the number of bugs changes. The proposed solution addresses the following three goals: (i) improve triage accuracy for bug reports, (ii) differentiate between active and inactive developers, and (iii) identify the availability of developers according to their current workload.

Bug Tracking System

For many years, bug-tracking mechanisms have been employed only in some of the large software development houses. Most of the others never bothered with bug tracking at all, and instead simply relied on shared lists and email to monitor the status of defects. This procedure is error-prone and tends to cause those bugs judged least significant by developers to be dropped or ignored. Bug Tracking System is an ideal solution to track the bugs of a product, solution or an application. Bug Tracking System allows individuals or groups of developers to keep track of outstanding bugs in their product effectively. This can also be called the Defect Tracking System. The Bug Tracking System can dramatically increase the productivity and accountability of individual employees by providing a documented workflow and positive feedback for good performance. Moreover, the project explores the use of machine learning for automated root cause analysis, assisting developers in identifying underlying issues contributing to bug occurrences. Recommendation systems are also developed to suggest potential fixes or solutions for reported bugs based on past incidents and code repositories, aiding developers in efficient bug resolution. Through these ML-driven functionalities, the proposed bug tracking software aims to revolutionize the bug management process, enabling faster bug detection, prioritization, and resolution, thereby enhancing software quality, user satisfaction, and overall development productivity. Key Words: Bug Tacking system, apps, users.

Mindfulness and Emotional Intelligence: A Study on Millennials on Hospitality

In software development, dependability and quality are critical. A Bug Tracking System (BTS) designed specifically for large-scale software projects is introduced in this significant project with the goal of streamlining bug tracking, reporting, detection, and resolution. The system provides secure authentication, a backend database that is reliable, and an easy-to-use web interface. Using cutting-edge web technologies, it offers critical features including automated notifications, progress tracking, severity assignment, and thorough bug reporting together with user-friendly interfaces for a range of user roles. Tools for data visualization help identify defect patterns and monitor projects. The project follows best practices recommended by the industry for requirements analysis, design, implementation, testing, and deployment, and it solicits ongoing input. The result is a thorough BTS that addresses defect management difficulties. Thorough testing and assessment in comparison to standards confirms its efficacy. This approach could have a big impact on software development, improving user satisfaction and quality. Furthermore, issues with bug tracking are covered, including distributed team communication, scalability, and automation balancing. Proposals for strategies to address these issues are grounded in scholarly research and professional opinions. This summary highlights the critical role that bug tracking systems play in contemporary software development, making it an invaluable tool for researchers, practitioners, and teams looking to improve bug tracking procedures and raise the caliber and effectiveness of the software development lifecycle. Keywords— Bug Tracking System, Software Development, Defect Management, Quality Assurance, Automation, Collaboration, Large-scale Projects.

A Method of Reliability Assessment Based on Trend Analysis for Open Source Software

Software reliability growth model (SRGM) is used as one of the reliability assessment methods to assess the software reliability. In SRGM, the degree of reliability growth may fluctuate greatly according to change in the internal state of the software. It is called the change point (CP). Several researchers proposed the SRGM considering CP. In the open source software (OSS), there are many projects that continue development even after the software is released. Therefore, major updates with breaking changes may occur in it. The major updates can be a factor that causes a CP because it greatly changes the internal state of the OSS. This paper focuses on the relationship between CP and software updates. We collect OSS fault data from a bug tracking system. Moreover, we examine the behavior of SRGM before and after software updates. Furthermore, we discuss the applicability of SRGM for CP in OSS. Also, we compare the proposed model based on CP with the model without CP. As a result, we have confirmed that the SRGM can evaluate the reliability in the environment with major updates. Moreover, the proposed method performs better than without considering CP model. Especially, the exponential model’s mean value function is the suitable method to assess the OSS reliability for the proposed method.

Neighborhood contrastive learning-based graph neural network for bug triaging

Researchers have been developing automatic bug triaging techniques by leveraging bug information sourced from bug tracking systems. Recent studies have modeled the bug-developer relationship as a graph, introducing graph neural networks for bug triaging. Despite achieving positive outcomes, these methods overlook issues related to data sparsity and fail to fully exploit implicit relationships within the graph. In addressing these challenges, we present the Neighborhood Contrastive Learning-based Graph Neural Network Bug Triaging framework, abbreviated as NCGBT. Our approach models the relationship between bugs and developers as a bipartite graph. We utilize a pre-trained language model to acquire the initial representation of bug nodes. Employing a basic graph neural network framework, we learn the representation of all nodes and leverage these representations to predict developers for a given bug. Our proposed strategy involves neighborhood contrastive learning applied to the basic graph neural network approach. We take into account the neighbors of nodes from both structural and semantic perspectives, utilizing them as contrastive objects. Extensive experiments conducted on three public datasets demonstrate the effectiveness of the NCGBT framework.

An Integrated Approach using Developer Profiles with Temporal Dynamics for Assignee Recommendation in Non-Reproducible Bugs

A vital component of the software framework is bug reports. Bug tracking systems are employed for handling and closing the reported bugs. Unfxed bugs hinder software reliability and also camoufage other bugs. Non-Reproducible bugs deteriorate the quality of bug fxation significantly. Many times non-reproducible bugs are reopened and they lead to fxation as well. This improves the overall bug handling process. The fxation of re-opened non-reproducible bugs requires selection of a prominent developer having enough expertise for resolving the issue. This paper presents a novel framework for triaging of non-reproducible bugs called TriageExpert-Recency. The proposed framework, TriageExpert-Recency takes developer’s expertise and time recency of usage of topic by developer into consideration while selecting an appropriate developer. The developer’s expertise corresponding to a topic is computed on the basis of number of times developer worked on a similar topic. The time recency of usage of topic by developer is computed using the dates of historical bugs handled by the developer. Bug reports are gathered from the Mozilla Firefox and SeaMonkey projects’ Bugzilla repositories for experimental review. Experimental results showed a hit ratio up to 68% for Top-5 developer list using TriageExpert-Recency framework for developer selection in Non-Reproducible bugs. he proposed approach achieved performance up to 70.18% for Mozilla Firefox and 74.8% for SeaMonkey projects respectively. Overall, it has been found that the proposed approach outperforms the existing techniques.

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.

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.

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.

A Method of OSS Reliability Assessment Based on Public Repository Analysis

Open Source Software (OSS) is developed by various developers. Moreover, OSS user is increasing all over the world. There are various methods to maintain the software. Large-scale OSS projects mainly use bug tracking system (BTS) for bug management. Recently, OSS project uses public software repository to publish software such as GitHub. Public software repository has a function to report software issue. In the past, several researchers have proposed reliability assessment method using BTS. In this research, we propose a reliability assessment method based on deep learning using software repository analysis.

A Survey on Bug Deduplication and Triage Methods from Multiple Points of View

To address the issue of insufficient testing caused by the continuous reduction of software development cycles, many organizations maintain bug repositories and bug tracking systems to ensure real-time updates of bugs. However, each day, a large number of bugs is discovered and sent to the repository, which imposes a heavy workload on bug fixers. Therefore, effective bug deduplication and triage are of great significance in software development. This paper provides a comprehensive investigation and survey of the recent developments in bug deduplication and triage. The study begins by outlining the roadmap of the existing literature, including the research trends, mathematical models, methods, and commonly used datasets in recent years. Subsequently, the paper summarizes the general process of the methods from two perspectives—runtime information-based and bug report-based perspectives—and provides a detailed overview of the methodologies employed in relevant works. Finally, this paper presents a detailed comparison of the experimental results of various works in terms of usage methods, datasets, accuracy, recall rate, and F1 score. Drawing on key findings, such as the need to improve the accuracy of runtime information collection and refine the description information in bug reports, we propose several potential future research directions in the field, such as stack trace enrichment and the combination of new NLP models.

Duplicate Bug Report Detection Using an Attention-Based Neural Language Model

<i>Context:</i> Users and developers use bug tracking systems to report errors that occur during the development and testing of software. The manual identification of duplicates is a tedious task especially with software that have large bug repositories. In this context, their automatic detection becomes a necessary task that can help prevent frequently fixing the same bug. <i>Objective:</i> In this article, we propose <i>BERT-MLP</i>, a novel pretrained language model using bidirectional encoder representations from ransformers (BERT) for duplicate bug report detection (DBRD) with the aim of improving the detection rate compared to existing works. <i>Method:</i> Our approach considers only unstructured data. These are fed into the BERT model in order to learn the contextual relationships between words. The output is fed into a multilayer perceptron (MLP) classifier, representing our base DBRD. <i>Results:</i> Our approach was evaluated on three projects: Mozilla Firefox, Eclipse Platform, and Thunderbird. It achieved an accuracy of 92.11, 94.08, and 89.03&#x0025;, respectively, for Mozilla, Eclipse, and Thunderbird. A comparison with a dual-channel convolutional neural network (DC-CNN) model and other pretrained models, including RoBERTa and Sentence-Bert has been conducted. Results showed that <i>BERT-MLP</i> outperformed, the second best performing models (DC-CNN and Sentence-BERT) by 12&#x0025; in accuracy for Eclipse and 9&#x0025; for both Mozilla and Thunderbird, respectively.

BugBuilder: An Automated Approach to Building Bug Repository

Bug-related research, e.g., fault localization, program repair, and software testing, relies heavily on high-quality and large-scale software bug repositories. The importance of such repositories is twofold. On one side, real-world bugs and their associated patches may inspire novel approaches for finding, locating, and repairing software bugs. On the other side, the real-world bugs and their patches are indispensable for rigorous and meaningful evaluation of approaches to software testing, fault localization, and program repair. To this end, a number of software bug repositories, e.g., iBUGS and Defects4J, have been constructed recently by mining version control systems and bug tracking systems. However, fully automated construction of bug repositories by simply taking bug-fixing commits from version control systems often results in inaccurate patches that contain many bug-irrelevant changes. Although we may request experts or developers to manually exclude the bug-irrelevant changes (as the authors of Defects4J did), such extensive human intervention makes it difficult to build large-scale bug repositories. To this end, in this paper, we propose an automatic approach, called BugBuilder, to construct bug repositories from version control systems. Different from existing approaches, it automatically extracts complete and concise bug-fixing patches and excludes bug-irrelevant changes. It first detects and excludes software refactorings involved in bug-fixing commits. BugBuilder then enumerates all subsets of the remaining part, and discards invalid subsets by compilation and software testing. If exactly a single subset survives the validation, this subset is taken as the complete and concise bug-fixing patch for the associated bug. In case multiple subsets survive, BugBuilder employs a sequence of heuristics to select the most likely one. Evaluation results on 809 real-world bug-fixing commits in Defects4J suggest that BugBuilder successfully extracted complete and concise bug-fixing patches from forty-three percent of the bug-fixing commits, and its precision (99%) was even higher than human experts. We also built a bug repository, called GrowingBugs, with the proposed approach. The resulting repository serves as evidence of the usefulness of the proposed approach, as well as a publicly available benchmark for bug-related research.

APPLICATION OF EXPLAINABLE ARTIFICIAL INTELLIGENCE IN SOFTWARE BUG CLASSIFICATION

Fault management is an expensive process and analyzing data manually requires a lot of resources. Modern software bug tracking systems may be armed with automated bug report assignment functionality that facilitates bug classification or bug assignment to proper development group. For supporting decision systems, it would be beneficial to introduce information related to explainability. The purpose of this work is to evaluate the use of explainable artificial intelligence (XAI) in processes related to software development and bug classification based on bug reports created by either software testers or software users. The research was conducted on two different datasets. The first one is related to classification of security vs non-security bug reports. It comes from a telecommunication company which develops software and hardware solutions for mobile operators. The second dataset contains a list of software bugs taken from an opensource project. In this dataset the task is to classify issues with one of following labels crash, memory, performance, and security. Studies on XAI-related algorithms show that there are no major differences in the results of the algorithms used when comparing them with others. Therefore, not only the users can obtain results with possible explanations or experts can verify model or its part before introducing into production, but also it does not provide degradation of accuracy. Studies showed that it could be put into practice, but it has not been done so far.

Bug Tracker: Comprehensive Bug Tracking and Modification System

It is important that information provided in bug reports is relevant and complete in order to help resolve bugs quickly. However, often such information trickles to developers after several iterations of communication between Developers and reporters. Poorly designed bug tracking systems are partly to blame for this exchange of information being stretched over time. Our paper addresses the concerns of bug tracking systems by proposing four broad directions for enhancements. As a proof-of-concept, we also demonstrate a prototype interactive bug tracking system that gathers relevant information from the user and identifies files that need to be fixed to resolve the bug.

S-DABT: Schedule and Dependency-aware Bug Triage in open-source bug tracking systems

Fixing bugs in a timely manner lowers various potential costs in software maintenance. However, manual bug fixing scheduling can be time-consuming, cumbersome, and error-prone. In this paper, we propose the Schedule and Dependency-aware Bug Triage (S-DABT), a bug triaging method that utilizes integer programming and machine learning techniques to assign bugs to suitable developers. Unlike prior works that largely focus on a single component of the bug reports, our approach takes into account the textual data, bug fixing costs, and bug dependencies. We further incorporate the schedule of developers in our formulation to have a more comprehensive model for this multifaceted problem. As a result, this complete formulation considers developers' schedules and the blocking effects of the bugs while covering the most significant aspects of the previously proposed methods. Our numerical study on four open-source software systems, namely, EclipseJDT, LibreOffice, GCC, and Mozilla, shows that taking into account the schedules of the developers decreases the average bug fixing times. We find that S-DABT leads to a high level of developer utilization through a fair distribution of the tasks among the developers and efficient use of the free spots in their schedules. Via the simulation of the issue tracking system, we also show how incorporating the schedule in the model formulation reduces the bug fixing time, improves the assignment accuracy, and utilizes the capability of each developer without much comprising in the model run times. We find that S-DABT decreases the complexity of the bug dependency graph by prioritizing blocking bugs and effectively reduces the infeasible assignment ratio due to bug dependencies. Consequently, we recommend considering developers' schedules while automating bug triage.

Automatic Bug Classification System to Improve the Software Organization Product Performance

Consistently, many bugs are raised, which are not completely settled, and countless designers are utilizing open sources or outsider assets, which prompts security issues. Bug-triage is the impending mechanized bug report framework to appoint individual security teams for a more than adequate pace of bug reports submitted from various IDEs inside the association (on-premises). We can lessen the time and cost of bug following and allocate it to the fitting group by foreseeing which division it has a place in within an association. In this paper, the authors are executing an automatic bug tracking system (ABTS) to allocate the group for the revealed bug involving the text examination for bug naming and characterization AI calculation for anticipating designer. Hybrid natural language processing and machine learning techniques are used for automatic bug identification to improve the performance of software organization products.

Identifying High-impact Bug Reports with Imbalance Distribution by Instance Fuzzy Entropy

Bug tracking systems, such as Bugzilla, contain bug reports collected from sources such as development teams, testing teams and end users. Developers often depend on bug reports to fix identified bugs. Frequently used bug reports are the so-called severe bug reports. Although severe bug reports can be manually detected within bug reports in bug tracking systems, they impose heavy burdens on management of bug tracking systems. Consequently, an automated mechanism to examine the severity of bug reports is desirable to augment productivity. Unfortunately, identifying the severity of bug reports from thousands of bug reports in a bug tracking system is not an easy feat, because of the problem of low-quality and imbalance distributions that could affect the performance of automated mechanisms. In this paper, we propose an approach, namely FER, to counter low-quality and imbalanced distributions of bug reports relative to their severity. First, FER approach gets high-quality bug reports based on instance fuzzy entropy. Then, FER approach weakens the imbalancedness degree of class distribution according to the high-quality bug reports to train classifiers to recognize the severity of bug reports. Several experiments are conducted on bug reports from three open source projects (Eclipse, Mozilla, GNOME) and they reveal that our approach is robust against the low-quality and imbalance distributions of bug reports, while identifying the severity of bug reports.