ICPC
•Download as PPTX, PDF•
0 likes•389 views
The document describes a study on a software tool called CnP that aids software maintenance by tracking code that has been copied and pasted (copy-paste clones). CnP visualizes clones through color highlighting and provides two plugins, CReN and LexId, that help consistently rename identifiers within clones. A user study found that CReN and LexId helped programmers complete renaming tasks faster and with fewer errors compared to manually renaming. The clone visualization also helped with debugging and modifying clones, though it was not always used by study participants.
More Related Content
What's hot
What's hot (19)
Similar to ICPC
Similar to ICPC (20)
Recently uploaded
Recently uploaded (20)
ICPC
- 1. Aiding Software Maintenance with Copy-and-Paste Clone-Awareness Patricia Jablonski and Daqing Hou Clarkson University ~ Potsdam, NY USA Friday July 2, 2010 ~ ICPC 2010
- 2. Source code is copied and pasted for reuse and then it is modified to fit a specific task The correspondence (similarity) relationship between the clones can be useful information during modification and debugging Having to manually identify and consistently change clones can be difficult over time Cloning increases source code maintenance and can lead to undetected errors in the code Copy, Paste, and Modify
- 3. Proactive tracking of copy-and-paste clones upon creation (using abstract syntax trees) Features of CnP tested in this user study CnP clone visualization Shows the programmer where related clones are CReN identifier renaming Assists the programmer in renaming identifiers consistently within clones LexId substring renaming Assists the programmer in renaming substrings consistently within clones The CnP Software Tool
- 5. Programmers often make small modifications to pasted code (like to its identifier names and literal constants) for it to fit its task CReN is an Eclipse plug-in that uses CnP’s clone tracking and visualization, and groups instances of the same identifier within a clone All instances of the same identifier are renamed together when any one instance is edited by the programmer This helps prevent inconsistencies (errors) CReN Identifier Renaming
- 6. LexId is a separate Eclipse plug-in (part of CnP) that adds onto CReN’s functionality LexId groups and renames together common substrings between different identifiers within a clone Recall that CReN renames instances of the same whole identifier name within a clone LexId focuses on inferring the lexical patterns LexId divides identifiers into substrings (standard Java CamelCase is supported) LexId Substring Renaming
- 7. CnP Clone Visualization Hypotheses CnP’s clone visualization makes it faster for programmers to find software bugs in copied-and-pasted code than debugging manually or with other tools, when the cloning information is not fresh in their memories. CnP’s clone visualization makes it faster and less error-prone for programmers to make modifications to copied-and-pasted code than modifying without visualization, when the cloning information is not fresh in their memories. User Study – CnP Visualization
- 8. CReN Identifier Renaming Hypotheses Using CReN to rename identifier instances consistently in copied-and-pasted code is quicker than performing the same task manually or with other tools CReN prevents such inconsistent renaming errors that can happen otherwise. User Study – CReN Renaming
- 9. LexId Substring Renaming Hypotheses Using LexId to rename substring instances consistently in copied-and-pasted code is quicker than performing the same task manually or with other tools. LexId prevents such inconsistent renaming errors that can happen otherwise. User Study – LexId Renaming
- 11. Recruitment email was sent to all Clarkson University computer science and engineering undergraduate and graduate students 14 male subjects participated in the user study – 8 undergraduate, 6 graduate students Knowledge of Java and Swing were required Familiarity with IDEs, especially Eclipse, was preferred, but not necessary Subjects had different levels of prior experience and knowledge Subject Characteristics
- 12. Subjects came one at a time to a user study lab for a session between 1 and 2 hours long Subjects were presented with background about the problems of copy-and-paste clones, the 3 CnP features, and other tools Subjects were shown the source code and graphical Paint program used for the tasks Subjects were encouraged to work efficiently (with accuracy and speed) Subjects were recorded with video/audio Study Procedure
- 14. Before starting a task, the current task’s description was read and questions answered The subject could use the instruction sheet, a sheet with the identifier names labeled, and an online Swing tutorial during the study The Paint program for the task was run for the subject to see the task’s problem visually The subjects were told whether the current task involved CnP, and if not, about some other (optional) tools that they could use Task Descriptions
- 15. Similar tasks were paired together Task 1 & 2 – debugging, CnP clone visualization Task 3 & 4 – modification, CnP clone visualization Task 5 & 6 – renaming, CReN identifier renaming Task 7 & 8 – renaming, LexId substring renaming Subjects completed each of the 8 tasks once, alternating with and without the tool Odd-numbered subjects performed the first task in each pair with tool support, while even-numbered subjects performed the first tasks without the tool Tasks were paired rather than pairing the subjects Task Pairs
- 16. For subjects who had CnP support for a task, the clone groups were already highlighted with different colors in PaintWindow.java 5 clone groups considered copy and pastes: Red (r), green (g), blue (b), thickness (t) slider/panel Color panel and thickness panel Tool panel and clear/undo panel The UI constraints for each of the four panels The declaration of the two change listeners Subjects without CnP could use CCFinderX CnP Visualization Tasks
- 17. Task 1: Moving the blue slider does not change the pixel color. Debugging Tasks – Task 1 rSlider should be bSlider (on line 120)
- 18. Task 2: Moving the thickness slider does not change the pixel thickness. Debugging Tasks – Task 2 colorChangeListener should be thicknessChangeListener (on line 142)
- 19. Task 3: Add a titled border to colorPanel and to thicknessPanel. Modification Tasks – Task 3
- 20. Modification Tasks – Task 3
- 21. Task 4: Add color to the label of each color slider – red, green, and blue. Modification Tasks – Task 4
- 22. Modification Tasks – Task 4
- 23. Task 5: Rename colorPanel to thicknessPanel and rPanel to tPanel within the clone. Renaming Tasks (with CReN)
- 24. Task 6: Rename toolPanel to clearUndoPanel, pencilButton to clearButton, and eraserButton to undoButton within the clone. Renaming Tasks (with CReN)
- 25. Task 7: Rename rPanel to gPanel and rSlider to gSlider in the green slider clone (shown), and rPanel to bPanel and rSlider to bSlider in the blue slider clone. Renaming Tasks (with LexId)
- 26. Task 8: Rename bPanel to tPanel and bSlider to tSlider in the thickness slider clone. Renaming Tasks (with LexId)
- 27. Results – Time per Task The time (in minutes) to complete each pair of tasks.
- 28. Results – Time per Task Statistical hypothesis testing on the paired time data.
- 29. Results – Solution Correctness Correct states when running the program or when finished.
- 30. Results – Completion Method Number of subjects who used each location and inspection method for debugging and modification tasks.
- 31. Results – Completion Method Number of times each renaming method was used for renaming tasks.
- 32. Confounding factors for clone visualization Clone visualization is not forced on the user Subjects would have produced correct solutions to Task 3 if they had made use of cloning information Varying levels of subjects’ prior experience Threats to validity Some subjects had more knowledge/experience Tasks close to real-world GUI programming tasks Tool design Need to further improve the clone visualization Need to tell programmers exactly what is renamed Discussion
- 33. Clone visualization Some other tools use colored bars, markers, rulers Many others use separate views that programmers need to invoke or relatively complex graphs that they need to learn and understand Related tools Find & Replace Rename Refactoring Linked Renaming Rename Type Refactoring Vaci Related Work
- 34. User study tested CnP’s clone visualization and renaming features (CReN and LexId) CReN and LexId both perform statistically quicker than without them on similar tasks CReN and LexId both help prevent inconsistent renaming that otherwise happens Since CnP’s clone visualization was not forced on the user, some subjects may not have used it even when it was present during a particular debugging or modification task Cloning information may be more useful to people without significant prior knowledge/experience Conclusion
- 35. Questions?
Editor's Notes
- CnP clone visualization has distinction between clone groups and the clone origin and its subsequent pastes. All clones within the same group are colored with the same color of bars (for example, yellow). A different clone group’s bars could be colored red, etc. Each paste’s bar has a slightly darker shade of the color (for example, the origin’s bar is a regular shade of yellow, the first paste has a little darker yellow color for its bar, the second paste has a slightly more grayed yellow bar, etc.).
- 7 subjects had a long-time knowledge of both Java and Swing 3 subjects had a long-time knowledge of Java but only recent knowledge of Swing 4 remaining subjects reported having relatively recent knowledge of both Java and Swing (having learned them within the past two years) 7 subjects said that they have written at least 10,000 lines of Java code since they have known the language The other 7 gave a lower estimate when describing their Java programming experience- 10 subjects said that the software that they have written in Java were for courses only = “considered themselves to be knowledgeable about Java and Swing, but not regular users of them”- The other 4 subjects had worked on software projects in industry = “considered themselves to be ‘very experienced’”
- We presented background information to the subject about what code clones are and problems that can result from copy-and-paste programming. We then gave the subject a short introduction to our software tool’s three features, explaining how they address the mentioned copy-paste-modify issues, and told them about the other tools that they could use during the experiment when they were doing a task without CnP. We told the subjects that all tasks in the user study would be performed in one file (PaintWindow.java, which is 264 lines of code).- As an incentive to work as efficiently as possible, we told everyone that we would provide extra compensation to the four subjects who completed the eight tasks with the best accuracy and speed. Each task had a time limit that the subject was told about in advance.- We asked that they talk aloud while completing each task, so that we could better understand their thoughts and actions, and we had them announce when they were finished with the task. The subjects were told that their session was being recorded with TechSmith’s Morae software, which captured the activity on the computer screen and recorded the user with video and audio.
- Each pair of tasks (Tasks 1 & 2, Tasks 3 & 4, Tasks 5 & 6, and Tasks 7 & 8) was designed to be very similar in terms of difficulty and effort, yet different enough that there would not be a learning effect.- Although odd-numbered subjects always performed the first task in each task pair with tool support, this is not a problem with the experiment design and would not create bias because each task category was unique and unrelated to the previously done pairs.- Our subject sample size was 14, not 7. We paired similar tasks together rather than pairing subjects together for comparison to avoid introducing this variable into the study. The same subject’s performance on one of the tasks in a pair with the tool present was compared with his own performance on the other task in the pair without the tool available, hence we did not need to take into account the subjects’ expertise and experience when establishing the pairs.
- The UI constraints for each panel: the tool panel, the color panel, the thickness panel, and the clear/undo panel The declaration of the thickness change listener and the declaration of the color change listener- Using a clone detection tool or manual searching are traditional ways to find the clones without CnP. We chose CCFinderX because its algorithm is token-based, which is known to have high recall. CCFinderX also has a graphical interface, is available for free download, and is easy to install and use. We preinstalled it, showed the subjects how to use it, and provided written instructions that they could refer back to.
- Find & Replace in Eclipse allows the programmer to find specified text and replace it with another text. Find & Replace is simply a text-based search and has no knowledge of the structure of the program. It does not infer intent and must be initially requested by the programmer. In addition, Find & Replace is not limited to within a clone code fragment, so the programmer must know where renaming in the clone begins and ends and manually replace only those instances.- The Rename refactoring allows the programmer to rename various program elements. As such, binding is an important condition for it to work, which is not necessary for CReN. Furthermore, Rename is automatically applied to the whole project instead of a clone.- Linked Renaming allows the programmer to rename identifiers within a file scope, while CReN can be applied across multiple files. Furthermore, Linked Renaming neither works with code that does not parse nor renames identifiers only within a clone as CReN does.- Eclipse’s Rename Type Refactoring feature allows similarly named variables and methods within a class to be updated when the class name is renamed. For example, when a class “Bar” is renamed to class “Foo”, the “fBar” variable and “createBar” method (both of type “Bar”) within the class are renamed to “fFoo” and “createFoo” if the programmer checks this option when invoking refactoring in Eclipse. LexId can do this same thing, but does not limit itself to the class scope.- Vaci detects contexts and identifiers, and then forms translation classes that can be used to detect an inconsistency in naming. It uses version control system information to track identifiers over software versions. Although Vaci can detect possible renaming inconsistencies, CReN and LexId instead proactively prevent the inconsistencies from occurring at all.