Detecting program changes helps maintainers to figure out the evolution of the changed program. For this, several line-based difference tools have been proposed, which extract differences between two versions of the program. Unfortunately, these tools do not provide enough support to program comprehension since a single commitment stored in a version control system contains multiple changes that are intermingled with each other. Therefore, the maintainers have to untangle them by hand. This work is troublesome and time-consuming. This paper proposes a novel mechanism that automatically detects individual program changes. For this, it restores snapshots of the program from the history of edit operations for the target source code and compares class members that result from syntax analysis for respective snapshots. In addition, the mechanism provides several options of aggregating fine-grained changes detected based on the edit history. The maintainers can select their suitable levels of summarization of program changes. The paper also shows experimental results with a running implementation of the change detection tool. Through the experiment, the detection mechanism presents various kinds of summarized information on program changes, which might facilitate maintainers' activities for program comprehension.

Change-aware development environments have recently become feasible and reasonable. These environments can automatically record fine-grained code changes on a program and allow programmers to replay the recorded changes in chronological order. However, they do not always need to replay all the code changes to investigate how a particular entity of the program has been changed. Therefore, they often skip several code changes of no interest. This skipping action is an obstacle that makes many programmers hesitate in using existing replaying tools. This paper proposes a slicing mechanism that can extract only code changes necessary to construct a particular class member of a Java program from the whole history of past code changes. In this mechanism, fine-grained code changes are represented by edit operations recorded on source code of a program. The paper also presents a running tool that implements the proposed slicing and replays its resulting slices. With this tool, programmers can avoid replaying edit operations nonessential to the construction of class members they want to understand.