In this paper, we present an approach for improving Spectrum-Based Fault Localization (SBFL) by integrating static and dynamic information about code elements. This is achieved by giving more importance to code elements that include mathematical operators compared to other types of elements (e.g., declaration, selection, iteration, or function call) and appear in failed tests. The intuition is that these elements are more likely to have bugs than others. The proposed approach is applicable to any SBFL formula without requiring any modifications to their structures because the weighting is done on the ranking list and not on the formulas. The experimental results of a preliminary study show that our approach achieved a much better performance in terms of average ranking compared to the underlying SBFL formulas. It also improved the Top-N categories; it doubled the number of cases in which the faulty method became the top-ranked element, and in all cases the fault became part of Top-5 of the ranking list.

Many tools for enabling developers to locate bugs in their programs have been proposed in the literature. The majority of programs they target are based on C/C++ and Java. In this paper, we offer a tool named "SFLaaS" for locating faults in programs written in Python and is provided as a service rather than as a plugin or a command-line tool to be installed. Thus, our tool can be accessed anytime and from anywhere. The tool employs Spectrum-based fault localization (SBFL) to help Python developers automatically analyze their programs and generate useful data at run-time to be used to produce a ranked list of potentially faulty program elements (i.e., statements). Our tool supports different important features in fault localization such as supporting about 80 SBFL formulas, different tie-breaking methods, showing code elements with different colors, ranging from most suspicious (red) not suspicious (green) based on their suspicious scores, allowing the user to define his/her own formula, etc. Using our tool could help developers to efficiently find the locations of different types of faults in their programs.

Many tools for enabling developers locating faults in their programs have been proposed in the literature. The majority of the programs they target are those created in the C/C++ and Java languages. In this paper, we offer a tool named "SFLaaS" for locating faults in programs written in Python, a popular programming language, and is provided as a service rather than as a plugin or a command-line tool to be installed. Thus, our tool can be accessed anytime and from anywhere. The tool employs Spectrum-based fault localization (SBFL) to help Python developers automatically analyze their programs and generate useful data at run-time to be used to produce a ranked list of potentially faulty program elements (i.e., statements). Our proposed tool supports different important features in fault localization such as supporting about 80 SBFL formulas, different tie-breaking methods, showing code elements with different colors, ranging from most suspicious (red) to not suspicious (green) based on their suspicious scores, allowing the user to define his/her own formula, etc. Using our tool could help developers to efficiently find faults in their programs.

Spectrum-Based Fault Localization (SBFL) uses a mathematical formula to determine a suspicion score for each program element (such as a statement, method, or class) based on fundamental statistics (e.g., how many times each element is executed and not executed in passed and failed tests) taken from test coverage and results. Based on the calculated scores, program elements are then ordered from most suspicious to least suspicious. The elements with the highest scores are thought to be the most prone to error. The final ranking list of program elements aids developers in debugging when looking for the source of a fault in the program under test. In this paper, we present a new SBFL ranking formula that enhances a base formula by ranking code elements slightly higher than others that are executed by more failed tests and less passing ones. Its novelty is that it breaks ties between the elements that share the same suspicion score of the base formula. Experiments were conducted on six single-fault programs of the Defects4J dataset to evaluate the effectiveness of the proposed formula. The results show that our new formula when compared to three widely-studied SBFL formulas, achieved a better performance in terms of average ranking. It also achieved positive results in all of the Top-N categories and increased the number of cases where the faulty element became the top-ranked element by 13–23%.

Software module clustering is an unsupervised learning method used to cluster software entities (e.g., classes, modules, or files) with similar features. The obtained clusters may be used to study, analyze, and understand the software entities’ structure and behavior. Implementing software module clustering with optimal results is challenging. Accordingly, researchers have addressed many aspects of software module clustering in the past decade. Thus, it is essential to present the research evidence that has been published in this area. In this study, 143 research papers from well-known literature databases that examined software module clustering were reviewed to extract useful data. The obtained data were then used to answer several research questions regarding state-of-the-art clustering approaches, applications of clustering in software engineering, clustering processes, clustering algorithms, and evaluation methods. Several research gaps and challenges in software module clustering are discussed in this paper to provide a useful reference for researchers in this field.

Fault localization is one of the most time-consuming and error-prone parts of software debugging. There are several tools for helping developers in the fault localization process, however, they mostly target programs written in Java and C/C++ programming languages. While these tools are splendid on their own, we must not look over the fact that Python is a popular programming language, and still there are a lack of easy-to- use and handy fault localization tools for Python developers. In this paper, we present a tool called “CharmFL” for software fault localization as a plug-in for PyCharm IDE. The tool employs Spectrum-based fault localization (SBFL) to help Python developers automatically analyze their programs and generate useful data at run-time to be used, then to produce a ranked list of potentially faulty program elements (i.e., statements, functions, and classes). Thus, our proposed tool supports different code coverage types with the possibility to investigate these types in a hierarchical approach. The applicability of our tool has been presented by using a set of experimental use cases. The results show that our tool could help developers to efficiently find the locations of different types of faults in their programs.

In Spectrum-Based Fault Localization (SBFL), a suspiciousness score is assigned to each code element based on test coverage and test outcomes. The scores are then used to rank the code elements relative to each other in order to aid the programmer during the debugging process when seeking the source of a fault. However, probably none of the known SBFL formulae are guaranteed to produce different scores for all the program elements, hence ties emerge between the code elements. Based on our experiments, ties in SBFL are prevalent: in Defects4J, 54–56% of buggy methods are members of ties, i.e., there is at least one other method with the same score in these cases (but typically much more, on average 6), and this inevitably reduces the effectiveness of any SBFL approach. In this work, we present a technique to break ties in such cases based on the so-called method calls frequencies. This counts the number of different contexts of method calls (both as callees and as callers) in failing test cases. The intuition is that if a method appears in many different calling contexts during a failing test case, it will be more suspicious and get a higher rank position compared to other methods with the same scores. This method can be applied to any underlying SBFL formula, and can favourably break the occurring ranks in the ties in many cases. The experimental results show that our novel tie-breaking strategy achieved a significant reduction in both size and number of critical ties in our benchmark. In 72-73% of the cases, the ties were completely eliminated and the average reduction rate was more than 80%.