Oliver Moseler

• Today, almost every modern computing device is equipped with multicore processors capable of efficient concurrent and parallel execution of threads. This processor feature can be leveraged by concurrent programming, which is a challenge for software developers for two reasons: first, it introduces a paradigm shift that requires a new way of thinking. Second, it can lead to issues that are unique to concurrent programs due to the non-deterministic, interleaved execution of threads. Consequently, the debugging of concurrency and related performance issues is a rather difficult and often tedious task. Developers still lack on thread-aware programming tools that facilitate the understanding of concurrent programs. Ideally, these tools should be part of their daily working environment, which typically includes an Integrated Development Environment (IDE). In particular, the way source code is visually presented in traditional source-code editors does not convey much information on whether the source code is executed concurrently or in parallel in the first place. With this dissertation, we pursue the main goal of facilitating and supporting the understanding and debugging of concurrent programs. To this end, we formulate and utilize a visualization paradigm that particularly includes the display of interactive glyph-based visualizations embedded in the source-code editor close to their corresponding artifacts (in-situ). To facilitate the implementation of visualizations that comply with our paradigm as plugins for IDEs, we designed, implemented and evaluated a programming framework called CodeSparks. After presenting the design goals and the architecture of the framework, we demonstrate its versatility with a total of fourteen plugins realized by different developers using the CodeSparks framework (CodeSparks plugins). With focus group interviews, we empirically investigated how developers of the CodeSparks plugins experienced working with the framework. Based on the plugins, deliberate design decisions and the interview results, we discuss to what extent we achieved our design goals. We found that the framework is largely target programming-language independent and that it supports the development of plugins for a wide range of source-code-related tasks while hiding most of the details of the underlying plugin development API. In addition, we applied our visualization paradigm to thread-related runtime data from concurrent programs to foster the awareness of source code being executed concurrently or in parallel. As a result, we developed and designed two in-situ thread visualizations, namely ThreadRadar and ThreadFork, with the latter building on the former. Both thread visualizations are based on a debugging approach, which combines statistical profiling, thread-aware runtime metrics, clustering of threads on the basis of these metrics, and finally interactive glyph-based in-situ visualizations. To address scalability issues of the ThreadRadar in terms of space required and the number of displayable thread clusters, we designed a revised thread visualization. This revision also involved the question of how many thread clusters k should be computed in the first place. To this end, we conducted experiments with the clustering of threads for artifacts from a corpus of concurrent Java programs that include real-world Java applications and concurrency bugs. We found that the maximum k on the one hand and the optimal k according to four cluster validation indices on the other hand rarely exceed three. However, occasionally thread clusterings with k > 3 are available and also optimal. Consequently, we revised both the clustering strategy and the visualization as parts of our debugging approach, which resulted in the ThreadFork visualization. Both in-situ thread visualizations, including their additional features that support the exploration of the thread data, are implemented in a tool called CodeSparks-JPT, i.e., as a CodeSparks plugin for IntelliJ IDEA. With various empirical studies, including anecdotal usage scenarios, a usability test, web surveys, hands-on sessions, questionnaires and interviews, we investigated quality aspects of the in-situ thread visualizations and their corresponding tools. First, by a demonstration study, we illustrated the usefulness of the ThreadRadar visualization in investigating and fixing concurrency bugs and a performance bug. This was confirmed by a subsequent usability test and interview, which also provided formative feedback. Second, we investigated the interpretability and readability of the ThreadFork glyphs as well as the effectiveness of the ThreadFork visualization through anonymous web surveys. While we have found that the ThreadFork glyphs are correctly interpreted and readable, it remains unproven that the ThreadFork visualization effectively facilitates understanding the dynamic behavior of threads that concurrently executed portions of source code. Moreover, the overall usability of CodeSparks-JPT is perceived as "OK, but not acceptable" as the tool has issues with its learnability and memorability. However, all other usability aspects of CodeSparks-JPT that were examined are perceived as "above average" or "good". Our work supports software-engineering researchers and practitioners in flexibly and swiftly developing novel glyph-based visualizations that are embedded in the source-code editor. Moreover, we provide in-situ thread visualizations that foster the awareness of source code being executed concurrently or in parallel. These in-situ thread visualizations can, for instance, be adapted, extended and used to analyze other use cases or to replicate the results. Through empirical studies, we have gradually shaped the design of the in-situ thread visualizations through data-driven decisions, and evaluated several quality aspects of the in-situ thread visualizations and the corresponding tools for their utility in understanding and debugging concurrent programs.
• Heutzutage ist fast jedes moderne Computergerät mit Multicore-Prozessoren ausgestattet, die eine effiziente nebenläufige und parallele Ausführung von Threads ermöglichen. Diese Prozessoreigenschaft kann durch nebenläufige Programmierung genutzt werden, was für Softwareentwicklerinnen und Softwareentwickler aus zwei Gründen eine Herausforderung darstellt: Erstens stellt sie einen Paradigmenwechsel dar, der eine neue Denkweise erfordert. Zweitens kann es zu Problemen kommen, die aufgrund der nicht-deterministischen, ineinander verzahnten Ausführung von Threads nur bei nebenläufigen Programmen auftreten. Folglich ist das Debugging von Nebenläufigkeit und damit verbundenen Performance-Problemen eine ziemlich schwierige und oft langwierige Aufgabe. Softwareentwickelnden fehlt es immer noch an Thread-sensitiven Programmierwerkzeugen, die das Verstehen von nebenläufigen Programmen erleichtern. Idealerweise sollten diese Werkzeuge Teil ihrer täglichen Arbeitsumgebung sein, zu der in der Regel eine integrierte Entwicklungsumgebung (IDE) gehört. Insbesondere die Art und Weise, wie der Quellcode in herkömmlichen Quellcode-Editoren visuell dargestellt wird, vermittelt kaum Informationen darüber, ob der Quellcode überhaupt parallel oder nebenläufig ausgeführt wird. Mit dieser Dissertation verfolgen wir das Hauptziel, das Verstehen und das Debuggen von nebenläufigen Programmen zu erleichtern und zu unterstützen. Zu diesem Zweck formulieren und verwenden wir ein Visualisierungsparadigma, das insbesondere die Anzeige interaktiver, glyphenbasierter Visualisierungen umfasst, die in den Quellcode-Editor eingebettet sind und in unmittelbarer Nähe der entsprechenden Artefakte platziert werden (in-situ). Um die Implementierung von Visualisierungen, die unserem Paradigma entsprechen, als Plugins für IDEs zu erleichtern, haben wir ein Programmier-Framework namens \textit{CodeSparks} entworfen, implementiert und evaluiert. Nachdem wir die Designziele und die Architektur des Frameworks vorgestellt haben, demonstrieren wir seine Vielseitigkeit anhand von insgesamt vierzehn Plugins, die von verschiedenen Entwicklerinnen und Entwicklern mit dem CodeSparks-Framework realisiert wurden (CodeSparks-Plugins). In Fokusgruppeninterviews haben wir empirisch untersucht, welche Erfahrungen die Entwicklerinnen und Entwickler der CodeSparks-Plugins bei der Arbeit mit dem Framework gemacht haben. Anhand der Plugins, bewussten Designentscheidungen und der Interviewergebnisse diskutieren wir, inwieweit wir unsere Designziele erreicht haben. Wir fanden heraus, dass das Framework weitgehend unabhängig von der Zielprogrammiersprache ist und dass es die Entwicklung von Plugins für ein breites Spektrum von Quellcode-bezogenen Programmieraufgaben unterstützt, während die meisten Details der zugrunde liegenden Plugin-Entwicklungs-API verborgen bleiben. Darüber hinaus haben wir unser Visualisierungsparadigma auf Thread-bezogene Laufzeitdaten von nebenläufigen Programmen angewandt, um das Bewusstsein von Quellcode zu fördern, der nebenläufig oder parallel ausgeführt wird. Infolgedessen haben wir zwei In-Situ-Thread-Visualisierungen entwickelt und gestaltet, namentlich ThreadRadar und ThreadFork, wobei letztere auf der ersteren aufbaut. Beide Thread-Visualisierungen basieren auf einem Debugging-Ansatz, der statistisches Profiling, Thread-sensitive Laufzeitmetriken, Clustering von Threads auf der Grundlage dieser Metriken und schließlich interaktive Glyphen-basierte In-situ Visualisierungen kombiniert. Um Probleme mit der Skalierbarkeit des ThreadRadars in Bezug auf den Platzbedarf und die Anzahl der darstellbaren Thread-Cluster zu lösen, haben wir eine überarbeitete Thread-Visualisierung entwickelt. Bei dieser Überarbeitung ging es auch um die Frage, wie viele Thread-Cluster k überhaupt berechnet werden sollten. Zu diesem Zweck haben wir Experimente mit dem Clustering von Threads für Artefakte aus einem Korpus von nebenläufigen Java-Programmen, welcher reale Java-Anwendungen und Nebenläufigkeitsfehler enthält, durchgeführt. Wir fanden heraus, dass das maximale k einerseits und das optimale k gemäß vier Cluster-Validierungsindizes andererseits selten drei überschreitet. Gelegentlich sind jedoch Thread-Cluster mit k > 3 verfügbar und auch optimal. Daher überarbeiteten wir sowohl die Clustering-Strategie als auch die Visualisierung als Teil unseres Debugging-Ansatzes, was zur ThreadFork-Visualisierung führte. Beide In-Situ Thread Visualisierungen, einschließlich ihrer zusätzlichen Funktionalitäten, die die Exploration der Thread-Daten unterstützen, sind in einem Werkzeug namens CodeSparks-JPT implementiert, d.h. als CodeSparks-Plugin für IntelliJ IDEA. Mit verschiedenen empirischen Studien, darunter anekdotische Nutzungsszenarien, ein Usability-Test, Webumfragen, praktische Anwendung des Werkzeugs, Fragebögen und Interviews, haben wir Qualitätsaspekte der Thread-Visualisierungen und ihrer entsprechenden Werkzeuge untersucht. Erstens haben wir in einer Demonstrationsstudie die Nützlichkeit der ThreadRadar-Visualisierung bei der Untersuchung und Behebung von Nebenläufigkeitsfehlern und einem Performance-Problem aufgezeigt. Dies wurde durch einen anschließenden Usability-Test und ein Interview bestätigt, die auch formatives Feedback lieferten. Zweitens haben wir die Interpretierbarkeit und Lesbarkeit der ThreadFork-Glyphen sowie die Effektivität der ThreadFork-Visualisierung durch anonyme Webumfragen untersucht. Während wir festgestellt haben, dass die ThreadFork-Glyphen korrekt interpretiert werden und lesbar sind, bleibt es unbewiesen, dass die ThreadFork-Visualisierung das Verstehen des dynamischen Verhaltens von Threads, die nebenläufig Teile des Quellcodes ausführen, effektiv erleichtert. Darüber hinaus wird die Usability von CodeSparks-JPT insgesamt als "OK, aber nicht akzeptabel" empfunden, da das Werkzeug Probleme mit seiner Erlernbarkeit und Einprägsamkeit hat. Alle anderen untersuchten Usability-Aspekte von CodeSparks-JPT werden jedoch als "überdurchschnittlich" oder "gut" empfunden. Unsere Arbeit unterstützt Forschende und Fachpersonen im Bereich Software-Engineering bei der flexiblen und schnellen Entwicklung neuartiger Glyphen-basierter Visualisierungen, die in den Quellcode-Editor eingebettet sind. Darüber hinaus stellen wir In-situ Thread Visualisierungen bereit, die das Bewusstsein für die nebenläufige oder parallele Ausführung von Quellcode fördern. Diese In-situ Thread Visualisierungen können beispielsweise angepasst, erweitert und zur Analyse anderer Anwendungsfälle oder zur Replikation der Ergebnisse verwendet werden. Durch empirischen Studien haben wir die Gestaltung der In-situ Thread Visualisierungen schrittweise durch datengetriebene Entscheidungen geformt und verschiedene Qualitätsaspekte der In-Situ Thread Visualisierungen und der entsprechenden Werkzeuge auf ihre Nützlichkeit für das Verstehen und das Debuggen von nebenläufigen Programmen untersucht.