Query-based Filtering and Graphical View Generation for Clone Analysis

Transcription

1 Int. Conf. on Software Maintenance, Beijing, Sept 2008 Query-based Filtering and Graphical View Generation for Clone Analysis Yali Zhang 1, Hamid Abdul Basit 2, Stan Jarzabek 1, Dang Anh 1, and Melvin Low 1 1 Department of Computer Science, School of Computing National University of Singapore stan@comp.nus.edu.sg 2 Department of Computer Science, School of Science and Engineering Lahore University of Management Sciences hamidb@lums.edu.pk Abstract Code clones are similar program structures recurring in software systems. Clone detectors produce much information and a challenge is to identify useful clones depending on the goals of clone analysis. To do so, further abstraction, filtering and visualization of cloning information, with the involvement of a human expert, is required. In this paper, we describe a technique for filtering and visualization of cloning information generated by Clone Miner, a clone detection tool presented in our earlier work. Unique benefit and contribution of our approach is that a human expert can define a wide range of filters to extract abstract views of the cloning data using a clone-query system to suit specific needs of clone analysis. We then produce standardized graphical presentations of those views for various types of clone queries. We implemented the technique into an Eclipse plug-in called Clone Visualizer. Clone Visualizer works closely with Clone Miner which not only finds similar code fragments (simple clones) but also finds higher-level abstractions of the cloning information. Our method is the first attempt to address filtering and visualization of those higher level cloning abstractions. We illustrate application of our technique with examples from a clone analysis project with Clone Miner and Clone Visualizer. 1. Introduction and motivation Software similarities, referred to as clones, are a common phenomenon in large software systems [1] [13]. Knowing clones location in programs can help in software maintenance, reducing the risk of update anomalies. Knowledge of clones may also shed light on the quality, maintainability and reusability of a software system, and can help in software reengineering. Some of the clones can be unified by applying design patterns, refactoring, using macros or a generative technique such as Aspect-Oriented Programming (AOP) [15] or XML-based Variant Configuration Language (XVCL) [22] [7] [23]. The above observations motivate work on clone detection and analysis. Clone detectors produce much information. Identifying useful clones requires post-detection analysis with the involvement of a human analyst [14] [20]. Clone detectors apply similarity heuristics to match human expectations for useful clones. These heuristics are expressed in terms of threshold values for factors that have to do with similarity such as percentage of repeated code, the size of program structures or characterization of program structures in terms of software metrics [18] or Levenshtein editing distance [5]. In reality, it is difficult to approximate human expectations of useful clones by calibrating threshold values. That is why tools can only find clone candidates, from which a human analyst needs to filter clones that are useful in the view of his/her specific goals. This motivates the need for analysis, filtering and visualization techniques to assist developers in post-detection analysis of clones and extracting useful ones from false-positives. During post-detection analysis, we try to make sense of the bulk of cloning information produced by a clone detection tool, and locate the relevant clones in the program code. Abstraction, filtering, and visualization of cloning information are the cornerstones of any strategy to address this problem. However, there is no one-size-fits-all solution, as a successful strategy depends on the cloning situation found in a system, and the specific goals of clone analysis, that vary from project-to-project. A unique benefit and contribution of the solution described in this paper is that it enables a programmer to define customized filters on the cloning data. It is also the first attempt to address filtering and visualization of higher-level cloning abstractions formed by Clone Miner that represent larger, designlevel software similarities [2].

2 The core idea of our solution is a clone-query system that allows us to specify filters to extract abstract views from the bulk of cloning data. We then produce standardized graphical presentations of those views for various types of clone queries. We store clone detector s output in a relational database. Queries are first conceived in terms of the conceptual model of cloning information, and then expressed in SQL. We implemented our solution into an Eclipse ( plug-in called Clone Visualizer. Clone Visualizer allows a programmer to incrementally explore the space of a clone-query result, zooming into specific clones, and hiding the details of others. It uses public domain libraries [12] to display query results in graphical forms. We developed our approach to enable the follow up analysis of cloning data produced by our clone detector called Clone Miner [2]. Unlike most of the other clone detectors, Clone Miner not only finds simple clones, but also presents further abstractions of these clones in the form of large granularity similar program structures such as similar files or repeating configurations of similar files across directories. Our previous research showed that elevating software similarity analysis to such large granularity similar program structures improves our understanding of the overall similarity situation in a subject system [2]. Clone Miner uses data mining techniques to detect these cloning abstractions as recurring configurations of simple clones or other lower-level cloning abstractions [2]. As Clone Miner already raises the level of abstraction of cloning information, it gives an additional head-start for the follow up analysis with user involvement. In the paper, we illustrate the application of our technique with examples from a case study involving an open source system. The paper is organized as follows: Section 2 points to the related work. In Section 3, we give an overview of Clone Miner and introduce the cloning abstractions found by the tool. Sections 4, 5 and 6 describe our proposed clone analysis techniques. Section 7 presents Clone Visualizer that implements those techniques. Section 8 illustrates the application of Clone Visualizer in a case study. Conclusions end the paper. 2. Related work There are numerous tools and techniques for simple clone detection, including plain text matching [6] [9], metrics value comparison [18], abstract syntax tree comparison [3], program dependence graph matching [16], token string pattern matching [13], and data mining [17]. Post-detection clone analysis techniques have also been proposed [14] [19] [20]. Work presented in this paper extends the previous research by addressing higher-level cloning abstractions, in addition to simple clones, and proposing a general facility to define a wide range of filters of cloning information. Specialized query systems have been successfully applied in other software domains where there is a need to bridge the gap between the bulk of low-level data and high-level concepts. Static Program Analyzers and reverse engineering tools [4] applied queries to help a programmer gain better understanding of a program under maintenance. Query-based tools have been implemented that queries the status of a project, based on the software metrics collected by developers [8]. Scatter plots or dot plots are commonly used for visualization of simple clone pairs [1] [6] [19] [20]. Scatter plots provide an overview of the cloning situation, but lack scalability, and, in certain cases, fail to provide a good overview of cloning intensity [19] [14]. Various other polymetric views for showing cloning relationship between different parts of the system and the extent of cloning in these parts have been proposed in [19]. Hasse diagrams and hyperlinked documents have also been tried for clone visualization and navigation [10] [11]. Visualization of clone detection results using stacked bar charts have been implemented as an Eclipse plug-in to extend the AspectJ Development Tool (AJDT) [20]. Gemini [21] is a clone analysis tool that works with CCFinder as its back-end clone detector. It facilitates simple clone analysis with metrics graphs, file similarity tables, code browsing and code comparison based on clone pairs and clone classes, as well as scatter plots. The basic requirements for a complete clone comprehension tool, as identified in [14], include facilities to evaluate the overall cloning situation in the system, a mechanism to guide users towards finding useful clones, and a method for filtering and refining clone classes. A tool implementing the described features, and the usefulness of those features using a case study, are also described in [14]. Clone analysis technique described in this paper attempts to provide these desired features in the context of higher-level cloning abstractions with a more powerful querying system. 3. Overview of Clone Miner Clone Miner [2] detects simple clones first, and then extracts higher-level cloning abstractions, such as similar files or configurations of similar files across directories, from simple clones. Simple clone classes

3 (SCC) are detected from a tokenized representation of the source code. With frequent itemset mining technique, Clone Miner then finds repeated configurations of co-located simple clones across different methods and files, to form the first level of cloning abstractions. Finally, clustering technique is applied to identify the next level of cloning abstractions, consisting of groups of similar methods and files. Clone Miner locates these groups from the significance of the common configurations of simple clones across the methods and files in each group. We call these cloning abstractions Method clone classes (MCC) and File clone classes (FCC). Clone Miner also detects repeated configurations of these method clones (called method clone structures or MCS) and file clones (called file clone structures or FCS) across different files and directories, respectively. All types of cloning abstractions detected by Clone Miner are grouped into clone classes rather than clone pairs for a more comprehensive representation. Following is a list of all the cloning abstractions detected by Clone Miner, apart from the simple clones. Figure 1 models the Clone Miner output in the form of a UML class diagram. The acronyms in brackets refer to the entities of the Clone Miner output shown in Figure 1. 1) repeated configurations of simple clones a) in the same method (SCS_In_Method) b) across different methods (SCS_Across_Method) 2) repeated configurations of simple clones a) in the same file (SCS_In_File) b) across different files (SCS_Across_File) 3) method clone classes (MCC) 4) file clone classes (FCC) 5) repeated configurations of method clones a) in the same file (MCS_In_File) b) across different files (MCS_Across_File) 6) repeated configurations of file clones a) in the same directory (FCS_In_Dir) b) across different directories (FCS_Across_Dir) Figure 1. Conceptual data model of Clone Miner output

4 Int. Conf. on Software Maintenance, Beijing, Sept 2008 In addition to all the clone classes listed above, we have also modeled clone instances of these clone classes. Note that for each clone class we have a corresponding clone instance, but in Figure 1 we have only shown SCC_Instance to avoid confusion because of cluttering. The output from Clone Miner is in the form of plain text files, with clone information represented by numbers that serve identification purpose or describe clone characteristics. For example, each clone class, as well as each of its members, is identified by a unique ID. Other numbers state how many instances belong to a given clone class, the length of a clone instance in terms of tokens, the file ID for the file that contains a given clone instance, and the location of the instance in the file. For SCS_Across_File and SCS_Across_Method, Clone Miner also computes two metrics related to the coverage of simple clones; average token coverage (ATC) and average percentage coverage (APC). ATC represents the average number of tokens from the given containers (methods and files respectively) that are covered by the simple clone instances forming a repeated configuration, while APC gives the same value as a percentage of the total size of the container. Based on the user-defined threshold values for APC and ATC, certain groups of methods and files that contain SCS_Across_File and SCS Across_Method, with the APC and ATC values above the threshold, are declared to be MCC and FCC, respectively. 4. Clone analysis with sortable tables Sortable tables are often used to arrange and view information that can be organized in many ways, along multiple dimensions. With sortable tables, we can arrange clone classes and clone instances according to their characteristics the user is interested in (Figure 2). For example, we can sort clone classes in descending order of their length, so as to bring the largest clones on top. Alternately, we can compute a metrics benefit for each clone class, where: benefit= (members-1)*length This would give an estimate of the amount of code reduction in ideal conditions by clone unification of the clone class, and arranging clone classes in descending order of benefit would give an indication of the intensity of cloning in the system, by bringing up the clone classes with the largest benefits. As described previously, all the clones are arranged in terms of clone classes rather than clone pairs; hence, we found it useful to show cloning information in two tables, as shown in Figure 2. The primary table (shown at the top in Figure 2) corresponds to clone classes, while the secondary table describes the clone instances. The two tables are synchronized; when the primary table displays the details of a clone class, the secondary table automatically updates itself to display the details of the clone instances of the clone class selected in the primary table. While we found sortable tables useful, we also identified limitation in providing more selective and focused views of the cloning information. For example, the user may want to filter out and view all SCCs that have lengths between 50 and 100 tokens and benefit values between 700 and 800. For such complex and non-standard filters, sortable tables alone are not sufficient. Figure 2. Sortable tables Even though SCCs are the simplest form of cloning information generated by Clone Miner, here are a few more examples of filters related to SCCs that could not be materialized with sortable tables alone: 1. Find all SCCs that have at least 6 members with length greater than 50 tokens and benefit greater than Find all SCCs found in both files 5 and Find all the unique files that contain at least two members of SCC with ID Find the SCCs that are found in the most number of files from the given files with IDs 1, 2, 3, 4, Find all SCCs that recur in all files with IDs As we move from simple clone analysis to the analysis of higher level cloning abstractions generated by Clone Miner, the need for many more complex types of filters increases. Working only with sortable tables and code display windows (Figure 3) makes it difficult to comprehend the overall cloning situation. 5. Filtering with clone-query system In addition to the cloning abstractions found by Clone Miner, we propose a general facility allowing an

5 analyst to specify a wider range of abstract views from the cloning data. We introduce a clone-query system as a flexible user-level mechanism for defining filters that could not be achieved with sortable tables. The idea is to store Clone Miner s output in a relational database, so-called Clone Miner Repository (CMR). The schema of CMR closely follows the conceptual model of Clone Miner output shown in Figure 1. We specify filters as queries in SQL which are evaluated against the CMR. The results of queries can be shown in tabular form using sortable tables (as discussed in the previous section) or in graphical views (as described in the next section). Figure 3. Code display windows As writing complex queries in SQL requires expertise, we propose querying/filtering forms for common types of queries for the novice users. In this case, the analyst only needs to enter the query parameters, and the proper query in SQL is autogenerated and evaluated on the CMR. Figure 4 shows an example of a query form related to the simple clone classes (SCC). Edit boxes are query parameters, referring to the different attributes of the SCC. Figure 4. General filter for SCC The following is the meaning of the parameterized query shown in Figure 4: Find all SCCs with <at least m members> and <at most n members> and <at least x tokens length> and <at most y tokens length> and <at least p benefit> and <at most q benefit> and <in locations (files/methods/directories) [list of location IDs]> By instantiating the query parameters, we can formulate concrete queries. As the query is a conjunction of different clauses, the clause for which the analyst does not provide a parameter value is dropped from the final query. Similar multi-clause queries can be presented as parameterized queries for the other types of cloning abstractions Queries related to simple clone classes We now show examples of filters for simple clones and for other cloning abstractions. Filter definitions in SQL are in italics. SCC is a database table containing the data about simple clones, while SCC_FILE is a table containing the information about the relationship between SCCs and Files. 1. Which SCC has the longest instances? Select * from SCC where length in (Select Max (length) from SCC) 2. Which SCC has most members? Select * from SCC where length in (Select Max (members) from SCC) 3. How many instances of SCC 5 are in file 26? Select count (scc_id) from SCC_FILE where scc_id =5 and fid =26 4. How many distinct SCCs are present in file 5? Select distinct scc_id from SCC_FILE where fid =5 5. Which SCCs are found in both files 5 and 6? Select a.scc_id from SCC_FILE a inner join SCC_FILE b on a.scc_id = b.scc_id and a.fid=5 and b.fid = Queries related to MCC In the following queries, METHOD_FILE is a table storing the information about the relationship between methods and files, whereas MCC_METHOD is the

6 table describing the relationship between method clone classes (MCCs) and methods. Methods and files are identified by mid and fid, respectively. 6. Which files contain MCC 5? Select distinct fid from METHOD_FILE where mid in (Select mid from MCC_METHOD where mcc_id =5) 7. Which MCCs are found in file 5? Select mcc_id from MCC_METHOD where mid in (Select mid from METHOD_FILE where fid =5) 5.3. Queries related to SCS across files In these queries, SCSCROSSFILE_FILE is a table describing the relationship between SCS across files and files. Again, fid is the file ID, while scs_crossfile_id is the ID for the SCS across files. 8. Which SCS recur in most files? Select scs_crossfile_id from SCSCROSSFILE_FILE group by scs_crossfile_id having count (fid) in (Select Max(c) from (select count (fid) as c from SCSCROSSFILE_FILE group by scs_crossfile_id having scs_crossfile_id <> -1) as t) 9. Which SCS recur in files 147 and 148? Select a.scs_crossfile_id from SCSCROSSFILE_FILE a inner join SCSCROSSFILE_FILE b on a. scs_crossfile_id = b. scs_crossfile_id and a.fid = 147 and b.fid = Types and examples of graphical views Visualization of cloning information goes hand-inhand with filtering, and can considerably enhance understanding of filtered cloning information. In particular, we can display the results of some clonequeries described in the last section in graphical form. We explored graphical representations including bar charts, line charts and scatter plots. We found that different graphical views are suitable for different types of analysis situations. As scatter plots have already been used by other clone analysis tools, we will not describe them here. Figure 5. Bar chart showing a single MCS A typical situation that calls for bar charts is when we want to view all the simple clone classes (SCC) in a given group of files. Each bar represents a file, and different SCCs are shown as stripes of different colors (or shades). Stripes of the same shade in different bars correspond to an SCC whose instances are found across multiple files. Figure 5 depicts a repeated configuration of method clones (MCS) across four files using the same bar chart representation. The height of the stripe reflects the length of the clone instance, while the location of the stripe in the bar reflects its actual location in the file. The length of the bar is also indicative of the total length of the file. Figure 6. Line chart showing a single SCC It is useful to connect bar charts to the code view shown in Figure 3, allowing a user to view the actual code represented by each stripe. To compare the lengths of clone instances belonging to different SCCs, or to examine the exact positions of clone instances from different SCCs in files, we make use of a line chart (Figure 6). In line chart, each horizontal line (not the grid lines) represents position of a clone instance in a particular file, connecting start line and end line number. In Figure 6, SCC 30 recurs in eight files, from line 148 to line 165 in the first four files, and from lines 355 to 368 in the remaining four files. A line chart of Figure 7 shows eight SCC instances belonging to seven different SCCs present in file 6. This type of view is especially useful in locating the overlapping clone instances. 7. Clone Visualizer We implemented the above filtering and visualization techniques in a tool called Clone Visualizer. Figure 8 shows the main interface of our tool. Clone Visualizer windows show and allow a user to examine various aspects of the cloning information. Clone Visualizer includes Navigator Window (on the

7 left-hand-side), Graphical View Window, Code View Window and Sortable Tables (at the bottom). The Navigator Window shows the directories and files of the analyzed system. Sortable Tables list cloning abstractions and allow a user to select them for analysis. The same window also contains the query form for the fixed parameterized queries related to each cloning abstraction. The Graphical View Window shows graphical views of a selected cloning abstraction. Tabs at the top of that window allow a user to select a required graphical view. We used JFreeChart graphics Library ( to draw some of the visualizations produced by Clone Visualizer. Bar charts are rendered using the AspectJ Development Tool Visualizer ( The Code View Window shows the source code of two instances of a selected cloning abstraction in two vertically tiled panes. Figure 7. Line chart showing all SCCs in a file The basic usage scenario of the Clone Visualizer is to select a cloning abstraction from the Sortable Tables. Then, in the Graphical View Window a user analyzes graphical views of the selected cloning abstraction, and examines the instances of the selected cloning abstraction in the Code View Window. Here, a user can also see the differences between clone instances. Navigator Window Graphical View Window Code View Window Sortable Tables Fixed Query Form Figure 8. Clone Visualizer interface

8 8. Clone views from a case study We illustrate how filtering and visualization techniques described above helped us analyze clones in StrutsBox ( An overview of the case study system StrutsBox is an Eclipse [7] plug-in for developing applications with Apache Struts Framework ( Its central component is a visual editor that graphically shows the flow of information in web applications. Apache Struts is an open source framework for developing Java Web Application [7]. It uses MVC (Model View Controller) architecture ( wiki/model-view-controller), where Model represents the business logic, View represents the user-interface, and Controller represents the navigational code. The goal of StrutsBox is to simplify the development of complicated struts applications. StrutsBox architecture consists of sub-components including core component, strutsconfig component, UI component, and visualizer component. In our case study, we focused only on the UI component Analysis of the UI component The UI component of StrutsBox consists of 106 files with 17,675 lines of code (LOC) and 865 methods. Using Clone Visualizer, we set the parameter values for Clone Miner: minimum clone length to 30 tokens, ATC for both method clone classes (MCC) and file clone classes (FCC) to 50 tokens, and APC (for both) to 50%. Clone Visualizer displayed 247 clone classes, with 1078 clone instances, as detected by Clone Miner. Focusing on the larger cloning abstractions, we found eight file clone classes. The details of two FCCs having the most number of members are presented next. DataSourcesPage.java, FormBeansPage.java, GlobalExecptionsPage.java, GlobalForwardsPage.java, MessageResourcesPage.java, and PluginPage.java.java. Figure 9 shows the bar chart generated by Clone Visualizer to represent similarities in this group of files. The seven files contain three common simple clone classes forming a repeated configuration (an SCS). Instances of the same SCC are represented by the same shaded stripes in different files. The overlapping clone instances of different SCCs are shown by multi-shaded stripes. From this figure, we can infer that this SCS covers nearly one-half of the total length of most of the file, so that these seven files can be safely considered as similar (an FCC). A manual inspection of the code in the Code View Window revealed that there is actually a configuration of two repeated methods in all seven files: namely createdetailspart and createmasterpart, forming a method clone structure (MCS). The implementations of these methods across the seven files are almost the same. The second FCC consists of six files of the form [*]Section.java, namely: ActionSection.java, DataSourceSection.java, ExceptionSection.java, FormBeansSection.java, ForwardSection.java, and MessageResourcesSection.java. The similarities across these six files are presented in Figure 10. Figure 9. SCS across a group of files forming FCC The first FCC consists of seven files of the form [*]Page.java, namely: ActionMappingPage.java, Figure 10. A file clone class (FCC) Figure 11 shows the line chart for one of the files from this FCC containing all the SCC instances. Similar to the previous FCC, the similarity here is again due to a configuration of methods recurring in these files, namely: selectionchanged, ActionSection, createclient, refresh, dispose, commit. These sets of methods appear in all six files, forming a repeated configuration of method clones (an MCS), as depicted in Figure 12. Line chart view also shows that

9 considering MCCs instead of SCCs gives a more crisp and consolidated result and a better understanding of the similarity situation in the code. Figure 11. Line chart showing SCS in a file Focusing on the method clones, we observed that in addition to the above mentioned method clones there is another large group of 30 methods that are clones of each other, forming a method clone class (MCC). This MCC consists of handleremove, handleup, and handledown methods recurring in the following files: ActionMappingMasterSection.java, DataSourcesMasterSection.java, ExceptionTableSection.java, FormBeanMasterSection.java, FormPropertySection.java ForwardTableSection.java, GlobalExceptionMasterSection.java, GlobalForwardsMasterSection.java, MessageResourcesMasterSection.java, PluginMasterSection.java, and SetProperySection.java Figure 12. Bar chart showing MCS across files In another case study, we analyzed a J2EE web portal called Common Application Platform (CAP- WP), developed by our industry partner ST Electronics Pte. Ltd. 929 files, out of a total of 1,919 files, were grouped into 85 FCCs by Clone Miner, and visual analysis of these FCCs by Clone Visualizer suggested that they capture some significant similarities in the system. In yet another study, we analyzed OpenJGraph ( - a Java library containing the well-known graph algorithms. Considerable similarity was observed between different algorithms. For example, BreadthFirstTraversal algorithm was found to be quite similar to the DepthFirstTraversal (implemented as queue and stack respectively) and MinimumSpanningTree algorithm was found to be very similar to the ShortestPath algorithm. The above examples illustrate how visualization of filtered information supported by Clone Visualizer helped us understand cloning situations that otherwise were not easy to spot. 9. Conclusions Clone detectors produce much information and a challenge is to identify useful clones in their output. In this paper, we described a technique for filtering, abstraction and visualization of the cloning information to help human analysts find useful clones. In addition to the novel solutions for filter definition and graphical visualization, we extended analysis and visualization techniques developed by others for simple clones [20] [14] to the area of cloning abstractions found by Clone Miner [2]. The core concept of our solution is a clone-query system that allows us to specify abstract views to be extracted from the cloning information produced by the Clone Miner. We store Clone Miner output in the relational database. Queries are first conceived in terms of the conceptual model of cloning information, and then expressed in SQL. Public domain graph libraries can be used to display the query results in graphical forms as well. We implemented the above mentioned technique in a tool called Clone Visualizer. Clone Visualizer incrementally raises the level of abstraction of recovered cloning information, in iterations, working closely with a human analyst. In each iteration, the analyst feeds the Clone Visualizer with extra inputs, based on his/her domain knowledge, and understanding of the cloning situation gained in the process of design recovery so far. We analyzed the effectiveness of our clone analysis techniques in studies involving open source systems including StrutsBox, OpenJGraph library, Java Buffer Library (java.nio.* package of J2SE), Eclipse Graphical Editing Framework ( Eclipse Visual Editor ( J2ME Wireless Toolkit ( Java Pet Store ( Linux device drivers, and an industry web-portal CAP-WP.

10 We designed Clone Visualizer to work not only with Clone Miner, but also with other similar clone detection tools. To achieve that, we defined a standard, conceptual level description of the required output from a clone detector. Any clone detector whose output conforms (or can be transformed) to this standard is able to benefit from the analysis techniques implemented into the Clone Visualizer. We are currently analyzing public domain software and software written by our industry collaborator to validate and further refine heuristics of our tools. We initiated a project to reach beyond cloning abstractions described in this paper, which are based on the physical location of simple clone configurations. For this, we are analyzing traces of program execution to infer dynamic relationships among program elements (such as message passing among interrelated classes/components). We hope that with more knowledge of the semantic associations between clones, we can better perform the system design recovery. References [1] Baker, B. S. On Finding Duplication and Near- Duplication in Large Software Systems Proc. 2 nd Working Conference on Reverse Engineering, 1995, pp [2] Basit, H.A. and Jarzabek, S. Detecting Higher-level Similarity Patterns in Programs. Proc. ESEC-FSE'05, European Soft. Eng. Conf. and ACM SIGSOFT Symp. on the Foundations of Soft. Eng., Sept. 2005, Lisbon, pp [3] Baxter, I., Yahin, A., Moura L., and Anna, M. S. Clone Detection using Abstract Syntax Trees. Proc. Int. Conf. on Software Maintenance, ICSM 98, pp [4] Chee, C.L., Jarzabek, S. and Paul, R. F-metric: a WWW-based framework for intelligent formulation and analysis of metric queries, Journal of Systems and Software, No. 43, 1998, Elsevier Science Inc., pp [5] De Lucia, A., Scanniello, G., and Tortora, G. Identifying clones in dynamic web sites using similarity thresholds, Proc. Int. Conf. on Enterprise Information Systems (ICEIS), pages , 2004 [6] Ducasse, S., Reiger, M. and Demeyer, S. A Language Independent Approach for Detecting Duplicated Code. In Proceedings of International Conference on Software Maintenance (ICSM 99), 1999, pp [7] Jarzabek, S. and Li, S. Eliminating Redundancies with a Composition with Adaptation Meta-programming Technique, Proc. ESEC-FSE'03, European Soft. Eng. Conf. and ACM SIGSOFT Symp. on the Foundations of Soft. Eng., Sept. 2003, Helsinki, pp [8] Jarzabek, S. Design of Flexible Static Program Analyzers with PQL, IEEE Transactions on Software Engineering, March 1998, pp [9] Johnson, J. H. Substring matching for clone detection and change tracking, Proc. Int Conf. on Software Maintenance (ICSM), 1994, pp [10] Johnson, J. H. Visualizing textual redundancy in legacy source., Proc. Conf. of the Centre for Advanced Studies on Collaborative Research, CASCON, pp. 9-18, 1994 [11] Johnson, H. Navigating the textual redundancy web in legacy source, Proc. Conf. of the Centre for Advanced Studies on Collaborative Research, CASCON, pp. 7-16, 1996 [12] JFreeChart : [13] Kamiya, T., Kusumoto, S. and Inoue, K. CCFinder: A Multi-Linguistic Token-Based Code Clone Detection System for Large Scale Source Code, IEEE Trans. Software Engineering. vol. 28 no. 7, July 2002, pp [14] Kapser, C. and Godfrey, M.W. Improved Tool Support for the Investigation of Duplication in Software, Proc. 21 st Int. Conf. on Software Maintenance, Budapest, Sept. 2005, pp [15] Kiczales, G, Lamping, J., Mendhekar, A., Maeda, C., Lopes, C., Loingtier, J-M., Irwin, J. Aspect-Oriented Programming, Europ. Conf. on Object-Oriented Programming, Finland, Springer-Verlag LNCS 1241, 1997, pp [16] Krinke, J. Identify Similar Code with Program Dependence Graphs., Proc. 8 th Working Conf. on Reverse Engineering, Stuttgart, Germany, October 2001, pp [17] Li, Z., Lu, S., Myagmar, S., Zhou, Y. CP-Miner: Finding Copy-Paste and Related Bugs in Large-Scale Software Code, IEEE Transactions on Software Engineering, 32(3), pp [18] Mayrand J., Leblanc C. and Merlo E. Experiment on the Automatic Detection of Function Clones in a Software System using Metrics, Proc. International Conference on Software Maintenance (ICSM 96), 1996, pp [19] Rieger, M., Ducasse, S. and Lanza, M. Insights into System-Wide Code Duplication, Proc. 11 th Working Conf. on Re-verse Engineering (WCRE 04), 2004, pp [20] Tairas, R., Gray, J. and Baxter, I. Visualisation of clone detection results, Proc. OOPSLA Workshop on Eclipse Technology exchange, Portland, Oct. 2006, pp [21] Ueda, Y., Kamiya, T., Kusumoto, S. and Inoue, K. Gemini: Maintenance Support Environment based on Code Clone Analysis, Proc. 8 th IEEE Symp. on Software Metrics, 2002, pp [22] XVCL (XML-based Variant Configuration Language) [23] Yang, J. and Jarzabek, S. Applying a Generative Technique for Enhanced Reuse on J2EE Platform, Proc. 4 th Int. Conf. on Generative Programming and Component Engineering, GPCE'05, Sep 29 - Oct 1, 2005, Tallinn, Estonia, pp