Combining user-interaction and automation to evolve source code

Software evolves. Developers and programmers manifest the needs that arise due to evolving software by making changes to the source code. While developers make such changes, reusing old code and rewriting existing code are inevitable. There are many challenges that a developer faces when manually reusing old code or rewriting existing code. Software tools and program transformation systems aid such reuse or rewriting of program source code. But there are significantly occuring development tasks that are hard to accomplish manually, where the current state-of-the-art tools are still not able to adequately automate these tasks. In this thesis, we discuss some of these unexplored challenges that a developer faces while reusing and rewriting program source code, the significance of such challenges, the existing automation support for these challenges and how we can improve upon them. Modern software development relies on code reuse, which software developers typically realize through hand-written abstractions, such as functions, methods, or classes. However, such abstractions can be challenging to develop and maintain. An alternative form of reuse is \emph{copy-paste-modify}, in which developers explicitly duplicate source code to adapt the duplicate for a new purpose. Copy-pasted code results in code clones, i.e., groups of code fragments that are similar to each other. Past research strongly suggests that copy-paste-modify is a popular technique among software developers. In this paper, we perform a small user study that shows that copy-paste-modify can be substantially faster to use than manual abstraction. One might propose that software developers should forego hand-written abstractions in favour of copying and pasting. However, empirical evidence also shows that copy-paste-modify complicates software maintenance and increases the frequency of bugs. Furthermore, the developers in an informal poll we conducted strongly preferred to read code written using abstractions. To address the concern around copy-paste-modify, we propose a tool that merges similar pieces of code and automatically creates suitable abstractions. Our tool allows developers to get the best of both worlds: easy reuse together with custom abstractions. Because different kinds of abstractions may be beneficial in different contexts, our tool provides multiple abstraction mechanisms, which we selected based on a study of popular open-source repositories. To demonstrate the feasibility of our approach, we have designed and implemented a prototype merging tool for C++ and evaluated our tool on a number of clones exhibiting some variation, i.e near clones, in popular Open Source packages. We observed that maintainers find our algorithmically created abstractions to be largely preferable to existing duplicated code. Rewriting existing code can be considered as a form of program transformation, where a program in one form is transformed into a program in another form. One significant form of program transformation is data representation migration that involves changing the type of a particular data structure, and then updating all of the operations that has a control or data dependence on that data structure according to the new type. Changing the data representation can provide benefits such as improving efficiency and improving the quality of the computed results. Performing such a transformation is challenging, because it requires applying data-type specific changes to code fragments that may be widely scattered throughout the source code connected by dataflow dependencies. Refactoring systems are typically sensitive to dataflow dependencies, but are not programmable with respect to the features of particular data types. Existing program transformation languages provide the needed flexibility, but do not concisely support reasoning about dataflow dependencies. To address the needs of data representation migration, we propose a new approach to program transformation that relies on a notion of semantic dependency: every transformation step propagates the transformation process onward to code that somehow depends on the transformed code. Our approach provides a declarative transformation specification language, for expressing type-specific transformation rules. We further provide scoped rules, a mechanism for guiding rule application, and tags, a device for simple program analysis within our framework, to enable more powerful program transformations. We have implemented a prototype transformation system based on these ideas for C and C++ code and evaluate it against three example specifications, including vectorization, transformation of integers to big integers, and transformation of array-of-structs data types to struct-of-arrays format. Our evaluation shows that our approach can improve program performance and the precision of the computed results, and that it scales to programs of at least 3700 lines.Bei dieser Arbeit werden wir uns einige unerforschte Herausforderungen ansehen, die bei der Entwicklung von Analysen und Transformationen involviert sind, die die Evolution von Quellcode unterstützen. Wir behandeln deren Wichtigkeit bei Nutzerstudien und ähnlicher Arbeit. Wir erstellen Programmanalysen und transformationsbasierte Herangehensweisen, um diese Herausforderungen zu meistern. Wir erstellen Prototyp-Tools aus diesen Herangehensweisen. Wir schätzen die Effektivität, Verwendbarkeit und Machbarkeit unserer Herangehensweise ein. Wir berichten über Ergebnisse und Erkenntnisse. Unser Hauptfokus liegt auf dem Hinzufügen/ Modifizieren von Funktionen und auf Softwareanpassung als Wartung, da diese zentral für die Entwicklung von Software sind. Fehlerreparatur fällt unter die Kategorie Korrekturwartung, die, wie wir uns erinnern, nicht als Entwicklungswartung kategorisiert ist. Die Kernhypothese unserer These ist es, dass Softwareentwicklungsaufgaben kompliziert genug sind, dass sie automatisiert werden müssen. Aber die Tools, die für diese Automatisierung erstellt wurden, sollten im Wesentlichen den Entwicklern helfen, und daher müssen die Entwickler das letzte Wort darin haben, wie die Entwicklung vor sich geht. Wir schlagen vor, zu einem Programmanalyse- und Transformations-Framework zu gelangen, das der Softwareentwicklung hilft, indem eine Automatisierung entwickelt wird, die durch Nutzereingabe gesteuert wird. Insbesondere machen uns zwei Aufgaben Sorgen, die während der Softwareentwicklung entstehen, und die erst noch gründlich erforscht werden müssen. Aufräumen von Copy-Paste-Klonen. Das Hinzufügen von Features geschieht durch das Einführen neuer Funktionalität. Neue Funktionalität ist manchmal der existierenden Funktionalität sehr ähnlich und Entwickler verwenden bestehende Funktionalität auch erneut wieder. Wir sehen uns zwei markante Methoden an, wie man Code auf diese Art wiederverwendet, d. h. Abstraktion von Funktionen und Copy-paste-modify (Änderung der Copy-Paste?). Wir führen Nutzerstudien durch, um diese Methoden der Wiederverwendung zu vergleichen und unsere Hypothese zu errichten, dass copy-paste-modify einfacher ist, aber dass Abstraktion bevorzugt wird. Wir schlagen vor, dass Tool-Support Code-Klone Aufräumen muss, die von der copy-paste-modify Methode herrühren, indem gut gewählte Abstraktionen verwendet werden. Migration der Datendarstellung. Softwareanpassung involviert typischerweise Code-Transformationen. Es existiert eine Unzahl von Tools und Frameworks, die Entwicklern mit automatisierten Code-Transformationen helfen. Die beiden Hauptkategorien von Tools, die bei der Code-Transformation helfen, sind Refactoring Tools (Restrukturierungstools) und Transformation Languages (Transformationssprachen). Refactoring Tools bieten einfache Transformationen wie Umbenenn-Variablen oder Extraktionsmethoden. Refactoring Tools haben den Vorteil, dass Sie die Dependencies bei der Transformation an einem Ort des Codes nachverfolgen und die Änderung in alle Dependencies übernommen werden, wodurch es dem Nutzer erlaubt wird, die Transformationen selektiv anzuwenden. Aber Refactoring Tools haben ein spezifisches vorbestimmtes Set an Transformationen. Eine Alternative zu solchen Transformation sind Transformation Languages, die anpassbare Regeln unterstützen, in denen der Entwickler so viele Transformationsregeln erstellen kann, wie er möchte und diese auf seinen Code anwenden kann, um Featureanpassungen zu unterstützen. Aktuelle Transformation Languages unterstützen keine selektive Anwendung von Regeln. Wir stellen die Hypothese auf, dass eine spezifische Art der Softwareanpassung, d. h. der Migration von Software von einer Datendarstellung zu einer anderen, sowohl die Einstellbarkeit (Customizability) von Transformation Languages als auch eine interaktive, selektive Transformation des Refactoring erfordert. Wir schlagen vor, dass Tool-Support erforderlich ist, um beide diese Funktionen zu unterstützen. In den folgenden Unterabschnitten besprechen wird die Wichtigkeit und unseren Beitrag zu den oben erwähnten Herausforderungen im Detail. Wenn Softwareentwickler neue Funktionen zu ihrer Software hinzufügen, entdecken sie oft, dass eine neue Funktion einer alten sehr ähnlich ist. Der Entwickler steht dann vor einer Entscheidung: Entweder er führt eine (möglicherweise komplexe) Abstraktion in den bestehenden, funktionierenden Code, oder er kopiert (Copy Paste) den bestehenden Code und modifiziert das Ergebnis. Die Einführung einer Abstraktion erzeugt kleineren, besser wartbaren Code, aber sie verändert die bestehende Funktionalität auf der Betriebsebene (operational level), was das Risiko beinhält ungewollt semantische Änderungen einzuführen