An empirical study of code clone genealogies

Abstract

It has been broadly assumed that code clones are inherently bad and that eliminating clones by refactoring would solve the problems of code clones. To investigate the validity of this assumption, we developed a formal definition of clone evolution and built a clone genealogy tool that automatically extracts the history of code clones from a source code repository. Using our tool we extracted clone genealogy information for two Java open source projects and analyzed their evolution.Our study contradicts some conventional wisdom about clones. In particular, refactoring may not always improve software with respect to clones for two reasons. First, many code clones exist in the system for only a short time; extensive refactoring of such short-lived clones may not be worthwhile if they are likely diverge from one another very soon. Second, many clones, especially long-lived clones that have changed consistently with other elements in the same group, are not easily refactorable due to programming language limitations. These insights show that refactoring will not help in dealing with some types of clones and open up opportunities for complementary clone maintenance tools that target these other classes of clones.

An empirical study on the maintenance of source code clones

“…Kim et al [30]) occurring in any system snapshot. The above choice does not constitute a limitation for our approach, which can be used to build clone genealogies as well.…”

“…Such studies, however, neither considered phenomena such as the propagation of changes to clones belonging to the same clone class nor did they investigate the relationship between the presence of clones and the source code fault-proneness. [30]. They proposed a formal definition of clone evolution and built a clone genealogy tool to automatically extract the history of code clones from a source code repository.…”

An Empirical Study of Function Clones in Open Source Software

“…Of them, Casazza et al [7] and Antoniol et al [4] provide interesting findings, but they focus on clone evolution, whereas we focus on the occurrence of copy/paste clones in several dimensions. Kim et al [17] also studied the evolution of code clones in several systems and concluded that programmers often intentionally practice code cloning. Jiang and Hassan [10] also used the Linux Kernel as an example for their framework for understanding cloning in large systems.…”

“…Although cloning is beneficial in some cases [13] and often programmers intentionally use it [17], it can be detrimental to software maintenance [8,12]. For example, if a bug is detected in a code fragment, all the fragments similar to it should be investigated to check for the same bug [19], and when enhancing or adapting a piece of code, duplicated fragments can multiply the work to be done [12].…”

An empirical study of the relationships between design pattern roles and class change proneness

“…Historical data on the changes of open-source systems allowed researchers to empirically investigate on the evolution of various software entities, such as clones [10,14] or design motifs [2]. Some studies considered changes between releases, i.e., stable snapshots released after some amount of changes, while others exploited the historical data available in versioning systems, such as CVS or SVN.…”