In this retrospective article of our TSE paper “CCFinder: A Multilinguistic Token-Based Code Clone Detection System for Large Scale Source Code” (Kamiya et al., 2002), we revisit the reasons why we became deeply involved in code clone research, and explore what has driven its frequent citation in many studies. Furthermore, we reflect on why not only our own lab, but also numerous researchers and tool developers have pursued code clone research and the development of related tools.

For various reasons, programming languages continue to multiply and evolve. It has become necessary to have a multilingual clone detection tool that can easily expand supported programming languages and detect various code clones is needed. However, research on multilingual code clone detection has not received sufficient attention. In this study, we propose MSCCD (Multilingual Syntactic Code Clone Detector), a grammar pluggable code clone detection tool that uses a parser generator to generate a code block extractor for the target language. The extractor then extracts the semantic code blocks from a parse tree. MSCCD can detect Type-3 clones at various granularities. We evaluated MSCCD's language extensibility by applying MSCCD to 20 modern languages. Sixteen languages were perfectly supported, and the remaining four were provided with the same detection capabilities at the expense of execution time. We evaluated MSCCD's recall by using BigCloneEval and conducted a manual experiment to evaluate precision. MSCCD achieved equivalent detection performance equivalent to state-of-the-art tools.

Agec is a semantic code-clone detection tool from Java bytecode, which (1) applies a kind of abstract interpretation to bytecode as a static analysis, in order to generate n-grams of possible execution traces, (2) detects the same n-grams from distinct places of the bytecode, and (3) then reports these n-grams as code clones. The strengths of the tool are: static analysis (no need for test cases), detection of clones of deeply nested invocations, and Map-Reduce ready detection algorithms for scalability.

This tool demo presents a tool prototype named VACI, which extracts relations between identifiers and their contexts in source code, and classifies (sets of) identifier names. The tool has two features; the first feature analyzes software for refactorings to enable users to check the adequateness of identifier names with context information. The second feature analyzes versions of code during maintenance activities to enable users to understand changes or trends in identifier names between versions.

Assertion checking is a powerful tool to detect software faults during debugging, testing and maintenance. Although assertion documents the behavior of one component, it is hard to document relations and interactions among several objects since such assertion statements are spread across the modules. Therefore, we propose to modularize such assertion as an aspect in order to improve software maintainability. In this paper, taking Observer pattern as an example, we point out that some assertions tend to be crosscutting, and propose a modularization of such assertion with aspect-oriented language. We show a limitation of traditional assertion and effectiveness of assertion aspect through the case study, and discuss various situations to which assertion aspects are applicable.

It is generally accepted that a code clone is one factor making software maintenance difficult. A code clone is a code portion in source files that is identical or similar to another. Clones are introduced because of various reasons such as reusing code by 'copy-and-paste' and so on. Since developers usually modify the copied-and-pasted code portions, there are gaps between them and the original code portion. We call such code portions including gaps gapped code clones. Several code clone detection methods, which consider such gaps, have been proposed. However, it is costly to detect all gapped code clones. This paper proposes a new method to visualize gapped code clones as if they were actually detected, based on the detection results of conventional code clones. Using the proposed method, the developer can specify target clones efficiently. Moreover, we implement the proposed method in the maintenance support environment and conduct an experimental evaluation.

A code clone is a code portion in source files that is identical or similar to another. Since code clones are believed to reduce the maintainability of software, several code clone detection techniques and tools have been proposed. This paper proposes a new clone detection technique, which consists of the transformation of input source text and a token-by-token comparison. For its implementation with several useful optimization techniques, we have developed a tool, named CCFinder (Code Clone Finder), which extracts code clones in C, C++, Java, COBOL and other source files. In addition, metrics for the code clones have been developed. In order to evaluate the usefulness of CCFinder and metrics, we conducted several case studies where we applied the new tool to the source code of JDK, FreeBSD, NetBSD, Linux, and many other systems. As a result, CCFinder has effectively found clones and the metrics have been able to effectively identify the characteristics of the systems. In addition, we have compared the proposed technique with other clone detection techniques.

This paper describes two software maintenance support tools, CCFinder (Code Clone Finder) and JAAT (Java Alias Analysis Tool), for Java programs. CCFinder identifies code clones in Java programs, while JAAT executes alias analysis for Java programs.

To analyse the complexity of object-oriented software, several metrics have been proposed. Among them, Chidamber and Kemerer's (1994) metrics are well-known object-oriented metrics. Also, their effectiveness has been empirically evaluated from the viewpoint of estimating the fault-proneness of object-oriented software. In the evaluations, these metrics were applied, not to the design specification but to the source code, because some of them measure the inner complexity of a class, and such information cannot be obtained until the algorithm and the class structure are determined at the end of the design phase. However, the estimation of the fault-proneness should be done in the early phase so as to effectively allocate effort for fixing the faults. This paper proposes a new method to estimate the fault-proneness of an object class in the early phase, using several complexity metrics for object-oriented software. In the proposed method, we introduce four checkpoints into the analysis/design/implementation phase, and we estimate the fault-prone classes using applicable metrics at each checkpoint.