As pull-based software development has become popular, collecting pull requests is frequent in many empiri-cal studies. Although researchers can utilize publicly available datasets, the on-demand collection of PR data is indispensable to compensate for missing information or obtain the latest in-formation. Unfortunately, PR data collected through the GitHub API sometimes has a deficiency in which parts of the data are lost. This data loss would be trouble for researchers in their data analysis. To reveal what data related to PRs tends to be lost during their collections using GitHub API, we conducted a study with 12,118 pull requests in six repositories of OSS projects on GitHub. In the study, we clarified the PR data that needs to be obtained through the GitHub API by defining their entities as features and attributes. We also collected data losses and classified them by checking the lost attributes based on exception reports triggered during PR collection. The collected data losses were categorized into seven. The paper shows our study results that more than half of the PRs (about 53%) involve data loss in total, which may be surprising for many researchers. The paper also discusses the possible causes of data losses, which helps researchers filter out deficient PRs during the collection.

Automated program repair (APR) is expected to reduce manual debugging effort in software development. However, its tools have seldom been adopted in real-world software development. One of the reasons for this is likely that the tools frequently output repaired programs with low readability, which many developers are unwilling to accept. To reveal a situation where such programs are output during repairing, we experimented with an APR tool based on a genetic algorithm to fix bugs in an open-source Java project. Experimental results show that many acceptable programs are output in a relatively early stage of the repair process. Additionally, increasing the number of variants generated per generation is beneficial for obtaining a greater number of acceptable programs with the same repair time. These findings help developers use the APR tool efficiently, avoiding needlessly lengthening the repair time.

To uncover situations where an APR tool based on a genetic algorithm effectively outputs fixed programs acceptable to developers, we conducted a preliminary experiment with seven bugs in an open source Java project. Experimental results for 5,475 fixed programs show that acceptable programs are likely to be output in the early generations.

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.

Behavior preservation often bothers programmers in refactoring. This poster paper proposes a new approach that tames the behavior preservation by introducing the concept of a frame. A frame in refactoring defines stakeholder's individual concerns about the refactored code. Frame-based refactoring preserves the observable behavior within a particular frame. Therefore, it helps programmers distinguish the behavioral changes that they should observe from those that they can ignore.

Modern version control systems facilitate concurrent work in software development by providing a mechanism to merge revisions that are independently modified by multiple programmers. However, merge conflicts might emerge due to concurrent modifications, and their resolution might require the programmers to scrutinize every modification in the revisions. This paper presents a tool that can alleviate this cumbersome task of merging conflicting revisions. Our tool exploits the fine-grained edit operation history of Java source code and extracts only the edit operations that affect the revision of a particular class member. By just replaying the extracted edit operations, it helps programmers detect merge conflicts between class members within the two revisions and understand the modifications of the conflicting class members. Moreover, it can artificially merge two snapshots that appear during the evolution of the two revisions and show the programmers a unique artificial snapshot that is consistent with both the merged snapshots. By replaying the fine-grained edits that cause merge conflicts and showing the apparent snapshots with no conflicts as hints of the merged revision, the tool reduces the burden of inspecting the code changes behind the conflicts and reconciling the conflicting revisions.

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.

Security is still a serious issue for many software systems. Even if software has the correct security features in its initial implementation, recurring modifications (e.g., refactoring) could deteriorate such features. We found several refactoring transformations which might make existing software vulnerable, and organized them as security-aware refactoring. This refactoring presents information useful for programmers to determine if they could accept or should cancel it, based on a criterion assessing the changes of accessibility of data stored in the target program. To demonstrate the feasibility of the proposed refactoring, we have developed a prototype of an automated refactoring tool detecting possible code vulnerabilities regarding the accessibility criterion. The new refactoring provides programmers with an environment in which they safely improve the maintainability of existing software without missing the intrusion of unexpected security vulnerabilities.

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.

Refactoring makes existing source code more understandable and reusable without changing observable behavior. Therefore, applying refactorings to existing source code and reversing the effects of past refactorings are inseparable from tool support to software development and maintenance. This paper proposes a powerful undo mechanism that uses a chain of past refactorings for each source file and determines which refactoring is undoable by monitoring the last refactoring in every chain. The proposed undo mechanism can make an undesired refactoring accurately undone although the refactoring has affected multiple source files. Moreover, it permits a programmer to compatibly execute operations of refactoring undo and editorial undo/redo without the limitation of manual edit of files. A running implementation of the mechanism has been integrated into our developed refactoring browser.

This paper briefly describes the theme and goals of the WebSDE Workshop on ASE'2006. This workshop emphasizes next-generation software development environments inspired by Web2.0 technologies and seeks to explore ways of automated support to software development in the Web2.0 era.

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.

The paper presents a mechanism for automatically generating new classes from classes existing in a library by using their modification histories. To generate classes that are likely to meet a programmer's requirements and that are consistent with the existing classes, we propose three actors: a Specifier, a Finder, and an integrator. The Specifier records the history of modifications between methods with the same interface of a parent class and its heir. If the required method is not defined in the existing class which a programmer is referring to, the Finder retrieves classes similar to the referenced class and the Integrator applies the past modifications of similar classes to the referenced class. Classes are determined to be similar, based on their positions in a class hierarchy tree. Both the Specifier and Integrator are achieved by using a method integration algorithm based on object oriented bounded program slicing and class dependence graph matching. This mechanism enables programmers to reuse classes with little or no modification, and thus, easily create object oriented programs.

While refactoring makes frameworks more reusable, it is complex to do by hand.This paper presents a mechanism that automatically refactors methods in object-oriented frameworks by using weighted dependence graphs, whose edges are weighted based on the modification histories of the methods.To find the appropriate boundary between frozen spots and hot spots in the methods, the value of the weight varies based on whether the dependence in the original methods has been repeatedly preserved or destroyed in the methods of applications created by programmers.The mechanism constructs both template methods that contain the invariant dependence and hook methods that are separated by eliminating the variant dependence.The new template methods and hook methods tailored to each programmer save him/her from writing superfluous code when reusing a framework.Experimental results show a reduction rate of up to 22% in the number of statements a programmer has to write when creating several applications; this percentage is double that achievable by a conventional refactoring technique.

Presents a mechanism for automatically generating new classes from classes existing in a user library by using their modification histories. To generate classes that are likely to meet user requirements and are consistent with the existing classes, we propose three actors-Specifier, Finder and Integrator-that perform this mechanism. Specifier records the history of modifications between methods with the same interface of a parent class and its heir. If the required method is not defined in the existing class which a user is referring to, Finder retrieves classes similar to the referenced class and Integrator applies the past modifications of similar classes to the referenced class. Classes are determined to be similar based on their positions in a class hierarchy tree. Both Specifier and Integrator are achieved by a method integration algorithm based on object-oriented bounded program slicing and class dependence graph matching. The mechanism enables users to reuse new classes with little or no modification, and thus easily create object-oriented programs.

The paper presents software components, which are called "active components", with a mechanism for automatically and dynamically changing their codes. To create new programs, users must frequently modify software components because conventional components are fixed in libraries and user requirements are continuously changing. The active components can modify themselves into source codes that meet new requirements and that correspond to the characteristics of their existing libraries. The new mechanism provides two kinds of changes by: i) decomposing the functions of active components based on program slicing, and ii) partially exchanging their functions with modification histories in the libraries based on labeled graph matching for program dependence graphs. With this mechanism, the active components do not require many user modifications to create new programs, and not all components need to be prepared in the libraries whose characteristics are not specified. The paper also demonstrates the effects of this mechanism by describing experimental results obtained with the active components.