Enhancing Software Development Techniques via Copy Codebases
MetadataShow full item record
Most software development tasks require developers to interact with multiple versions of a codebase directly or through an analysis tool. Consider a developer, Alice, who wants to implement a new feature. To ensure that her changes are of high quality, Alice might want to continuously analyze the current codebase. To make the changes fast but with confidence, Alice might use automated transformations such as refactorings. While using these transformations Alice might want to analyze the likely future codebases, which these transformations would generate, to make more informed decisions. Finally, to pinpoint the cause of any regression defect, Alice might want to analyze historical codebases e.g., binary search the development history. Unfortunately, developers' interaction with multiple codebases is limited since modern integrated development environments (IDEs) maintain one version of the codebase with limited development history. First, it is difficult to run an arbitrary analysis continuously with development since most analyses assume that the code under analysis does not change for the duration of the analysis. Second, having access to one codebase makes it impossible to analyze likely future codebases continuously with development since the modifications done to generate the future codebases conflict with development. Third, maintaining a limited development history makes it difficult to analyze historical codebases e.g., to extract information from the development history. This dissertation introduces a novel technique, Codebase Replication, which creates and incrementally maintains a copy of the developer's codebase. Our thesis is that having access to copy codebases improves developers' interaction with the current codebase, likely future codebases, and historical codebases. Improving the developer's interaction with codebases will simplify software engineering tasks and reduce developer mistakes. Continuous analyses — analyses that run in the background after each developer edit and update their result unobtrusively — improve developers' interaction with the current codebase. Having access to an in-sync copy codebase simplifies the design and implementation of continuous analyses. We introduce Codebase Analysis, which lets developers run an existing analysis continuously with development without worrying about conflicting edits. We prototyped Solstice, an implementation of Codebase Analysis for the Eclipse IDE. Solstice has negligible (<2.5 ms) synchronization delay and IDE overhead. Using Solstice, we implemented four continuous analyses. Each of these analyses required less than 800 lines of Java code and 20 hours of development time, on average. Our case study with Solstice continuous testing shows that developers like continuous feedback and they like continuous analysis tools built with Solstice. Impure analyses — analyses that modify the source code before computing results — improve developers' interaction with likely future codebases. We show how Codebase Analysis supports impure analyses and guarantees that these analyses' modifications will not conflict with development. We introduce a new impure analysis that augments IDE recommendations with their speculatively computed consequences. We created a prototype implementation, Quick Fix Scout, in the context of Eclipse Quick Fixes. Our experiment shows that Quick Fix Scout can speed up compilation error removal tasks by 10%. Being able to access the development history in the granularity that is the most optimal for the underlying software engineering task improves developers' interaction with historical codebases. We introduce Codebase Manipulation, a history manipulation framework that lets developers access the history at different granularities for different tasks. We prototyped Bread, an implementation of Codebase Manipulation for the Eclipse IDE. Bread automatically creates a fine-grained development history by recording each edit. We show that Codebase Manipulation can express a range of development tasks by providing algorithms for three common information-retrieval-based tasks. Using Bread, we prototyped two of these algorithms. Our initial experience with these tools suggests that Bread can simplify information-retrieval-based software engineering tasks.