3,700 research outputs found
Rediscovery Datasets: Connecting Duplicate Reports
The same defect can be rediscovered by multiple clients, causing unplanned
outages and leading to reduced customer satisfaction. In the case of popular
open source software, high volume of defects is reported on a regular basis. A
large number of these reports are actually duplicates / rediscoveries of each
other. Researchers have analyzed the factors related to the content of
duplicate defect reports in the past. However, some of the other potentially
important factors, such as the inter-relationships among duplicate defect
reports, are not readily available in defect tracking systems such as Bugzilla.
This information may speed up bug fixing, enable efficient triaging, improve
customer profiles, etc.
In this paper, we present three defect rediscovery datasets mined from
Bugzilla. The datasets capture data for three groups of open source software
projects: Apache, Eclipse, and KDE. The datasets contain information about
approximately 914 thousands of defect reports over a period of 18 years
(1999-2017) to capture the inter-relationships among duplicate defects. We
believe that sharing these data with the community will help researchers and
practitioners to better understand the nature of defect rediscovery and enhance
the analysis of defect reports
Recommended from our members
Leveraging the Power of Crowds: Automated Test Report Processing for The Maintenance of Mobile Applications
Crowdsourcing is an emerging distributed problem-solving model combining human and machine computation. It collects intelligence and knowledge from a large and diverse workforce to complete complex tasks. In the software engineering domain, crowdsourced techniques have been adopted to facilitate various tasks, such as design, testing, debugging, development, and so on. Specifically, in crowdsourced testing, crowdsourced workers are given testing tasks to perform and submit their feedback in the form of test reports. One of the key advantages of crowdsourced testing is that it is capable of providing engineers software engineers with domain knowledge and feedback from a large number of real users. Based on diverse software and hardware settings of these users, engineers can bugs that are not caught by traditional quality assurance techniques. Such benefits are particularly ideal for mobile application testing, which needs rapid development-and-deployment iterations and support diverse execution environments. However, crowdsourced testing naturally generates an overwhelming number of crowdsourced test reports, and inspecting such a large number of reports becomes a time-consuming yet inevitable task. This dissertation presents a series of techniques, tools and experiments to assist in crowdsourced report processing. These techniques are designed for improving this task in multiple aspects: 1. prioritizing crowdsourced report to assist engineers in finding as many unique bugs as possible, and as quickly as possible; 2. grouping crowdsourced report to assist engineers in identifying the representative ones in a short time; 3. summarizing the duplicate reports to provide engineers with a concise and accurate understanding of a group of reports; In the first step, I present a text-analysis-based technique to prioritize test reports for manual inspection. This technique leverages two key strategies: (1) a diversity strategy to help developers inspect a wide variety of test reports and to avoid duplicates and wasted effort on falsely classified faulty behavior, and (2) a risk-assessment strategy to help developers identify test reports that may be more likely to be fault-revealing based on past observations.Together, these two strategies form our technique to prioritize test reports in crowdsourced testing. Moreover, in the mobile testing domain, test reports often consist of more screenshots and shorter descriptive text, and thus text-analysis-based techniques may be ineffective or inapplicable. The shortage and ambiguity of natural-language text information and the well-defined screenshots of activity views within mobile applications motivate me to propose a novel technique based on using image understanding for multi-objective test-report prioritization. This technique employs the Spatial Pyramid Matching (SPM) technique to measure the similarity of the screenshots, and apply the natural-language processing technique to measure the distance between the text of test reports. Next, I design and implement CTRAS: a novel approach to leveraging duplicates to enrich the content of bug descriptions and improve the efficiency of inspecting these reports. CTRAS is capable of automatically aggregating duplicates based on both textual information and screenshots, and further summarizes the duplicate test reports into a comprehensive and comprehensible report.I validate all of these techniques on industrial data by collaborating with several companies. The results show my techniques can improve both the efficiency and effectiveness of crowdsourced test report processing. Also, I suggest settings for different usage scenarios and discuss future research directions
Duplicate Defect Detection
Discovering and fixing faults is an unavoidable process in Software Engineering. It is always a good practice to document and organize fault reports. This facilitates the effectiveness of development and maintenance process. Bug Tracking Repositories, such as Bugzilla, are designed to provide fault reporting facilities for developers, testers and users of the system. Allowing anyone to contribute finding and reporting faults has an immediate impact on software quality. However, this benefit comes with one side-effect. Users often file reports that describe the same fault. This increases the triaging time spent by the maintainers. At the same time, important information required to fix the fault is likely to be distributed across different reports.;The objective of this thesis is twofold. First, we want to understand the dynamics of bug report filing for a large, long duration open source project, Firefox. Second, we present a new approach that can reduce the number of duplicate reports. The novel element in the proposed approach is the ability to concentrate the search for duplicates on specific portions of the bug repository. This improves the performance of Information Retrieval techniques and classification runtime of our algorithm. Our system can be deployed as a search tool to help reporters query the repository or it can be adopted to help maintainers detect duplicate reports. In both cases the performance is satisfactory. When tested as a search tool our system is able to detect up to 53% of duplicate reports. The approach adapted for maintainers has a maximum recall rate of 59%
Large Language Models for Software Engineering: A Systematic Literature Review
Large Language Models (LLMs) have significantly impacted numerous domains,
notably including Software Engineering (SE). Nevertheless, a well-rounded
understanding of the application, effects, and possible limitations of LLMs
within SE is still in its early stages. To bridge this gap, our systematic
literature review takes a deep dive into the intersection of LLMs and SE, with
a particular focus on understanding how LLMs can be exploited in SE to optimize
processes and outcomes. Through a comprehensive review approach, we collect and
analyze a total of 229 research papers from 2017 to 2023 to answer four key
research questions (RQs). In RQ1, we categorize and provide a comparative
analysis of different LLMs that have been employed in SE tasks, laying out
their distinctive features and uses. For RQ2, we detail the methods involved in
data collection, preprocessing, and application in this realm, shedding light
on the critical role of robust, well-curated datasets for successful LLM
implementation. RQ3 allows us to examine the specific SE tasks where LLMs have
shown remarkable success, illuminating their practical contributions to the
field. Finally, RQ4 investigates the strategies employed to optimize and
evaluate the performance of LLMs in SE, as well as the common techniques
related to prompt optimization. Armed with insights drawn from addressing the
aforementioned RQs, we sketch a picture of the current state-of-the-art,
pinpointing trends, identifying gaps in existing research, and flagging
promising areas for future study
Bug Fix Time Optimization Using Matrix Factorization and Iterative Gale-Shaply Algorithms
Bug triage is an essential task in software maintenance phase. It assigns
developers (fixers) to bug reports to fix them. This process is performed
manually by a triager, who analyzes developers profiles and submitted bug
reports to make suitable assignments. Bug triaging process is time consuming
thus automating this process is essential to improve the quality of software.
Previous work addressed triaging problem either as an information retrieval or
classification problem. This paper tackles this problem as a resource
allocation problem, that aims at the best assignments of developers to bug
reports, that reduces the total fixing time of the newly submitted bug reports,
in addition to the even distribution of bug reports over developers. In this
paper, a combination of matrix factorization and Gale Shapely algorithm,
supported by the differential evolution is firstly introduced to optimize the
total fix time and normalize developers work load. Matrix factorization is used
to establish a recommendation system for Gale-Shapley to make assignment
decisions. Differential evolution provides the best set of weights to build
developers score profiles. The proposed approach is assessed over three
repositories, Linux, Apache and Eclipse. Experimental results show that the
proposed approach reduces the bug fixing time, in comparison to the manual
triage, by 80.67%, 23.61% and 60.22% over Linux, Eclipse and Apache
respectively. Moreover, the workload for the developers is uniform.Comment: 14 page, 7 figures, 8 tables, 10 equation
- …