Understanding the complexity of refactoring in software systems: a tool-based approach

Abstract

The majority of information systems these days engender a high level of complexity through the extent of possible inputs to testing, required processing and consequent outputs. In fact, complexity permeates every level of this model for an information system. Complexity thus has a direct effect on the extent to which a system needs to be tested, through those inputs. Complexity also inhibits the ease with which a system can be modified since more time needs to be devoted to assessment of change complexity and resulting tests. Reduction of complexity is the goal of every developer when initially developing a system and, as importantly, after the system has been developed and inevitable changes are made. In this paper, we analyse an automated technique for extracting the typical changes (or refactorings as we have labelled them) made to various Java systems over different versions of its lifetime. Our goal is to identify areas of change where complexity can be examined more thoroughly and aid thus given to the developer when maintaining systems. A generic tool was developed specifically for this task and the results showed new and promising insights into the way systems behave as they evolve. In particular, the complex refactorings are relatively rare compared with more simple refactorings.

Keywords:

• Software systems
• Refactoring
• Tool-based approach
• Information systems

Acknowledgements

The authors would like to thank the anonymous referees for their insightful and useful comments. The paper benefited significantly from these comments.