Statistical analysis of switching overvoltages and insulation coordination for a 500 kV transmission line (original) (raw)
Related papers
Once a novel bug report is received, developers generally have to be compelled to be compelled to breed the bug and perform code reviews to hunt out the cause, a way that will be tedious and time overwhelming. A tool for ranking all the provision files with relation to but in all probability they are to contain the rationale for the bug would modify developers to slender down their search and improve productivity. This paper introduces associate degree adaptive ranking approach that leverages project data through purposeful decomposition of computer code computer file, API descriptions of library parts, the bug-fixing history, the code modification history, and so the file dependency graph. Given a bug report, the ranking score of each offer file is computed as a weighted combination of associate degree array of choices, where the weights unit of measurement trained automatically on antecedently solved bug reports using a learning-to-rank technique. We've an inclination to worth the ranking system on six huge scale open offer Java comes, exploitation the before-fix version of the project for every bug report. The experimental results show that the learning-to-rank approach outperforms three recent progressive ways. S pecially, our technique makes correct recommendations at intervals the best ten stratified offer files for over seventy p.c of the bug reports at intervals the Eclipse Platform and Felis domesticus comes.
Learning to rank faulty source files for dependent bug reports
Big Data: Learning, Analytics, and Applications, 2019
With the rise of autonomous systems, the automation of faults detection and localization becomes critical to their reliability. An automated strategy that can provide a ranked list of faulty modules or files with respect to how likely they contain the root cause of the problem would help in the automation bug localization. Learning from the history if previously located bugs in general, and extracting the dependencies between these bugs in particular, helps in building models to accurately localize any potentially detected bugs. In this study, we propose a novel fault localization solution based on a learning-to-rank strategy, using the history of previously localized bugs and their dependencies as features, to rank files in terms of their likelihood of being a root cause of a bug. The evaluation of our approach has shown its efficiency in localizing dependent bugs.
2018
Bug localisation is a core program comprehension task in software maintenance: given the observation of a bug, where is it located in the source code files? Information retrieval (IR) approaches see a bug report as the query, and the source code files as the documents to be retrieved, ranked by relevance. Such approaches have the advantage of not requiring expensive static or dynamic analysis of the code. However, most of state-of-the-art IR approaches rely on project history, in particular previously fixed bugs and previous versions of the source code. We present a novel approach that directly scores each current file against the given report, thus not requiring past code and reports. The scoring is based on heuristics identified through manual inspection of a small set of bug reports. We compare our approach to five others, using their own five metrics on their own six open source projects. Out of 30 performance indicators, we improve 28. For example, on average we find one or mor...
A Dataset of High Impact Bugs: Manually-Classified Issue Reports
2015
The importance of supporting test and maintenance activities in software development has been increasing, since recent software systems have become large and complex. Although in the field of Mining Software Repositories (MSR) there are many promising approaches to predicting, localizing, and triaging bugs, most of them do not consider impacts of each bug on users and developers but rather treat all bugs with equal weighting, excepting a few studies on high impact bugs including security, performance, blocking, and so forth. To make MSR techniques more actionable and effective in practice, we need deeper understandings of high impact bugs. In this paper we introduced our dataset of high impact bugs which was created by manually reviewing four thousand issue reports in four open source projects (Ambari, Camel, Derby and Wicket).
Bug Report Summarization: An Evaluation of Ranking Techniques
Bug reports are regularly consulted software ar-tifacts, especially, because they contain valuable information for many change management tasks. Developers consult them whenever they need to know already reported problems or have to investigate previous bug solutions. This activity, however, consumes a substantial amount of time once bug reports content might achieve dozens of comments and thousands of sentences. One recommended and massively applied solution to prevent developers to read the entire bug report is to summarize the whole conversation in a few sentences. Summaries ideally give to developers an overview of the current status of the bug and the reasons, highlighting the result of each proposed solution, for which environments, which solutions are most appropriated, and the necessary information to reproduce the bug. This strategy intends to minimize the time a developer would spend in maintenance tasks. However, investigations demonstrate that summaries do not meet the expectations of developers and, in practice, they still read the entry line of discussion. To circumvent this drawback, we propose a summary based on comments, instead of the ones based on isolated sentences, as proposed by previous works. We argue that a ranking of the most relevant comments would enable developers to find more appropriate information. Empirical results corroborate with our arguments and show that summaries generated by traditional ranking algorithms are accurate with respect to developers expected information when compared to reference summaries created manually.
A novel and improved developer rank algorithm for bug assignment
International Journal of Intelligent Systems Technologies and Applications, 2020
Analytical studies on automatic bug triaging approach have the main objective to recommend appropriate developer for bug report with reduced bug tossing length, time and effort in bug resolution. In bug triaging process, if the first recommended developer cannot fix a bug, it is tossed to another developer and the tossing process is continued till the bug gets assigned and resolved. Existing approaches to the best of our knowledge have not considered developer's contributions and performance assessment metrics for bug triaging process. In this paper, we proposed a novel and improved two phase bug triager that involves a developer profile creation and assignment phases. In this, developer profile is built by using individual contributions (IC) and performance assessment (PA) metrics. Contribution and performance of a developer in prefixed bug reports are analysed to calculate a developer's weighted score. This score indicates the level of expertise to fix and resolve a newly reported bug. This approach is tested on two open source projects-Eclipse and Mozilla. Empirical results show that proposed approach has achieved a significantly higher F-score up to 90% for both projects and has effectively reduced bug tossing length up to 11.8% as compared to existing approaches.
Detect Related Bugs from Source Code Using Bug Information
Open source projects often maintain open bug repositories during development and maintenance, and the reporters often point out straightly or implicitly the reasons why bugs occur when they submit them. The comments about a bug are very valuable for developers to locate and fix the bug. Meanwhile, it is very common in large software for programmers to override or overload some methods according to the same logic. If one method causes a bug, it is obvious that other overridden or overloaded methods maybe cause related or similar bugs.
From Bugs to Decision Support - Leveraging Historical Issue Reports in Software Evolution
2015
Software developers in large projects work in complex information landscapes and staying on top of all relevant software artifacts is an acknowledged challenge. As software systems often evolve over many years, a large number of issue reports is typically managed during the lifetime of a system, representing the units of work needed for its improvement, e.g., defects to fix, requested features, or missing documentation. Efficient management of incoming issue reports requires the successful navigation of the information landscape of a project. In this thesis, we address two tasks involved in issue management: Issue Assignment (IA) and Change Impact Analysis (CIA). IA is the early task of allocating an issue report to a development team, and CIA is the subsequent activity of identifying how source code changes affect the existing software artifacts. While IA is fundamental in all large software projects, CIA is particularly important to safety-critical development. Our solution approach, grounded on surveys of industry practice as well as scientific literature, is to support navigation by combining information retrieval and machine learning into Recommendation Systems for Software Engineering (RSSE). While the sheer number of incoming issue reports might challenge the overview of a human developer, our techniques instead benefit from the availability of ever-growing training data. We leverage the volume of issue reports to develop accurate decision support for software evolution. We evaluate our proposals both by deploying an RSSE in two development teams, and by simulation scenarios, i.e., we assess the correctness of the RSSEs' output when replaying the historical inflow of issue reports. In total, more than 60,000 historical issue reports are involved in our studies, originating from the evolution of five proprietary systems for two companies. Our results show that RSSEs for both IA and CIA can help developers navigate large software projects, in terms of locating development teams and software artifacts. Finally, we discuss how to support the transfer of our results to industry, focusing on addressing the context dependency of our tool support by systematically tuning parameters to a specific operational setting.
Managing Open Bug Repositories through Bug Report Prioritization Using SVMs
Managing the incoming deluge of new bug reports received in bug repository of a large open source project is a challenging task. Handling these reports manually by developers, consume time and resources which results in delaying the resolution of crucial (important) bugs which need to be identified and resolved earlier to prevent major losses in a software project. In this paper, we present a machine learning approach to develop a bug priority recommender which automatically assigns an appropriate priority level to newly arrived bugs, so that they are resolved in order of importance and an important bug is not left untreated for a long time. Our approach is based on the classification technique, for which we use Support Vector Machines. Experimental evaluation of our recommender using precision and recall measures reveals the feasibility of our approach for automatic bug priority assignment.
Mining Historical Information to Study Bug Fixes
2018
Software is present in almost all economic activity, and is boosting economic growth from many perspectives. At the same time, like any other man-made artifacts, software suffers from various bugs which lead to incorrect results, deadlocks, or even crashes of the entire system. Several approaches have been proposed to aid debugging. An interesting recent research direction is automatic program repair, which achieves promising results towards the reduction of costs associated with defect repair in software maintenance. The identification of common bug fix patterns is important to generate program patches automatically. In this paper, we conduct an empirical study with more than 4 million bug fixing commits distributed among 101,471 Java projects hosted on GitHub. We used a domain-specific programming language called Boa to analyze ultra-large-scale data efficiently. With Boa’s support, we automatically detect the prevalence of the 5 most common bug fix patterns (identified in the wor...