Edit operation history of source code can be used to understand how the software has been developed. However, since such an edit history is enormous, it is effective to first grasp the outline of development and then look at the details, although existing tools do not well support the process. In this paper, we propose Edited Method Highlight (EMH), which extends an existing operation replay tool called OperationReplayer to support understanding of development tasks by visualizing the recorded operation history. The visualization shows the transition of edited parts (classes and methods) and specific types of operations (debugging and committing) on the timeline displayed in the replay tool. We conducted a preliminary experiment to examine whether users could share a common understanding of task outlines. The result shows they reported task kinds with similar word sets while reported time stamps of task boundaries and word sets for developed functions in each task were various. This paper also discusses several success and failure factors to reach common understanding of development tasks.

Ripple effect in the modification of software requirements should be properly analyzed, since it may cause errors of software requirements. We have already proposed a ripple effect analysis method in deletion or update of data flow requirements. In this paper, we enhance our method considering ripple effect analysis in adding new data flows requirements. Our method will be illustrated with examples.

It is very important to certify the accuracy of non-functional requirements in software development. In this paper, we focus on reliability requirements. We can correctly obtain reliability requirements from software requirements documents by using keywords related to reliability requirements. Retrieved requirements will be checked using a requirements frame model in order to verify the consistency, non-redundancy, unambiguity and completeness of these requirements. Our method will be illustrated with examples.

Recording code changes comes to be well recognized as an effective means for understanding the evolution of existing programs and making their future changes efficient. Although fine-grained textual changes of source code are worth leveraging in various situations, there is no satisfactory tool that records such changes. This paper proposes a yet another tool, called ChangeMacroRecorder, which automatically records all textual changes of source code while a programmer writes and modifies it on the Eclipse's Java editor. Its capability has been improved with respect to both the accuracy of its recording and the convenience for its use. Tool developers can easily and cheaply create their new applications that utilize recorded changes by embedding our proposed recording tool into them.

Source code comments are valuable to keep developers' explanations of code fragments. Proper comments help code readers understand the source code quickly and precisely. However, developers sometimes delete valuable comments since they do not know about the readers' knowledge and think the written comments are redundant. This paper describes a study of lost comments based on edit operation histories of source code. The experimental result shows that developers sometimes delete comments although their associated code fragments are not changed. Lost comments contain valuable descriptions that can be utilized as new data sources to support program comprehension.

This paper presents Historef, a tool for automating edit history refactoring on Eclipse IDE for Java programs. The aim of our history refactorings is to improve the understandability and/or usability of the history without changing its whole effect. Historef enables us to apply history refactorings to the recorded edit history in the middle of the source code editing process by a developer. By using our integrated tool, developers can commit the refactored edits into underlying SCM repository after applying edit history refactorings so that they are easy to manage their changes based on the performed edits.

Software visualization has become a major technique in program comprehension. Although many tools visualize the structure, behavior, and evolution of a program, they have no concern with how a tool user has understood it. Moreover, they miss the stuff the user has left through trial-and-error processes of his/her program comprehension task. This paper presents a source code visualization tool called CodeForest. It uses a forest metaphor to depict source code of Java programs. Each tree represents a class within the program and the collection of trees constitutes a three-dimensional forest. CodeForest helps a user to try a large number of combinations of mapping of software metrics on visual parameters. Moreover, it provides two new types of support: leaving notes that memorize the current understanding and insight along with visualized objects, and automatically recording a user's actions under understanding. The left notes and recorded actions might be used as historical data that would be hints accelerating the current comprehension task.

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.

This paper proposes a concept for refactoring an edit history of source code and a technique for its automation. The aim of our history refactoring is to improve the clarity and usefulness of the history without changing its overall effect. We have defined primitive history refactorings including their preconditions and procedures, and large refactorings composed of these primitives. Moreover, we have implemented a supporting tool that automates the application of history refactorings in the middle of a source code editing process. Our tool enables developers to pursue some useful applications using history refactorings such as task level commit from an entangled edit history and selective undo of past edit operations.

In current software development, code completion is necessary to enhance productivity of our programming tasks. However, how developers use code completion tools on integrated development environments is still not elucidated completely. Aiming to improve such tools, we performed an investigation in terms of code completion use. We investigated developers' operation histories on an integrated development environment and found that code completion operations inserting the same text tend to be repetitively performed in a short time period. We also propose new code completion strategies to reduce such repetitive code completion.

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.

As managing software evolution becomes more important, many methods of development support using editing operations have been proposed. However, it is still difficult to extract truly valuable information, since massiveness of recorded operations grows with the development period. In this paper, we propose a mechanism for extracting useful information on stagnation of development from huge operation history. We have implemented this mechanism as a tool, which is called OperationReplayer. The tool allows a developer to investigate detected candidates of stagnation periods and replay operations belonging to the candidate through its graphical user interface. Through exploratory case studies using the tool, we found several problematic operations that adversely affect of the developer's development process.

Understanding a program and its evolution is not satisfied only by looking at a current snapshot of its source code. Thus, a developer often examines a sequence of its snapshots stored in repositories of versioning systems, and identifies differences between two successive snapshots. Unfortunately, such differences do not represent individual changes of the source code. This paper proposes a mechanism for recording all editing operations a developer has applied to source code on an integrated development environment. The paper also shows a running implementation of the mechanism built as an Eclipse plug-in, which is called OperationRecorder. The experimental results with a small-scale program substantiate that it has a practical use from the viewpoint of its performance.

Recent integrated development environments (IDEs) have become more extensible tool platforms but it is in fact hard for non-experts to extend or customize them. This paper proposes a mechanism for adding new functionalities to existing IDEs by using two kinds of XML-based configurations. One of them defines relationships between code fragments and the other determines how these relationships are utilized. In these configurations, a user can flexibly combine two kinds of components. They encapsulate either a trigger which expresses when the added functionality is performed or an action which is actually performed due to the trigger. Therefore, the user easily attains the extension of IDEs without knowing programming techniques by only writing XML-based configurations. The experimental results with a prototype of the proposed system show the reduction of efforts to understand proprietary APIs provided by IDEs.