Any successful software system continuously evolves in response to ever-changing requirements. Developers regularly add new or adjust existing features, fix bugs, tune performance, etc. Thus, code change is the heart of software development.Nevertheless, the traditional programming environments and toolkits treat changes as a by-product of software evolution. First, most of the tools do not offer direct access to the history of code changes and do not allow to browse or manipulate these changes. Second, different tools represent changes differently and thus, do not understand each other. For example, text editors treat changes to the edited document at the character level, Version Control Systems (VCS) track changes as text line differences in the corresponding file, and refactoring engines represent changes with high-level descriptors. Third, the most common, textual representation of changes is inappropriate for a developer, who reasons in terms of program entities rather than individual characters or text lines. Hence, the current tools' support for the major activity of a developer, code changing, is limited.To address these limitations, we propose to make change the first-class citizen and place it at the center of a programming environment. In our approach, we represent any change, from low-level code edits up to high-level automated refactorings, as a program transformation. Consequently, we express a version of a program as a sequence of such program transformations. We developed CodingTracker, an infrastructure that captures all changes that affect a program's code. CodingTracker uniformly represents the raw captured changes as operations on the corresponding Abstract Syntax Tree (AST) nodes. These AST node operations are the lowest level of program transformations that serve as building blocks for higher level transformations. Also, CodingTracker implements a replayer that enables a developer to browse and replay the captured code changes. We employed CodingTracker to perform a field study and answered several important code evolution research questions that could not be answered without such infrastructure.As part of CodingTracker, we implemented an algorithm that infers refactorings from the AST node operations. Refactorings are high-level program transformations that improve the underlying code's design without affecting its behavior. Our algorithm infers refactorings from continuous code changes, and thus, it could be applied on-line, assisting a developer with the refactoring process. Moreover, our refactoring inference algorithm enabled us to perform a field study that compared the practice of manual and automated refactorings. Our findings reveal new facts about the refactoring practice that benefit code evolution researchers, tool builders, and developers.Finally, we augmented CodingTracker with an algorithm that helps identify high-level program transformations without prior knowledge of how these transformations look. Our novel algorithm employs data mining techniques to detect frequent code change patterns. We applied our algorithm on the data collected in our field study and showed that it is scalable and effective. Analyzing the detected code change patterns, we identified ten kinds of popular program transformations. Our results shed light on how developers evolve their code as well as enable tool builders to automate common program transformations.
PDF
download
878987797
028-85220240
