In der folgenden Arbeit soll ein Überblick über den aktuellen Stand der Technik bei 3D-Druckern gegeben werden. Der Fokus liegt dabei auf dem Druck von Softwarevisualisierungen. Hierfür beginnt diese Arbeit mit der Ersteinrichtung eines Druckers und dabei entstehenden Problemen und endet mit einer Werkzeugkette, welche den einfachen Druck der Visualisierungen erlaubt. Die Arbeit zielt darauf ab, die am Lehrstuhl „Softwareentwicklung“ der Universität Leipzig eingesetzten Modelle zu erklären und für den Druck nötige Anpassungen durchzuführen. Die Wahl der verwendeten Software wird jeweils erläutert. Es wird betrachtet, welche Modelle mit welchen Veränderungen druckbar sind. So soll ein Überblick über die Möglichkeiten des 3D-Drucks von Softwaremodellen gegeben werden und die Erstellung, Anpassung und der Druck solcher Modelle in Zukunft vereinfacht werden.

Das System Getaviz der Forschungsgruppe \textit{Visual Software Analytics} des Instituts für Wirtschaftsinformatik der Universität Leipzig stellt mehrere Werkzeuge zur Erzeugung und Analyse von Softwarevisualisierungen bereit. Da sich der Einsatz des Frameworks Xtext zur Generierung einer Visualisierung bezüglich Flexibilität und Speicherperformance als problematisch herausgestellt hat, wurde untersucht wie eine Ablösung dieser Technologie in Zukunft erreicht werden kann.\\ Zu diesem Zweck wurde ein Datenmodell entwickelt, welches es ermöglicht, Softwarevisualisierungsartefakte mittels Neo4j in einer Datenbank abzulegen und von dort wieder abzurufen. Der Entwurf dieses Datenmodells basiert auf einer vorangegangenen Analyse der bisher genutzten Modelle für die Metaphern City und Recursive Disk, um deren Bestandteile auf die neuen Modelle abzubilden. Um mögliche Auswirkungen einer Migration auf die Performance und Flexibilität des Transformationsprozesses untersuchen zu können, wurde anschließend das Datenmodell und der Zugriff auf die Datenbank innerhalb des Generators in Form von zusätzlichen Komponenten implementiert. Dadurch konnte erreicht werden, Transformationen ohne den Einsatz von Xtext durchzuführen. Als Eingabemodell wird ein von jQAssistant generierter Graph verwendet, der die Struktur des Softwaresystems abbildet.

Mittels Visualisierung lässt sich Software so darstellen, dass selbst für Laien ein Eindruck von einem Software-System geschaffen wird. Anti-Pattern zeigen Fehler im Design eines solchen Systems; sie zu finden und ebenfalls zu visualisieren ist eine Unterstützung zum Verbessern der Codequalität. Das Qualitätsmanagement-Werkzeug Getaviz der Forschungsgruppe Visual Software Analytics an der Universität Leipzig ermöglicht es, solche Softwarevisualisierungen leicht zu generieren, bietet aktuell aber noch nicht die Möglichkeit, Anti-Pattern im System zu finden oder anzuzeigen. In dieser Arbeit wird gezeigt, wie sich Anti-Pattern in den Daten aus Getaviz-Scans identifizieren lassen und wie sie sich mit Getaviz darstellen lassen. Um Anti-Pattern zu finden, wird eine Methodik angewendet, die nur mit Softwaremetriken arbeitet. Lücken zwischen dem Getaviz-Datensatz und den geforderten Informationen zur Erkennung werden genau beschrieben und geschlossen. Die bestehenden Visualisierungen in Getaviz werden schließlich um eine Ansicht der Anti-Pattern sowie eine Steuerung, um diese Ansicht zu bedienen, erweitert. Damit wird ein guter Eindruck gegeben, wie sich diese Methodik zum Identifizieren von Anti-Pattern in Getaviz integrieren lässt und wie sich Anti-Pattern in Getaviz anzeigen lassen.

Innovative und komplexe Informationssysteme erfordern zur Erfassung neuartige Analysewerkzeuge. Dazu dienen in der Softwarevisualisierung Modelle zur Darstellung und Interaktionstechniken zur Steuerung. Ein Teilgebiet der Interaktionstechniken sind Feedbacktechniken, die dem Benutzer Rückmeldungen auf Interaktionen liefern. In der vorliegenden Arbeit werden bestehende Feedbacktechniken eingeordnet und neue entwickelt. Anhand von drei Prototypen werden unterschiedliche Feedbacktechniken vorgestellt und implementiert. Abschließend werden die Techniken auf ihre Nützlichkeit getestet. Dazu wird eine explorative Evaluation konzipiert, durchgeführt und ausgewertet.:Gliederung Abbildungsverzeichnis Listings Tabellenverzeichnis Abkürzungsverzeichnis 1 Einleitung 1.1 Motivation und Problemstellung 1.2 Zielstellung 1.3 Aufbau der Arbeit 2 Interaktionstechniken in der Softwarevisualisierung 2.1 Softwarevisualisierung 2.2 Interaktionstechniken 2.3 Bewertung von User-Interfaces 2.4 Stand der Forschung 3 Entwicklung von Feedbacktechnologie für SV 3.1 Taxonomien für ITecs 3.2 Vorhandene ITecs in SV 3.3 Konzeption neuer Feedbacktechniken für SV 3.4 Implementierung und Funktionsweise 4 Erhebung zur Messung des Nutzens von ITecs 4.1 Theoretische Grundlagen und Methodik der Erhebung 4.1.1 Methoden zur Evaluation von Software 4.1.2 Wahl einer Evaluationsmethode 4.2 Konzeption und Versuchsaufbau 4.3 Durchführung 5 Evaluation des Nutzens von ITecs 5.1 Stichprobenbeschreibung 5.2 Auswertung, Priorisierung und Klassifikation der Ergebnisse 5.3 Interpretation 5.4 Diskussion 6 Fazit und Ausblick

Die Interaktion mit Softwarevisualisierungen liefert im Zusammenspiel mit der Darstellung den entscheidenden Beitrag beim Erlangen von Verständnis über die zugrundeliegenden Softwaresysteme und den damit verbundenen Prozessen. Denn erst durch die zielgerichtete Manipulation der Darstellung kann der Nutzer die notwendigen Erkenntnisse zur Bearbeitung seiner Aufgaben erzielen. Die im Kontext dieser Interaktion stattfindende Perzeption und Kognition stellen allerdings hohe Anforderungen an den Nutzer. Entsprechend anspruchsvoll ist es, die Softwarevisualisierung so zu gestalten, dass der Nutzer sie trotz der hohen Anforderungen akzeptiert. Dies ist auch ein Grund für die geringe Verbreitung von Softwarevisualisierungen im praktischen Einsatz ist. Um dieses Ziel zu erreichen, bedarf es der Evaluation der Interaktion hinsichtlich der Nutzerakzeptanz, was als Forschungsthema in dieser Kombination bislang nur unzureichend bearbeitet wurde. Diese Arbeit liefert sowohl einen Beitrag zur Schließung dieser Forschungslücke als auch zur Schließung der Lücke zwischen wissenschaftlicher Erforschung und dem praktischen Einsatz von Softwarevisualisierungen. Mittels Literaturrecherche wird dazu ein wissenschaftliches Modell der Interaktion mit Softwarevisualisierungen abgeleitet, welches die Nutzerakzeptanz ins Zentrum der Betrachtung stellt. Darauf aufbauend wird ein Vorgehensmodell zur Evaluation der Nutzerakzeptanz vorgestellt, welches den aktuellen Stand der Forschung zur Evaluation von Softwarevisualisierungen berücksichtigt. Die im Rahmen der vorliegenden Arbeit durchgeführte Studienreihe demonstriert die Anwendung dieses Vorgehensmodells am Szenario der Abhängigkeitsanalyse der Strukturelemente eines Softwaresystems. Im Zentrum der Untersuchung stehen die Interaktionsmöglichkeiten zur Darstellung von Beziehungen und zur Navigation innerhalb der Darstellung, welche mittels prototypischer Implementierungen in einer flexibel erweiterbaren Benutzungsschnittstelle realisiert werden. In den vier Studien der Reihe werden sowohl qualitative als auch quantitative Methoden eingesetzt, um die Nutzerakzeptanz bei der Interaktion mit zwei- und dreidimensionalen Softwarevisualisierungen zu evaluieren, womit auch ein Beitrag zur Wissensbasis über den praktischen Einsatz von Softwarevisualisierungen erzeugt wird.:1 Einleitung 1.1 Motivation 1.2 Forschungslücke 1.3 Forschungsfrage und Ziele 1.4 Einordnung und Abgrenzung 1.5 Aufbau und Vorgehen 2 Softwarevisualisierung 2.1 Grundlagen 2.2 Eigenschaften 2.3 Visual Analytics 2.4 Einsatz in der Praxis 3 Darstellung 3.1 Grundlagen 3.2 Generative Softwarevisualisierung 3.3 Getaviz 3.4 Evaluation 4 Interaktion 4.1 Human-Computer-Interaction 4.2 Interaktion mit Visualisierungen 4.3 Interaktionstechniken 4.4 Navigation im 3D-Raum 4.5 Evaluation 5 Modell der Interaktion mit Softwarevisualisierungen 5.1 Wissenschaftliche Modelle und Theorien 5.2 Modell der Softwarevisualisierung 5.3 Herleitung 5.4 Interaktionskosten 5.5 Einordnung 6 Evaluationsansatz 6.1 Empirische Evaluation 6.2 Evaluation von Visualisierungen 6.3 Anforderungsanalyse 6.4 Herleitung 6.5 Vorgehensmodell 6.6 Einordnung 7 Planung der Studienreihe 7.1 Ziel 7.2 Darstellungsvarianten 7.3 Benutzungsschnittstellenvarianten 7.4 Aufgaben 7.5 Probanden 7.6 Ablauf 7.7 Datenerhebung 7.8 Durchführung 7.9 Auswertung 7.10 Bedrohung der Validität 8 Studie EarlyBird 8.1 Ziel 8.2 Iterationen 8.3 Untersuchungsvarianten 8.4 Aufgaben 8.5 Ablauf 8.6 Datenerhebung 8.7 Auswertung 8.8 Diskussion 8.9 Ergebnis 9 Studie LateWorm 9.1 Ziel 9.2 Iterationen 9.3 Untersuchungsvarianten 9.4 Aufgaben 9.5 Ablauf 9.6 Datenerhebung 9.7 Auswertung 9.8 Diskussion 9.9 Ergebnis 10 Studie LazyDog 10.1 Ziel 10.2 Iterationen 10.3 Untersuchungsvarianten 10.4 Aufgaben 10.5 Ablauf 10.6 Datenerhebung 10.7 Auswertung 10.8 Diskussion 10.9 Ergebnis 11 Studie AgileSnail 11.1 Ziel 11.2 Iterationen 11.3 Untersuchungsvarianten 11.4 Aufgaben 11.5 Ablauf 11.6 Datenerhebung 11.7 Auswertung 11.8 Diskussion 11.9 Ergebnis 12 Fazit und Ausblick 12.1 Interaktionskostenmodell 12.2 Vorgehensmodell 12.3 Studienreihe

Software maintenance encompasses any changes made to a software system after its initial deployment and is thereby one of the key phases in the typical software-engineering lifecycle. In software maintenance, we primarily need to understand structural and behavioral aspects, which are difficult to obtain, e.g., by code reading. Software analysis is therefore a vital tool for maintaining these systems: It provides - the preferably automated - means to extract and evaluate information from their artifacts such as software structure, runtime behavior, and related processes. However, such analysis typically results in massive raw data, so that even experienced engineers face difficulties directly examining, assessing, and understanding these data. Among other things, they require tools with which to explore the data if no clear question can be formulated beforehand. For this, software analysis and visualization provide its users with powerful interactive means. These enable the automation of tasks and, particularly, the acquisition of valuable and actionable insights into the raw data. For instance, one means for exploring runtime behavior is trace visualization. This thesis aims at extending and improving the tool set for visual software analysis by concentrating on several open challenges in the fields of dynamic and static analysis of software systems. This work develops a series of concepts and tools for the exploratory visualization of the respective data to support users in finding and retrieving information on the system artifacts concerned. This is a difficult task, due to the lack of appropriate visualization metaphors; in particular, the visualization of complex runtime behavior poses various questions and challenges of both a technical and conceptual nature. This work focuses on a set of visualization techniques for visually representing control-flow related aspects of software traces from shared-memory software systems: A trace-visualization concept based on icicle plots aids in understanding both single-threaded as well as multi-threaded runtime behavior on the function level. The concept’s extensibility further allows the visualization and analysis of specific aspects of multi-threading such as synchronization, the correlation of such traces with data from static software analysis, and a comparison between traces. Moreover, complementary techniques for simultaneously analyzing system structures and the evolution of related attributes are proposed. These aim at facilitating long-term planning of software architecture and supporting management decisions in software projects by extensions to the circular-bundle-view technique: An extension to 3-dimensional space allows for the use of additional variables simultaneously; interaction techniques allow for the modification of structures in a visual manner. The concepts and techniques presented here are generic and, as such, can be applied beyond software analysis for the visualization of similarly structured data. The techniques' practicability is demonstrated by several qualitative studies using subject data from industry-scale software systems. The studies provide initial evidence that the techniques' application yields useful insights into the subject data and its interrelationships in several scenarios. / Die Softwarewartung umfasst alle Änderungen an einem Softwaresystem nach dessen initialer Bereitstellung und stellt damit eine der wesentlichen Phasen im typischen Softwarelebenszyklus dar. In der Softwarewartung müssen wir insbesondere strukturelle und verhaltensbezogene Aspekte verstehen, welche z.B. alleine durch Lesen von Quelltext schwer herzuleiten sind. Die Softwareanalyse ist daher ein unverzichtbares Werkzeug zur Wartung solcher Systeme: Sie bietet - vorzugsweise automatisierte - Mittel, um Informationen über deren Artefakte, wie Softwarestruktur, Laufzeitverhalten und verwandte Prozesse, zu extrahieren und zu evaluieren. Eine solche Analyse resultiert jedoch typischerweise in großen und größten Rohdaten, die selbst erfahrene Softwareingenieure direkt nur schwer untersuchen, bewerten und verstehen können. Unter Anderem dann, wenn vorab keine klare Frage formulierbar ist, benötigen sie Werkzeuge, um diese Daten zu erforschen. Hierfür bietet die Softwareanalyse und Visualisierung ihren Nutzern leistungsstarke, interaktive Mittel. Diese ermöglichen es Aufgaben zu automatisieren und insbesondere wertvolle und belastbare Einsichten aus den Rohdaten zu erlangen. Beispielsweise ist die Visualisierung von Software-Traces ein Mittel, um das Laufzeitverhalten eines Systems zu ergründen. Diese Arbeit zielt darauf ab, den "Werkzeugkasten" der visuellen Softwareanalyse zu erweitern und zu verbessern, indem sie sich auf bestimmte, offene Herausforderungen in den Bereichen der dynamischen und statischen Analyse von Softwaresystemen konzentriert. Die Arbeit entwickelt eine Reihe von Konzepten und Werkzeugen für die explorative Visualisierung der entsprechenden Daten, um Nutzer darin zu unterstützen, Informationen über betroffene Systemartefakte zu lokalisieren und zu verstehen. Da es insbesondere an geeigneten Visualisierungsmetaphern mangelt, ist dies eine schwierige Aufgabe. Es bestehen, insbesondere bei komplexen Softwaresystemen, verschiedenste offene technische sowie konzeptionelle Fragestellungen und Herausforderungen. Diese Arbeit konzentriert sich auf Techniken zur visuellen Darstellung kontrollflussbezogener Aspekte aus Software-Traces von Shared-Memory Softwaresystemen: Ein Trace-Visualisierungskonzept, basierend auf Icicle Plots, unterstützt das Verstehen von single- und multi-threaded Laufzeitverhalten auf Funktionsebene. Die Erweiterbarkeit des Konzepts ermöglicht es zudem spezifische Aspekte des Multi-Threading, wie Synchronisation, zu visualisieren und zu analysieren, derartige Traces mit Daten aus der statischen Softwareanalyse zu korrelieren sowie Traces mit einander zu vergleichen. Darüber hinaus werden komplementäre Techniken für die kombinierte Analyse von Systemstrukturen und der Evolution zugehöriger Eigenschaften vorgestellt. Diese zielen darauf ab, die Langzeitplanung von Softwarearchitekturen und Management-Entscheidungen in Softwareprojekten mittels Erweiterungen an der Circular-Bundle-View-Technik zu unterstützen: Eine Erweiterung auf den 3-dimensionalen Raum ermöglicht es zusätzliche visuelle Variablen zu nutzen; Strukturen können mithilfe von Interaktionstechniken visuell bearbeitet werden. Die gezeigten Techniken und Konzepte sind allgemein verwendbar und lassen sich daher auch jenseits der Softwareanalyse einsetzen, um ähnlich strukturierte Daten zu visualisieren. Mehrere qualitative Studien an Softwaresystemen in industriellem Maßstab stellen die Praktikabilität der Techniken dar. Die Ergebnisse sind erste Belege dafür, dass die Anwendung der Techniken in verschiedenen Szenarien nützliche Einsichten in die untersuchten Daten und deren Zusammenhänge liefert.

Softwarevisualisierung stellt als Teil der Informationsvisualisierung Struktur, Verhalten und Evolution einer Software dar. In der Softwareentwicklung bietet sie für jeden Akteur ein nützliches Werkzeug. So können neben Entwicklern auch Berater und Kunden Eigenschaften einer Software beurteilen, ohne höhere Programmierkenntnisse zu besitzen. Die Professur für Softwareentwicklung für Wirtschaft und Verwaltung der Universität Leipzig forscht im Bereich der Softwarevisualisierung. Neben einem Softwarevisualisierungsgenerator existieren bisher Extraktoren für C#, Java und Ruby. Für die SAP-eigene Programmiersprache ABAP und weitere SAP-Strukturinformationen sind in der Literatur und im kommerziellen Bereich wenige Konzepte veröffentlicht worden. Das Ziel dieser Arbeit ist die Entwicklung eines Prototypen zur Extraktion von SAP- Strukturinformationen in das Metamodell FAMIX als Grundlage für die Softwarevisualisierung. Als Werkzeug kommt dabei der SAP Code Inspector zum Einsatz, um Informationen über Quelltextelemente zu sammeln. Die zu extrahierenden Informationen werden durch eine Analyse der Recursive Disk Metaphor ermittelt, bei der SAP-Elemente in die bestehende Version integriert werden.:1. Einleitung 1.1. Motivation 1.2. Zielstellung 1.3. Methodisches Vorgehen 1.4. Aufbau dieser Arbeit 2. SAP-Grundlagen 2.1. SAP-System 2.2. ABAP 2.2.1. Report 2.2.2. Funktionsgruppe 2.2.3. Klasse 2.2.4. Datentyp 2.2.5. Tabelle 2.3. SAP Code Inspector 2.3.1. Anwendung des SAP Code Inspectors 2.3.2. Aufbau eigener Prüfklassen 3. Softwarevisualisierung 3.1. Grundlagen der Softwarevisualisierung 3.2. Visualisierungsprozess 3.3. FAMIX-Grammatik 3.4. Recursive Disc Metaphor 4. Analyse der zu extrahierenden Strukturinformationen 4.1. Auswahl der ABAP-Objekte 4.2. Anforderungsanalyse für ABAP 4.3. Visualisierung in der Recursive Disc Metaphor 5. Prototyp zur Extraktion von Strukturinformationen 5.1. Konzeption 5.2. Funktionsbeschreibung 5.3. Architektur 5.4. Datenhaltung 5.5. Evaluation 6. Ausblick

Softwarevisualisierung stellt als Teil der Informationsvisualisierung Struktur, Verhalten und Evolution einer Software dar. In der Softwareentwicklung bietet sie für jeden Akteur ein nützliches Werkzeug. So können neben Entwicklern auch Berater und Kunden Eigenschaften einer Software beurteilen, ohne höhere Programmierkenntnisse zu besitzen. Die Professur für Softwareentwicklung für Wirtschaft und Verwaltung der Universität Leipzig forscht im Bereich der Softwarevisualisierung. Neben einem Softwarevisualisierungsgenerator existieren bisher Extraktoren für C#, Java und Ruby. Für die SAP-eigene Programmiersprache ABAP und weitere SAP-Strukturinformationen sind in der Literatur und im kommerziellen Bereich wenige Konzepte veröffentlicht worden. Das Ziel dieser Arbeit ist die Entwicklung eines Prototypen zur Extraktion von SAP- Strukturinformationen in das Metamodell FAMIX als Grundlage für die Softwarevisualisierung. Als Werkzeug kommt dabei der SAP Code Inspector zum Einsatz, um Informationen über Quelltextelemente zu sammeln. Die zu extrahierenden Informationen werden durch eine Analyse der Recursive Disk Metaphor ermittelt, bei der SAP-Elemente in die bestehende Version integriert werden.:1. Einleitung 1.1. Motivation 1.2. Zielstellung 1.3. Methodisches Vorgehen 1.4. Aufbau dieser Arbeit 2. SAP-Grundlagen 2.1. SAP-System 2.2. ABAP 2.2.1. Report 2.2.2. Funktionsgruppe 2.2.3. Klasse 2.2.4. Datentyp 2.2.5. Tabelle 2.3. SAP Code Inspector 2.3.1. Anwendung des SAP Code Inspectors 2.3.2. Aufbau eigener Prüfklassen 3. Softwarevisualisierung 3.1. Grundlagen der Softwarevisualisierung 3.2. Visualisierungsprozess 3.3. FAMIX-Grammatik 3.4. Recursive Disc Metaphor 4. Analyse der zu extrahierenden Strukturinformationen 4.1. Auswahl der ABAP-Objekte 4.2. Anforderungsanalyse für ABAP 4.3. Visualisierung in der Recursive Disc Metaphor 5. Prototyp zur Extraktion von Strukturinformationen 5.1. Konzeption 5.2. Funktionsbeschreibung 5.3. Architektur 5.4. Datenhaltung 5.5. Evaluation 6. Ausblick

Softwareentwicklungsprojekte bringen viele verschiedene Artefakte hervor. Artefakte stellen unterschiedliche Aspekte wie Struktur (statische Informationen), Verhalten (dynamische Informationen) oder Evolution (historisierte Informationen) von Softwaresystemen dar. Die Softwarevisualisierung ist darauf ausgelegt, solche Artefakte in eine visuelle Form zu überführen. Externe Umfragen und eine intensive Literaturrecherche zeigen jedoch Defizite dieses Gebietes auf. So sind viele Werkzeuge zur Visualisierung vom Entwicklungsprozess entkoppelt, bieten unzureichenden Im- und Export von Visualisierungen und besitzen teilweise einen geringen Automatisierungsgrad des Visualisierungsprozesses, insbesondere bei Werkzeugen zur dreidimensionalen Visualisierung. In dieser Arbeit wurde durch Adaption und Kombination bestehender Theorien und Werkzeuge der generativen und der modellgetriebenen Softwareentwicklung in Verbindung mit Techniken aus der Softwarevisualisierung ein Konzept entwickelt, das beschreibt, wie dreidimensionale Visualisierungen von Softwaresystemen vollautomatisch generiert werden können. Im Mittelpunkt steht ein Generator, der ausgehend von einer Anforderungsspezifikation vollautomatisiert 3D-Modelle erzeugt. Zur Validierung des entwickelten Konzeptes wurde ein Prototyp implementiert, der auf die Visualisierung der Struktur von Softwaresystemen abzielt. Dieser lässt sich als Plugin in die Entwicklungsumgebung Eclipse integrieren und erzeugt aus Ecore-basierten Modellen nach Benutzeranforderungen mittels Modelltransformationen ein 3D-Modell im freien und standardisierten X3D-Format. Die Transformationen sind dabei mit dem Werkzeug openArchitectureWare realisiert. Schließlich wurde der Prototyp selbst einer Evaluation gemäß etablierten Kriterien aus der Softwarevisualisierung unterzogen.

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.:1 Einleitung 1.1 Motivation 1.2 Ziele 1.3 Aufbau 2 Softwarevisualisierung 2.1 Visualisierung 2.1.1 Grundlagen 2.1.2 Aufgaben und Ziele 2.1.3 Teilgebiete 2.2 Definition 2.3 Ziele und Aufgaben 2.4 Visualisierungspipeline 2.5 Visualisierungstechniken 2.5.1 Graphen 2.5.2 Visuelle Metaphern 2.6 Taxonomie für Softwarevisualisierungen 3 Interaktion mit einer Softwarevisualisierung 3.1 Einordnung 3.2 Definition 3.3 Ziele 3.4 Benutzungsschnittstelle 3.5 Aufbau der Benutzungsschnittstelle 3.5.1 Anwendungsschnittstelle 3.5.2 Dialogschnittstelle 3.5.3 Ein-/Ausgabenschnittstelle 3.6 Interaktionstechnik 3.7 Taxonomie der Interaktionstechniken 3.8 Konzept zur Interaktion mit einer Softwarevisualisierung 4 Technische Grundlagen des Prototyps 4.1 Eclipse 4.2 Das openArchitectureWare-Framework 4.2.1 Modellgetriebene Softwareentwicklung 4.2.2 Aufbau des Frameworks 4.2.3 oAW-Workflow 4.2.4 Ecore 4.2.5 Xtend Modell-zu-Modell-Transformationen 4.3 Extensible 3D 4.3.1 Grundlagen 4.3.2 Szenegraph 4.3.3 Ereignismodell 4.3.4 X3D-Prototypen 5 Basisprototyp 5.1 Funktionsweise 5.2 Einordnung 5.3 Visualisierungsprozess des Generators 5.3.1 Modelltransformation von Ecore zu Graph 5.3.2 Modellmodifikation des Graphen 5.3.3 Modelltransformation von Graph zu X3D 5.4 Ansatzpunkte der Erweiterung 6 Erweiterung des Prototyps für die Interaktion 6.1 Benutzungsschnittstelle 6.1.1 Direkte Manipulation 6.1.2 Manipulation nach Elementtyp 6.1.3 Navigation durch Pakethierarchie und Klassengraph 6.1.4 Identifikation nach Bezeichner und Tooltip 6.2 Architektur des interaktiven X3D-Modells 6.3 Erweiterung des Generators 6.3.1 Anpassung der Transformationen des Basisprototyps 6.3.2 Modelltransformation in ein interaktives X3D-Modell 6.4 Integration in das Eclipse-Plugin 7 Fazit und Ausblick