Softwaresysteme sind komplexe immaterielle Systeme mit einer Vielzahl von Bestandteilen und Beziehungen. Um den Aufbau, die Funktionsweise und die Entwicklung von Softwaresystemen besser zu verstehen, eignen sich Softwarevisualisierungen, welche die abstrakte Datengrundlage in eine visuelle Repräsentation übertragen. Auf Grund der Masse und der Komplexität der in der Visualisierung enthaltenen Informationen, kommt es schnell zur Unübersichtlichkeit, was sich negativ auf den Prozess des Verstehens auswirkt. Zur Beherrschung der Komplexität muss der Betrachter daher die Gesamtheit zuerst in mehrere Perspektiven unterteilen, um diese anschließend gezielt nach verschiedenen Aspekten untersuchen zu können. Die dafür benötigten Interaktionsmöglichkeiten sind Gegenstand der Untersuchungen in dieser Arbeit, wobei im Wesentlichen Visualisierungen der Struktur von Software als Ausgangspunkt genutzt werden. Insbesondere wird der Frage nachgegangen, wie die Interaktion gestaltet werden kann, damit der Benutzer ein möglichst umfassendes Verständnis der Struktur erlangt. Zur Umsetzung der theoretischen Erkenntnisse wird ein Prototyp vorgestellt, der automatisiert aus den Strukturinformationen eines Ecore-Modells eine interaktive dreidimensionale Softwarevisualisierung der Struktur im freien standardisierten Format Extensible 3D generiert. Der Prozess der Visualisierung wird dabei durch Werkzeuge des openArchitectureWare-Frameworks realisiert. Zur Integration in den Entwicklungsprozess ist der Prototyp in ein Plugin für Eclipse eingebettet.

Die Softwarevisualisierung nutzt unter anderem dreidimensionale Modelle zur Darstellung von Software. Diese Modelle erlauben die Exploration von Softwareprojekten durch Interaktion mit einer 3D-Szene. Das Institut für Wirtschaftsinformatik der Universität Leipzig entwickelt im Rahmen der Forschung auf diesem Gebiet das Programm Getaviz, welches verschiedene Funktionen umfasst, um die Analyse von Software zu unterstützen. Im Rahmen der vorliegenden Arbeit wird eine Erweiterung zur Darstellung der Testabdeckung in Getaviz entwickelt. Hierzu werden Techniken aus dem Usability Engineering verwendet, um eine hohe Benutzungsfreundlichkeit zu erreichen. Insbesondere findet der Entwicklungsprozess in mehreren Iterationen statt, in denen das Design durch eine formative Untersuchung bewertet und für die nächste Iteration angepasst wird. Der Entwicklungsprozess sowie der finale Stand sind außerdem auf GitHub (https://github.com/AaronSil/Getaviz/tree/development) als Repository dokumentiert.:Inhaltsverzeichnis Abbildungsverzeichnis Tabellenverzeichnis 1 Einleitung 1.1 Motivation und Problemstellung 1.2 Ziel und Aufbau der Arbeit 2 Grundlagen 2.1 Softwarevisualisierung 2.2 Getaviz 2.3 Testabdeckung 2.4 Testabdeckung in der Softwarevisualisierung 2.5 Usability-Engineering 3 Konzeption des Prototyps 3.1 Vorgehen 3.2 Anforderungsanalyse 3.2.1 Eingrenzung des Umfangs 3.2.2 Funktionale Anforderungen 3.2.3 Nicht-funktionale Anforderungen 3.2.4 Zielstellung für die erste Iteration 4 Konzeption der Evaluation 4.1 Untersuchungsgegenstand und -design 4.2 Methoden 4.3 Testdesign 4.3.1 Vorbereitung und Aufbau 4.3.2 Durchführung 4.3.3 Nachbereitung 5 Durchführung der Evaluation 5.1 Stichprobenzusammensetzung 5.2 Erste Iteration 5.3 Zweite Iteration 5.4 Dritte Iteration 6 Implementierung des Prototyps 6.1 Erweiterung des Generators 6.2 Sourcecode-Controller 6.3 Treemap 6.4 Sphären 6.5 Color-Coding 6.6 Farb-Controller 6.7 Experiment-Popover-Fenster 6.8 Tooltip-Controller 6.9 Package Explorer 6.10 Sonstige Features 7 Untersuchungsergebnisse 7.1 Kategorisierung der Ergebnisse 7.2 Interpretation der Ergebnisse 7.3 Diskussion 8 Fazit und Ausblick Literaturverzeichnis Selbstständigkeitserklärung Anhang Anhang 1: Fragebogen Anhang 2: Interviewleitfaden Anhang 3: Eckdaten der Iterationen Anhang 4: Szenarien Anhang 5: Implementierung des Prototyps Anhang 6: Auswertung - Fragebogen Anhang 7: Auswertung - Findings

Die Stadtmetapher des Softwarevisualisierungsgenerators der Forschungsgruppe Softwarevisualisierung in 3D und virtueller Realität soll um zwei Varianten der Darstellung von Klassenattributen und -methoden erweitert werden. Nach Evaluation bereits existierender Stadtmetaphern mit dem Fokus auf die Anwendbarkeit verschiedener visualisierter Aspekte auf die Stadtmetapher des Softwarevisualisierungsgenerators folgt eine Definition der zu implementierenden Varianten zur Darstellung der Klassenbestandteile. Als Basis einer der umzusetzenden Varianten dient dabei der Ansatz von CodeCity, der die Zerlegung des Gebäudes in sogenannte Bricks vorsieht. Eine zweite Variante der Visualisierung soll das Gebäude ebenfalls in Segmente gliedern, jedoch konsequent aufeinander stapeln. Zusätzlich werden Zugriffsmodifikatoren beziehungsweise Methodentypen farblich verschieden gekennzeichnet sowie eine Sortierung der Elemente nach mehreren Kriterien vorgenommen.:Gliederung (I) Abbildungsverzeichnis (III) Tabellenverzeichnis (V) Verzeichnis der Listings (VI) Abkürzungsverzeichnis (VII) 1 Einleitung (1) 1.1 Motivation und Problemstellung (1) 1.2 Zielstellung der Arbeit (1) 1.3 Methodisches Vorgehen (2) 1.4 Aufbau der Arbeit (2) 2 Darstellungen von Klassenbestandteilen (3) 2.1 Softwarevisualisierung (3) 2.2 Die Stadtmetapher (5) 2.3 Methoden als Gebäude (6) 2.3.1 ImSoVision (6) 2.3.2 Vizz3d - Unified City (7) 2.3.3 Software World (9) 2.4 Klassen als Gebäude (15) 2.4.1 EvoSpaces / Software City (15) 2.4.2 SArF Map (17) 2.4.3 Verso (18) 2.5 Gebäude als ambivalente Glyphe (20) 2.5.1 CodeMetropolis (20) 2.5.2 CodeCity (22) 3 Erweiterung des Softwarevisualisierungsgenerators (24) 3.1 Der Softwarevisualisierungsgenerator (24) 3.2 Anforderungsanalyse der Teilelemente (25) 3.3 Erweiterung des Metamodells (26) 3.4 Modell-Transformationen und Modifikationen (28) 3.4.1 Modell-zu-Modell-Transformation der Backsteine (28) 3.4.2 Modell-zu-Modell-Transformation der Paneele (30) 3.4.3 Modellmodifikationen (31) 3.4.4 Modell-zu Text-Transformation (36) 3.5 Evaluation der Varianten (38) 4 Zusammenfassung und Ausblick (42) Anhang – Erläuterungen zur Konfiguration und Ausführung (VIII) Literatur- und Quellenverzeichnis (XI) Selbstständigkeitserklärung (XV)

Animationen bieten verschiedene Möglichkeiten, um Sachverhalte in der Softwarevisualisierung darzustellen. Die vielfältigen Ausprägungen von Animationen können eingesetzt werden, um die verschiedenen Hauptaspekte von Software, Struktur, Verhalten und Historie, zu visualisieren. Um ihren Einsatz für die Zwecke der Softwarevisualisierung zu optimieren, ist es aber essenziell, die verschiedenen möglichen Formen, deren Einsatzzwecke und ihre Eigenschaften im Bezug auf die Wahrnehmung von Menschen zu untersuchen. Die vorliegende Arbeit untersucht diese Aspekte und bedient sich dabei verschiedener Forschungsmethoden. Zu diesen Forschungsmethoden gehören eine Literaturstudie, die prototypische Implementierung von Werkzeugen und ein Experiment. Die Literaturstudie zeigt den aktuellen Stand der Forschung im Bezug auf die Verwendung und den Einsatzzweck von Animationen im Bereich der Softwarevisualisierung. Die prototypische Implementierung von Werkzeugen wird genutzt, um verschiedene Phasen des Visualisierungsprozesses zu unterstützen. So werden Techniken dargestellt, die es ermöglichen, Informationen über die Struktur, das Verhalten und die Historie von Ruby-Programmen zu gewinnen und diese in geeigneter Weise bereitzustellen. Des Weiteren wird ein Framework vorgestellt, mit dem es möglich ist, durch deklarative Angabe von Ereignissen, verschiedene Arten von Animationen in X3D- und X3DOM-Szenen auszulösen. Um die Visualisierungen zu erzeugen, stellt die Arbeit die Erweiterung eines Generators für Softwarevisualisierungen vor. Diese Erweiterung ermöglicht es, aus den extrahierten Informationen animierte Softwarevisualisierungen für alle drei Hauptaspekte von Software zu erzeugen. Im Rahmen der vorliegenden Arbeit wird ein Experiment zur Untersuchung der Effektivität und Effizienz von Animationen in Softwarevisualisierungen durchgeführt. Um die Durchführung dieses und anderer Experimente im Bereich der Softwarevisualisierung zu erleichtern, werden verschiedene Methoden und Hilfsmittel vorgestellt. Dazu gehört auch ein prototypisch im Rahmen der Arbeit implementierter Evaluationsserver, der Versuchsleiter für vergleichende Visualisierungsexperimente in den Bereichen Planung, Durchführung und Auswertung unterstützen kann. Dieser kommt im Rahmen der vorliegenden Arbeit bei der Durchführung eines Experiments zum Einsatz, das für die Aspekte Struktur, Verhalten und Historie jeweils eine statische mit einer animierten Softwarevisualisierung hinsichtlich der Aspekte Fehlerrate, Zeitbedarf zur Beantwortung von Fragen und von den Probanden durchgeführte Interaktion vergleicht.

In C-Quellcode wird der C-Präprozessor häufig verwendet, um ein Softwaresystem für verschiedene Ausführungsumgebungen und Varianten zu konfigurieren. Anweisungen zur bedingten Kompilierung ermöglichen es, dass Quellcodeteile bei der Verarbeitung durch den Präprozessor ein- oder ausgeblendet werden. Dies erzeugt verschiedene Varianten der Software, erschwert jedoch die Lesbarkeit und Wartung des Quellcodes. Insbesondere die Auswirkungen einzelner Makrodefinitionen sind oft nicht einfach zu ermitteln. In dieser Arbeit soll der Frage nachgegangen werden, wie das Verständnis des Quellcodes und der Auswirkungen von Makrodefinitionen mithilfe von Softwarevisualisierung unterstützt werden kann. Dazu wird eine bestehende Visualisierungsmetapher an den Anwendungsfall angepasst. Anschließend folgt der Entwurf eines Verarbeitungsprozesses, um den Quellcode automatisiert darstellen zu können. Mithilfe eines Prototyps wird die Machbarkeit gezeigt.:Inhaltsverzeichnis Inhaltsverzeichnis I Abbildungsverzeichnis III Tabellenverzeichnis IV Listings V Abkürzungsverzeichnis VI 1 Einleitung 1 1.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1.2 Zielsetzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.3 Vorgehensweise . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 1.4 Stand der Forschung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 2 Grundlagen 6 2.1 Die Programmiersprache C . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.1.1 Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 2.1.2 Wichtige Sprachelemente . . . . . . . . . . . . . . . . . . . . . . 7 2.1.3 Der C-Präprozessor . . . . . . . . . . . . . . . . . . . . . . . . . . 8 2.1.4 Ablauf der Kompilierung . . . . . . . . . . . . . . . . . . . . . . . 10 2.2 Softwarevisualisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 2.2.1 Eigenschaften und Ziele . . . . . . . . . . . . . . . . . . . . . . . 11 2.2.2 Getaviz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2.3 Graphdatenbanken und Neo4j . . . . . . . . . . . . . . . . . . . . . . . . 14 3 Konzeption 17 3.1 Anwendungsfall . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 3.2 Extraktion der benötigten Informationen . . . . . . . . . . . . . . . . . . . 19 3.2.1 Sprachmittel im C-Standard . . . . . . . . . . . . . . . . . . . . . 19 3.2.2 Variabilität in C-Quellcode . . . . . . . . . . . . . . . . . . . . . . 21 3.2.3 Extraktion von Variabilität . . . . . . . . . . . . . . . . . . . . . . 25 3.2.4 Entwurf eines Graphmodells für C-Quellcode . . . . . . . . . . . . 29 3.3 Visualisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 3.3.1 Analyse bestehender Metaphern . . . . . . . . . . . . . . . . . . . 34 3.3.2 Darstellung der Variabilität in der Benutzungsoberfläche . . . . . . 37 3.4 Überblick über den Generierungsprozess . . . . . . . . . . . . . . . . . . . 39 4 Implementierung 42 4.1 Vorverarbeitung des Quellcodes . . . . . . . . . . . . . . . . . . . . . . . 42 4.1.1 Anpassung von TypeChef . . . . . . . . . . . . . . . . . . . . . . 42 4.1.2 Aufbau des Abstract Syntax Tree . . . . . . . . . . . . . . . . . . 43 4.2 Das jQAssistant-Plugin . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 4.2.1 Aufbau und grundsätzliche Funktionsweise . . . . . . . . . . . . . 44 4.2.2 Wichtige Descriptors und Relations . . . . . . . . . . . . . . . . . 46 4.2.3 Verarbeitung der XML-Datei . . . . . . . . . . . . . . . . . . . . . 46 4.2.4 Parsen der Bedingungen . . . . . . . . . . . . . . . . . . . . . . . 49II 4.3 Anpassung von Getaviz . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 4.4 Erweiterung der graphischen Oberfläche . . . . . . . . . . . . . . . . . . . 52 4.5 Test und Evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 5 Fazit 55 5.1 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 5.2 Kritische Würdigung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 5.3 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 A Übersicht über die Sprachmittel im C-Standard VII Literaturverzeichnis XI

Softwarevisualisierung unterstützt Entwickler und weitere Stakeholder von Computerprogrammen beim Verständnis von und der Kommunikation über Software. Software-Produktlinien zeigen durch die Nutzung von organisierter Variabilität im Quellcode gegenüber klassischer Software eine erhöhte Komplexität auf und profitieren aus diesem Grund besonders von Visualisierungen. In dieser Arbeit soll auf Basis der Visualisierungssoftware Getaviz ein Prototyp eines Visualisierungswerkzeugs für Featurelokalisierungen in Software-Produktlinien entwickelt werden. Dabei soll gezeigt werden, ob Getaviz als Grundlage geeignet ist und wie durch das Hilfsmittel einer Benutzungsoberfläche zusätzliche Informationen bereitgestellt werden können. Das Ergebnis attestiert die technische Machbarkeit und zeigt eine konkrete Umsetzung einer Visualisierungslösung für Software-Produktlinien, die durch eine Benutzungsoberfläche die Interaktion mit der Visualisierung ermöglicht.

Das Ziel dieser Arbeit ist es, Methoden zur schnelleren Erstellung und Speicherung von Teilsichten prozessierter X3D-Dateien zu entwickeln. Point and Click und Drag and Drop werden als Interaktionsmethoden zur Erstellung der Teilsichten vorgestellt und anhand bestehender, wissenschaftlicher Studien verglichen. Drag and Drop wird als die günstigere Methode umgesetzt. Die Implementierung ermöglicht sowohl das Ziehen von Einträgen der integrierten Listenansicht als auch der Fragmente der Visualisierung.:Abbildungsverzeichnis Quellcode-Listings Abkürzungsverzeichnis 1 Einleitung 1.1 Motivation 1.2 Zielstellung 1.3 Aufbau der Arbeit 2 Stand der Forschung 2.1 Grundlagen der Softwarevisualisierung 2.1.1 Einordnung 2.1.2 Definition 2.1.3 Aufgaben 2.1.4 Metaphern 2.1.5 Generierung einer Softwarevisualisierung 2.2 Darstellung der Softwarevisualisierung und Interaktion 2.2.1 Die Oberfläche 2.2.2 Die Recursive Disc Metaphor 3 Technische Grundlagen 3.1 HTML5 3.2 JavaScript 3.3 Drag and Drop 3.4 Point and Click 3.5 Verwaltung der Struktur der Visualisierung durch zTree 4 Erzeugung von Teilsichten 4.1 Definition einer Teilsicht 4.2 Vergleich von Drag and Drop und Point and Click 4.3 Implementierung für den Package Explorer 4.4 Implementierung für die Visualisierung 5 Speichern und Laden von Teilsichten 5.1 Grundlagen zur Implementierung 5.2 Speichern einer Teilsicht 5.3 Laden einer Teilsicht 6 Fazit und Ausblick Literaturverzeichnis

Die Einarbeitung in ein bestehendes Softwareprojekt ist mit einigen Schwierigkeiten behaftet. Um das Verständnis über Aufbau und Funktionsweise von Software zu fördern, werden die zugrundeliegenden, meist abstrakten Daten oft mithilfe einer Metapher in eine verständlichere visuelle Form übertragen. Ein entscheidender Bereich, der sich dieser Aufgabe annimmt, ist die Softwarevisualisierung. Mithilfe der Visualisierung bietet sich ein Überblick auf ein gesamtes Softwareprojekt. Zur Verbesserung des Verständnisses ist es auch notwendig, einen direkten Bezug vom abstrakten Quellcode zu den Bestandteilen der Visualisierung zu ziehen. Dadurch können erkannte Auffälligkeiten sofort am Quellcode untersucht werden. Ziel dieser Arbeit war es, den Quellcode in die Visualisierung zu integrieren und damit diesen Bezug herzustellen. Zusätzlich wurde die Darstellung des Quellcodes durch das Einbinden des Frameworks Prism mit einem Syntax-Highlighting versehen. Das Syntax-Highlighting erhöht dessen Lesbarkeit und bietet dem Benutzer damit eine bessere Orientierung. Der Bezug wurde gleichzeitig dadurch gestärkt, dass der Benutzer mit dem Quellcode auf die gleiche Weise interagieren kann, wie mit den Elementen innerhalb der Visualisierung.:Gliederung Abbildungsverzeichnis Quellcode-Listing Tabellenverzeichnis Abkürzungsverzeichnis 1 Einleitung 1.1 Motivation 1.2 Zielstellung 1.3 Aufbau der Arbeit 2 Stand der Forschung 2.1 Softwarevisualisierung 2.2 Der Generator 2.3 Extensible 3D und X3DOM 2.4 Die Oberfläche 3 Theoretische Grundlagen 3.1 Anzeigen des Quellcodes 3.2 Der HTML-Standard 3.3 JavaScript 3.4 Reguläre Ausdrücke 4 Syntax-Highlighter 4.1 Syntax-Highlighting 4.2 Evaluation eines Syntax-Highlighters 4.3 Prism 5 Erweiterung des Prototyps 5.1 Funktionsweise 5.2 Implementierung 5.2.1 Architektur der Oberfläche 5.2.2 Laden und Anzeigen des Quellcodes 5.2.3 Hervorheben des selektierten Elements 5.2.4 Interaktion mit dem Quellcode 5.2.5 Darstellung im Extra-Fenster 6 Fazit und Ausblick Literaturverzeichnis

Der Forschungsbereich der generativen Softwarevisualisierung beschäftigt sich mit dem Problem, automatisch individuell konfigurierte Visualisierungen von Software zu erzeugen, um deren Struktur und Funktionsweise durch visuelle Mittel einfacher verständlich zu machen. Für die Darstellung werden sogenannte Metaphern verwen- det, die es, anhand bekannter Anhaltspunkte, ermöglichen sich in der entsprechend visualisierten Software zurechtzufinden. Dies ist bereits für verschiedene objektorientierte Programmiersprachen möglich, jedoch nicht für solche, die einige Spezialfälle beinhalten, wie beispielsweise ABAP. Das Ziel dieser Arbeit ist es, in einer methodischen Vorgehensweise einen prototy- pischen Generator, der eine entsprechend angepasste City-Metapher einer ABAP- Software erzeugen kann, zu entwickeln. Dabei wurde die Programmiersprache an sich, aber auch die typische Arbeitsumgebung des ABAP-Entwicklers analysiert, um den praktischen Nutzen der entstandenen Metapher zu optimieren.

Der Schwerpunkt dieser Arbeit liegt auf der Konzeption sowie prototypischen Implementierung eines web-basierten Dashboards zur Softwarevisualisierung. Ziel der Arbeit ist es, ein Dashboard zu entwickeln, welches Informationen eines Softwareprojekts dynamisch aus einer Graphdatenbank visualisiert und Projekteitern aufgabenbezogen zur Entscheidungsunterstützung darstellt. Derzeit existiert keine Softwarelösung, die diesen Anforderungen vollumfänglich gerecht wird. Es existieren jedoch bereits Bibliotheken und Softwaresysteme, welche Teilaspekte zu einer möglichen Gesamtlösung beitragen können. Diese können bei der prototypischen Implementierung von Nutzen sein und müssen daher beachtet werden. Um die Ziele der Arbeit zu erreichen, werden verschiedene Forschungsmethoden angewandt. Es wird eine Literaturrecherche durchgeführt, mit dem Ziel, typische Aufgaben von Projektleitern im Bereich Software Engineering zu identifizieren. Um die vom Dashboard zu unterstützenden Aufgaben ableiten zu können, werden außerdem verschiedene existierende Dashboard-Werkzeuge analysiert. Mithilfe der gewonnenen Ergebnisse wird das Dashboard konzipiert und prototypisch implementiert. Durch eine Fallstudie anhand von Open-Source-Projekten wird das Dashboard abschließend evaluiert.:1 Einleitung 1.1 Motivation und Problemstellung 1.2 Zielstellung 1.3 Methodisches Vorgehen 2 Grundlagen 2.1 Softwarevisualisierung 2.2 jQAssistant 2.3 Neo4j 2.4 Webanwendungen und web-basierte Frameworks 2.5 D3.js 2.6 Dashboards 3 Konzeption 3.1 Mission Statement 3.2 Architekturziele 3.3 Kontextabgrenzung 3.3.1 Fachlicher Kontext 3.3.1.1 Literaturrecherche zu typischen Aufgaben von Projektleitern 3.3.1.2 Analyse existierender Dashboard-Werkzeuge 3.3.1.3 Use-Case-Diagramm der zu unterstützenden Aufgaben 3.3.1.4 Mockups der Benutzungsschnittstelle 3.3.2 Technischer Kontext 3.4 Randbedingungen 3.4.1 Technische Randbedingungen 3.4.2 Organisatorische Randbedingungen 3.5 Risiken und technische Schulden 3.6 Entwurfsentscheidungen 3.6.1 Auswahl des Neo4j-Treibers 3.6.2 Vergleich existierender Webframeworks 3.6.2.1 Angular 3.6.2.2 Backbone.js 3.6.2.3 Ember.js 3.6.2.4 Vue.js 3.6.2.5 React 3.7 Lösungsstrategie 4 Implementierung 4.1 Implementierungskomponenten 4.1.1 CoreUI 4.1.2 Nivo 4.2 Dashboard 4.2.1 Startseite 4.2.2 Einstellungen 4.2.3 Benutzerdefinierte Abfragen 4.2.4 Visualisierungskomponenten 4.2.4.1 Struktur 4.2.4.2 Dateitypen 4.2.4.3 Abhängigkeiten 4.2.4.4 Aktivitäten 4.2.4.5 Wissensverteilung 4.2.4.6 Hotspots 4.2.4.7 Statische Quellcodeanalyse 4.2.4.8 Testabdeckung 4.2.4.9 Erstellung 4.3 Eingesetzte Werkzeuge 4.3.1 Entwicklung und Test 4.3.1.1 Jest 4.3.1.2 Codecov 4.3.1.3 Travis CI 4.3.1.4 Prettier 4.3.1.5 Docker 4.3.2 Installation und Wartung 5 Evaluation 6 Fazit und Ausblick