Software reengineering and refactoring are related but distinct activities. Reengineering a software system typically involves first reverse engineering it in order to extract a high-level design, and then forward engineering it to improve its design, add new functionality or correct errors. Refactoring differs from this in two ways. Firstly, refactoring is usually a code-to-code transformation and secondly, its goal is to improve design, not to change functionality. Reengineering has been a standard physical engineering process for a long time, coming into use as a software process in the early 1990s. The advent of refactoring is more recent, aided by the burgeoning popularity of Agile Processes that emphasize code quality and regard refactoring as a central part of the development process. Unlike software reengineering, refactoring has no equivalent in physical engineering.

The papers in this track reflect the increased importance of refactoring and the related issue of code smells, as well as the steady interest in software reengineering. Two papers deal with refactoring, three with code smell detection and two with reengineering.

The paper by Soetens and Demeyer studies the impact of refactoring on software metrics. Refactoring aim to improve design quality while metrics measure design quality, so one might naively expect a direct correlation between the application of refactoring and quality improvement as measured by metrics. However, the situation transpires to be not so simple. In their paper, Joshi and Joshi study a number of standard cohesion metrics and try to empirically determine which ones most accurately reflect actual class cohesion, and changes to class cohesion. With the increased use of software quality metrics to determine which refactoring should be applied, it is important to study which of the vast array of available metrics are useful for this purpose.

Chatzigeorgiou and Manakos in their paper study the evolution of code smells in open source repositories. Of particular interest is to determine what causes code smells to disappear in practice. Surprisingly, in only a small number of cases is the remediation of a code smell the direct result of refactoring. Combining this result with the Soetens and Demeyer paper above, we see that in this research little evidence has been found to support two of the popular beliefs about refactoring: that they improve software quality and remediate code smells.

Bryton et al in their contribution analyze one of the most common code smells, Long Method. This smell is naturally very subjective and threshold-dependent, and this paper seeks to place its detection on a more objective footing. A mathematical model is used that can be trained using experts’ judgments, and then used to detect the smell on unseen examples. Of particular interest here is whether the approach can be generalized to other smells as well. A related approach to smell detection is presented in the paper of Hassaine et al. They use an Artificial Immune System (AIS) to detect code smells. This approach is based on the metaphor of the software system as an organism and the code smell as a pathogen. The results of this approach are promising and it has the advantage of being able to detect problems that are not yet smells, and requires less input from experts.

Turning to the reengineering contributions, Ferreira da Silva and Brito e Abreu propose a regression-based technique to discover the topology of a distributed Information Technology Infrastructure (ITI) network. The topology of a large ITI network is likely to be in constant evolution, so discovering this topology is an important maintenance task. Their approach is validated by applying it to the ITI networks of a number of real-world organizations, and the results are found to be in keeping with the expected topologies. Trümper et al present a program comprehension technique that helps maintainers to understand the runtime behavior of complicated, multithreaded software systems. They instrument the executable form of the software system to be analyzed, thus enabling the collection of execution traces at run-time. After post-processing, these synchronized traces of multiple threads can be explored interactively by maintainers. The usefulness of the technique is demonstrated by case studies on two industrial software systems.

In summary, the papers of this track cover a broad spectrum of contemporary topics including refactoring, code smells, software quality metrics, reengineering and visualization. The research presented is imaginative and novel, and illuminates an exciting field where we can expect to see many further developments in the near future.