Marco Zanoni

Automatic detection of bad smells in code: An experimental assessment

Code smells are structural characteristics of software that may indicate a code or design problem that makes software hard to evolve and maintain, and may trigger refactoring of code. Recent research is active in defining automatic detection tools to help humans in finding smells when code size becomes unmanageable for manual review. Since the definitions of code smells are informal and subjective, assessing how effective code smell detection tools are is both important and hard to achieve. This paper reviews the current panorama of the tools for automatic code smell detection. It defines research questions about the consistency of their responses, their ability to expose the regions of code most affected by structural decay, and the relevance of their responses with respect to future software evolution. It gives answers to them by analyzing the output of four representative code smell detectors applied to six different versions of GanttProject, an open source system written in Java. The results of these experiments cast light on what current code smell detection tools are able to do and what the relevant areas for further improvement are.

A tool for design pattern detection and software architecture reconstruction

It is well known that software maintenance and evolution are expensive activities, both in terms of invested time and money. Reverse engineering activities support the obtainment of abstractions and views from a target system that should help the engineers to maintain, evolve and eventually re-engineer it. Two important tasks pursued by reverse engineering are design pattern detection and software architecture reconstruction, whose main objectives are the identification of the design patterns that have been used in the implementation of a system as well as the generation of views placed at different levels of abstractions, which let the practitioners focus on the overall architecture of the system without worrying about the programming details it has been implemented with. In this context we propose an Eclipse plug-in called MARPLE (Metrics and Architecture Reconstruction Plug-in for Eclipse), which supports both the detection of design patterns and software architecture reconstruction activities through the use of basic elements and metrics that are mechanically extracted from the source code. The development of this platform is mainly based on the exploitation of the Eclipse framework and plug-ins as well as of different Java libraries for data access and graph management and visualization. In this paper we focus our attention on the design pattern detection process.

Code Smell Detection: Towards a Machine Learning-Based Approach

Several code smells detection tools have been developed providing different results, because smells can be subjectively interpreted and hence detected in different ways. Usually the detection techniques are based on the computation of different kinds of metrics, and other aspects related to the domain of the system under analysis, its size and other design features are not taken into account. In this paper we propose an approach we are studying based on machine learning techniques. We outline some common problems faced for smells detection and we describe the different steps of our approach and the algorithms we use for the classification.

On applying machine learning techniques for design pattern detection

We apply machine learning to detect design patterns in software systems.We exploit a specific design pattern model to apply machine learning techniques.We compare the performances of several machine learning algorithms.We provide a large dataset containing manually checked design pattern instances. The detection of design patterns is a useful activity giving support to the comprehension and maintenance of software systems. Many approaches and tools have been proposed in the literature providing different results. In this paper, we extend a previous work regarding the application of machine learning techniques for design pattern detection, by adding a more extensive experimentation and enhancements in the analysis method. Here we exploit a combination of graph matching and machine learning techniques, implemented in a tool we developed, called MARPLE-DPD. Our approach allows the application of machine learning techniques, leveraging a modeling of design patterns that is able to represent pattern instances composed of a variable number of classes. We describe the experimentations for the detection of five design patterns on 10 open source software systems, compare the performances obtained by different learning models with respect to a baseline, and discuss the encountered issues.

Towards assessing software architecture quality by exploiting code smell relations

We can evaluate software architecture quality using a plethora of metrics proposed in the literature, but interpreting and exploiting in the right way these metrics is not always a simple task. This is true for both fixing the right metric threshold values and determining the actions to be taken to improve the quality of the system. Instead of metrics, we can detect code or architectural anomalies that give us useful hints on the possible architecture degradation. In this paper, we focus our attention on the detection of code smells and in particular on their relations and co-occurrences, with the aim to evaluate technical debt in an architectural context. We start from the assumption that certain patterns of code anomalies tend to be better indicators of architectural degradation than simple metrics evaluation.

Towards a prioritization of code debt: A code smell Intensity Index

Code smells can be used to capture symptoms of code decay and potential maintenance problems that can be avoided by applying the right refactoring. They can be seen as a source of technical debt. However, tools for code smell detection often provide far too many and different results, and identify many false positive code smell instances. In fact, these tools are rooted on initial and rather informal code smell definitions. This represents a challenge to interpret their results in different ways. In this paper, we provide an Intensity Index, to be used as an estimator to determine the most critical instances, prioritizing the examination of smells and, potentially, their removal. We apply Intensity on the detection of six well known and common smells and we report their Intensity distribution from an analysis performed on 74 systems of the Qualitas Corpus, showing how Intensity could be used to prioritize code smells inspection.

DPB: A Benchmark for Design Pattern Detection Tools

Many activities can be done to support software evolution and reverse engineering of a system. Design pattern detection is one of these activities. It is useful to gain knowledge on the design issues of an existing system, on its architecture and design quality, improving the comprehension of the system and hence its maintainability and evolution. Several tools for design pattern detection have been developed in the literature, but they usually provide different results when analyzing the same systems. Some works have been proposed in the literature to compare these results, but a standard and widely-accepted benchmark is not yet available. In this work we propose our benchmark web application for design pattern detection, based on a community driven evaluation.

Using Design Pattern Clues to Improve the Precision of Design Pattern Detection Tools

Design pattern detection, or rather the detection of structures that match design patterns, is useful for reverse engineering, program comprehension and for design recovery as well as for re-documenting object-oriented systems. Finding design patterns inside the code gives hints to software engineers about the methodologies adopted and the problems found during its design phases, and helps the engineers to evolve and maintain the system. In this paper, we present the results provided by four dierent design pattern detection tools on the analysis of JHotDraw 6.0b1, a well-known Java GUI framework. We show that the tools generally provide dierent results, even while evaluating the same system. From this observation, we introduce an approach based on micro structures detection that aims to discard the false positives from the detected results, hence improving the precision of the analyzed tools results. For this purpose we exploit a set of micro structures called design pattern clues, which give useful hints for the detection of design patterns.

Software Clone Detection and Refactoring

Several studies have been proposed in the literature on software clones from different points of view and covering many correlated features and areas, which are particularly relevant to software maintenance and evolution. In this paper, we describe our experience on clone detection through three different tools and investigate the impact of clone refactoring on different software quality metrics.

On Investigating Code Smells Correlations

Code smells are characteristics of the software that may indicate a code or design problem that can make software hard to evolve and maintain. Detecting and removing code smells, when necessary, improves the quality and maintainability of a system. Code smells have been defined in [5], and different detection tools have been developed, each one characterized by particular features and providing often different results. Usually detection techniques are based on the computation of a particular set of combined metrics, or standard object-oriented metrics [8] or metrics defined ad hoc for the smell detection. As outlined in [3] there is the need for a clearer research strategy on smells identification and measurement. Other knowledge has to be exploited for their detection. In this work we are interested to investigate the direct and indirect correlations existing between smells. Moreover we propose to analyze if other relations exist between code smell and another kind of micro structure, called micro pattern[6]. We started this research since we think that the knowledge on these relations between smells could be exploited by code smell detection tools to improve their results. If one code smell exists, this can imply the existence of another code smell, or if one smell exists, another one cannot be there, or perhaps we could observe that some code smells tend to go together.