Term Project

All students are expected to perform a term project for the class, which may be done either individually, or in a small group (larger groups have larger expectations). The project involves a significant investigation into some aspect of software evolution. The goal of the project is to permit a more in-depth exploration of software evolution than is possible from just the in-class disucssions.

The output from the project is a written report, appx. 7-20 pages in length (whatever length is appropriate for adequately describing the project), written in the form of a research paper.

The Software Engineering lab at UCSC, in cooperation with Michael Godfrey and Lijie Zou at Univ. of Waterloo, have developed Kenyon, a useful infrastructure for performing research on software evolution. Kenyon automates many of the steps involved in performing software evolution research by automatically extracting software from a software configuration management repository into the filesystem, where a fact extractor (such as a static dependence analyzer) can be run over it, and the results stored in a consistent schema in a Hibernate database. Student projects are highly encouraged to use Kenyon to perform some kind of software evolution analysis of a software project. Potential analysis ideas include:

• Procedure/method signature evolution. Analyze a software project to determine how the signatures of procedures/methods have changed over time, and characterize the kinds of changes that have been made. Questions to answer include: how often are variables renamed? How often are variable types modified? How often are variables added/removed?
• Entity mapping analysis. A difficult problem in software evolution analysis is maintaining the identity of a procedure across a procedure/method rename. Ideally, even if a procedure has been renamed, you would like the analysis to recognize that the procedure under the new and old names is the same. Making the problem more complex, procedures can be renamed and modified in the same SCM transaction, and hence a simple source code text comparison doesn't fully address the problem.
• Clone analysis. A related problem to entity mapping is that of code clone detection, finding duplicate chunks of source code within a larger system. This project involves implementing a code clone detection algorithm, and then using it to analyze the history of a project for code clones, and their evolution.
• Design pattern evolution. Software design patterns are structural idioms used in the development of software systems. Many design patterns have qualities that should allow them to accommodate a wide variety of change over time. However, to date there has not been any analysis of how design patterns actually do evolve over time. This project involves analyzing software design patterns over time, and characterizing how they change.
• Find "dead" or "magic" code regions. In large software systems, there are sometimes sections of code that are critical to the behavior of the software, but which are imperfectly understood by current project personnel. Such code is often intentionally not modified by project personnel as a risk reduction approach; if the poorly understood code is not modified, it is less likely to cause bugs that cannot be fixed. However, to accommodate changes to the software, often code surrounding the dead code is modified. Hence, we would expect dead code regions to be characterized by a section of code that is unmodified for many releases, surrounded by code that does change fairly frequently. The goal of this project is to automatically identify dead code regions, and determine what kinds of changes are made to accommodate this region of static code. People working on this project can leverage work-to-date on the IVA project (this project is in some respects the inverse of IVA).
• Evolution of UML diagrams. UML diagrams are now commonly used to represent the design of software systems, and have been used long enough that it may be possible to observe the effects of long-term change on these diagrams (and hence on the software system it describes). The goal of this project is to develop techniques to observe and characterize change in UML diagrams over time.
• Visualization of evolution. Good visualizations of the evolution of software projects are an open area of research. The goal of this project is to develop a novel visualization of the evolution of software over time.

Substantial instruction on Kenyon will be provided in-class, and students will have access to the developers of Kenyon for detailed assistance.

Project work will have three deliverables. You will need to decide on a project topic and project partners early in the quarter. A rough draft of your project report will be due later in the quarter, with the final report due the final week. Consult the syllabus for exact due dates.

Last modified: 12/20/2004