Interacting with code : observations, models, and tools for usable software development environments

Krämer, Jan-Peter; Borchers, Jan Oliver; Lichter, Horst; Brandt, Joel

doi:10.18154/RWTH-2017-00620

Interacting with code : observations, models, and tools for usable software development environments = Interaktion mit Programmquellcode : Beobachtungen, Modelle und Werkzeuge für benutzbare Softwareentwicklungswerkzeuge

Krämer, Jan-Peter^RWTH*

2016 & 2017

Verantwortlichkeitsangabevorgelegt von Diplom-Informatiker Jan-Peter Krämer

ImpressumAachen 2016

Umfang1 Online-Ressource (xxi, 179 Seiten) : Illustrationen, Diagramme

Dissertation, RWTH Aachen University, 2016

Veröffentlicht auf dem Publikationsserver der RWTH Aachen University 2017

Genehmigende Fakultät
Fak01

Hauptberichter/Gutachter
Borchers, Jan Oliver (Thesis advisor) ; Brandt, Joel (Thesis advisor) ; Lichter, Horst (Thesis advisor)

Tag der mündlichen Prüfung/Habilitation
2016-11-23

Online
URN: urn:nbn:de:hbz:82-rwth-2017-006207
DOI: 10.18154/RWTH-2017-00620
URL: http://publications.rwth-aachen.de/record/682068/files/682068.pdf
URL: http://publications.rwth-aachen.de/record/682068/files/682068.pdf?subformat=pdfa

Einrichtungen

Inhaltliche Beschreibung (Schlagwörter)
source code (frei) ; empirical research (frei) ; software development tools (frei) ; software engineering (frei) ; user studies (frei)

Thematische Einordnung (Klassifikation)
DDC: 004

Kurzfassung
Das Verstehen von Programmquellcode ist eine der essentiellen Aktivitäten von Softwareentwicklern. Es ist nicht nur erforderlich um Wartungsarbeiten an existierender Software durchzuführen, sondern auch, wenn bereits existierender Quellcode wiederverwendet werden soll. Viele Aspekte einer Softwareentwicklungsumgebung, wie z.B. Software-basierte Werkzeuge, Frameworks, oder Dokumentation, sind so gestaltet, dass sie das Verständnis von Software unterstützen. Die Gestaltung dieser Aspekte hilft jedoch Softwareentwicklern nicht nur ihre existierenden Strategien um Software zu verstehen effizienter anzuwenden, sondern ändert welche Strategien sie nutzen. In dieser Arbeit werden wir untersuchen wie genau die Gestaltung der Entwicklungsumgebung die Strategien zum Verständnis von Quellcode beeinflusst. Unsere Ergebnisse erweitern das Wissen über die kognitiven Modelle von Softwareentwicklern und können die Gestaltung zukünftiger Entwicklungswerkzeuge prägen. Zuerst vergleichen wir zwei Frameworks zur programmatischen Erstellung von Animationen. Wir zeigen, dass eine der wichtigsten Variablen in der Gestaltung von Frameworks die Wahl des Abstraktionsniveaus ist. Einerseits können Abstraktionen helfen, die Möglichkeiten die das Framework bietet mit den Problemlösungsstrategien der Entwickler in Deckung zu bringen, andererseits können Abstraktionen zu Fehlvorstellungen über das Verhalten des Frameworks führen, wenn konzeptionelle Details durch die Abstraktion versteckt werden. Im nächsten Teil untersuchen wir, ob Entwickler motiviert werden können mehr Dokumentation und Komponententests zu erstellen, wenn die Interaktion für diese Aufgabe vereinfacht wird. Unser Interaktionsdesign propagiert, Dokumentation und Komponententests als Teil des Edit-Test-Edit-Kreislaufs zu schreiben. Um Änderungen an diesen Dokumenten automatisiert vorzuschlagen, nutzen wir Laufzeitinformationen, die während den manuellen Tests, die Entwickler als Teil dieses Kreislaufs ausführen, gespeichert werden. Wir fanden heraus, dass, um diesem Interaktionsdesign zu Erfolg zu verhelfen, das resultierende Werkzeug den Entwicklern nicht nur bei der Erstellung von Dokumentation und Komponententests helfen muss, sondern darüber hinaus auch kurzfristig nützlich sein muss. Im dritten Projekt untersuchten wir, wie sich die Nutzung von Werkzeugen zur Call Graph Navigation ändert, wenn diese Werkzeuge so gestaltet sind, dass sie vor der Nutzung nicht erst konfiguriert werden müssen und sie Informationen kontinuierlich anzeigen. Wir stellen zunächst zwei Werkzeuge vor, die diese Gestaltungsideen implementieren, und vergleichen danach diese Werkzeuge mit anderen typischen Methoden zur Navigation entlang des Call Graphen. Entwickler, die unsere Werkzeuge nutzten, konnten Wartungsaufgaben schneller lösen, weil sie eine effizientere Strategie zur Navigation anwendeten. Wir stellen außerdem eine neue Analysetechnik vor, die es uns erlaubte die Unterscheide zwischen Navigationsstrategien quantitativ zu beschreiben. Zuletzt analysieren wir den Effekt, den Live Coding Umgebungen, also Entwicklungsumgebungen die die Applikation nach jeder Änderung automatisch ausführen um dem Entwickler Informationen über das Laufzeitverhalten zeigen zu können, auf das Verhalten der Entwickler haben. Wir fanden heraus, dass Entwickler, die solche Werkzeuge nutzen, ihre Fehler schneller beseitigten und häufiger zwischen dem Schreiben von neuem Quellcode und dem Korrigieren von existierendem Quellcode wechseln. Dieses Verhalten erlaubt es manche Programmierarbeiten auch schneller zu erledigen. Um Live Coding Werkzeuge auch unter realen Bedingungen einsetzen zu können, präsentieren wir eine Interaktionstechnik, die es erlaubt Live Coding spontan für kurze Teile des Quellcodes zu nutzen. Zu diesen Teilen des Quellcodes wird automatisch ein Kontext generiert, der repräsentiert wie sich der Code verhalten würde, wenn er als Teil der kompletten Applikation ausgeführt würde.

Comprehending source code is an essential activity for software developers. It is not only required for software maintenance but also when developers want to reuse existing code. Many facilities in the development environment, such as software-based development tools, frameworks, or documentation, are designed to support software comprehension. Changing the design of these facilities does not only allow developers to perform their comprehension strategies more efficiently, but also changes the strategies they use. In this thesis, we aim to understand in more depth how the design of the development environment changes comprehension strategies. Our results contribute to the corpus of knowledge of the cognitive models of software developers, and can influence the design of future development tools.First, we compare two frameworks to program animations. We show that one of the most important design variables for frameworks is the level of abstraction. On the one hand, abstractions can help to align the capabilities offered by a framework with the developers' high-level programming plans, on the other hand, abstractions can lead to misconceptions about the behavior of the framework when conceptual details are hidden. Second, we study whether developers can be encouraged to write more documentation and unit tests by improving the interaction design for these tasks. Our interaction design promotes writing documentation and unit tests as part of the edit-test-edit cycle, and leverages runtime information from manual tests performed by developers to suggest updates to these documents. We found that for this interaction design to be successful, it is crucial to not only simplify the authoring task but to also provide near-term value for the developer.Third, we explore in which way the use of call graph navigation tools changes when these tools are designed to not require any setup and to provide information continuously. We present two tools that implement this design, and we compare these tools to existing call graph navigation facilities. Developers using our tools could solve maintenance tasks faster, because they adapted a more effective navigation strategy. We also present a novel analysis method that we used to quantitatively describe the differences in navigation behavior.Last, we analyzed the effect of live coding environments on the developers' behavior. These environments execute the application after every change automatically in order to present information about its runtime behavior. We find that developers using such tools fix bugs they introduced faster, because they switch between writing new code and debugging existing code more frequently. This behavior can reduce the task completion time for certain coding tasks. To be able to use live coding in real-world scenarios, we present an interaction technique that allows to use live coding on-demand for short code snippets. These snippets are automatically contextualized to simulate how the code snippet would behave if it was executed as part of the complete application.

OpenAccess:
PDF PDF (PDFA)
(additional files)