Zusammenfassung

In der Literatur existieren verschiedene Methoden zur Beschreibung und Ordnung von Visualisierungen f¨ ur Programmcode. Diese Methoden betrachten jedoch vorwiegend die objektiven Eigenschaften der Visualisierungen.

In dieser Arbeit wird ein Verfahren vorgestellt, das sowohl eine Beschreibung der objektiven Eigenschaften, als auch eine Bewertung der subjektiven Eigenschaften von Visualisierungen f¨ ur Programmcode beinhaltet. Zudem bietet dieses Verfahren ein zielorientiertes Vorgehen zur Auswahl von Visualisierungen zur Unterst¨ utzung von T¨ atigkeiten in Zusammenhang mit der Arbeit an Programmcode.

Mit diesem neu entwickelten Verfahren werden existierende Visualisierungen f¨ ur Programmcode katalogisiert und bewertet. Zudem werden Profile f¨ ur T¨ atigkeiten erstellt. Anhand dieser Bewertungen und Profile wird exemplarisch eine Zuordnung von Visualisierungen zu T¨ atigkeiten durchgef¨ uhrt.

Die abschließende Analyse der Ergebnisse der Arbeit f¨ uhrt zu einem ” Werkzeugkasten“

f¨ ur an Programmcode arbeitende Personen sowie zu der Neuentwicklung der Visualisierung ” SimplyView“.

Inhaltsverzeichnis

1  Einleitung  13

1.1  Zweck des Dokuments  14

1.2  Leserkreis  14

2  Aufgabenstellung  15

2.1  Ziel der Diplomarbeit  15

3  Verwandte Arbeiten  17

3.1  Taxonomien  17

3.2  Abgrenzung  19

4  L osungsweg  21

4.1  Abgrenzung des Betrachtungsraumes  21

4.1.1  Definition von Visualisierung f ur Programmcode  21

4.1.2  Dynamische Visualisierungen zur Darstellung von Laufzeitverhalten  22

4.2  Schema zur Erfassung existierender Visualisierungen  22

4.3  Beschreibungsschema  22

4.4  Bewertungsschema  23

4.5  Katalogisierung  23

4.6  Resultate der Katalogisierung  24

5  Beschreibungsschema  25

5.1  Struktur  25

5.2  Klassifizierung  26

5.3  Ebene 1 - Kategorien von Eigenschaften  27

5.4  Ebene 2 - Eigenschaften  27

5.4.1  Darstellung  29

5.4.2  Interaktion  32

5.4.3  Anbindung  34

5.5  Anwendung des Beschreibungsschemas  36

5.5.1  Anwendung zur Beschreibung einer Visualisierung  37

5.5.2  Anwendung zur Suche einer Visualisierung  37

5.6  Erweiterbarkeit des Beschreibungsschemas  38

5.6.1  Erweiterung um eine Eigenschaft  38

5.6.2  Erweiterung um eine Kategorie  38

5.6.3  Erweiterung um einen Eigenschaftstyp  38

5.6.4  Erweiterung um eine Klasse  39

6  Bewertungsschema  41

6.1  Zielorientierung  41

6.2  Komponenten von Programmcode  41

5

Inhaltsverzeichnis

6.3  Darstellungsebene  44

6.4  Zuordnung von Komponenten zu T atigkeiten  44

6.5  Bewertung einer Visualisierung  45

6.5.1  Bewertungskriterien  45

6.5.2  Bewertungsskala  48

7  Katalogisierung  49

7.1  T atigkeitsanalyse  49

7.1.1  Kategorien von T atigkeiten eines Programmierers  49

7.1.2  Feindesign erstellen  50

7.1.3  Programmieren  50

7.1.4  Fehler suchen  52

7.1.5  Dokumentation  53

7.1.6  Unit Test  54

7.1.7  Kommentieren  55

7.1.8  Code Review  56

7.2  Analyse existierender Visualisierungen  57

7.3  Basisvisualisierungen  57

7.4  Omondo UML Klassendiagramm  58

7.4.1  Beschreibung  58

7.4.2  Bewertung  59

7.5  SeeSoft Conditional nesting complexity  62

7.5.1  Beschreibung  62

7.5.2  Bewertung  63

7.6  G SEE Inheritance Relationship  67

7.6.1  Beschreibung  67

7.6.2  Bewertung  68

7.7  Creole Nested View  70

7.7.1  Beschreibung  71

7.7.2  Bewertung  72

7.8  sv3D  76

7.8.1  Beschreibung  76

7.8.2  Bewertung  77

7.9  IMSOVision  81

7.9.1  Beschreibung  81

7.9.2  Bewertung  83

7.10  Alternative zur Visualisierung - Metrics  86

7.10.1  Beschreibung  87

7.10.2  Bewertung  88

7.11  Zuordnung von Visualisierungen zu T atigkeiten  90

7.11.1  Zuordnung von Visualisierungen zur T atigkeit Dokumentation ei-  

ner  Klasse erstellen“  90

7.11.2  Zuordnung von Visualisierungen zur T atigkeit Erstellung von Test-  

f  allen f ur komplexe Methoden“  91

7.11.3  Zuordnung von Visualisierungen zur T atigkeit Einsetzen externer  

Bibliotheken  “  92

7.11.4  Zuordnung von Visualisierungen zur T atigkeit Vervollst andigen der  

Kommentierung  von Klassen“  93

6

Inhaltsverzeichnis

8  Resultate der Katalogisierung  95

8.1  Analyse der katalogisierten Visualisierungen  95

8.2  Werkzeugkasten  96

8.3  Entwurf der Visualisierung SimplyView  97

8.3.1  Dargestellte Informationen  98

8.3.2  Aussagen uber das analysierte Projekt  102

9  Fazit  103

9.1  R uckblick  103

9.2  Inhaltliches Fazit  104

9.3  Zuk unftige Arbeiten  105

7

Abbildungsverzeichnis

3.1 Beispiel f¨ ur einen generierten Flowchart, entnommen aus dem Artikel von Haibt (1959) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 3.2 Grafische Darstellung der Taxonomie von Brad A. Myers (1990) . . . . . . 18 3.3 Anwendung der Charakterisierung von John T. Stasko auf ausgew¨ ahlte Untergruppen von Programm-Visualisierungen, entnommen aus Stasko and Patterson (1993) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 3.4 ¨ Uberblick ¨ uber die Taxonomie von Price et al. (1992) . . . . . . . . . . . . 19 3.5 Detail-Ansicht der Kategorie ” Form“ . . . . . . . . . . . . . . . . . . . . . 19

5.1 Grafische Darstellung der Struktur des Beschreibungsschemas . . . . . . . 25 5.2 Grafische Darstellung der Klassifizierung . . . . . . . . . . . . . . . . . . . 26 5.3 Grafische Darstellung der Eigenschaften der Kategorie Darstellung . . . . . 29 5.4 Grafische Darstellung der Eigenschaften der Kategorie Interaktion . . . . . 32 5.5 Grafische Darstellung der Eigenschaften der Kategorie Anbindung . . . . . 34

7.1 Beispiel eines Omondo UML Klassendiagramms . . . . . . . . . . . . . . . 58 7.2 Ansicht der SeeSoft Conditional nesting complexity Visualisierung . . . . . 62 7.3 Ansicht der G ^SEE Inheritance Relationship Visualisierung . . . . . . . . . . 67 7.4 Beispiel der Creole Nested View Visualisierung . . . . . . . . . . . . . . . . 71 7.5 Abbildung von Relationen in der Creole Nested View Visualisierung . . . . 74 7.6 Beispiel der sv3D Visualisierung . . . . . . . . . . . . . . . . . . . . . . . . 76 7.7 Beispiel IMSOVision Visualisierung . . . . . . . . . . . . . . . . . . . . . . 82 7.8 Metrics in der Anwendung auf ein Java-Projekt mit ungef¨ ahr 14 000 Programmzeilen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

8.1 Anwendung der Visualisierung SimplyView auf den eigenen Programmcode (3087 Zeilen Programmcode) . . . . . . . . . . . . . . . . . . . . . . . . . . 98 8.2 SimplyView-Darstellung ohne Filter . . . . . . . . . . . . . . . . . . . . . . 101 8.3 SimplyView-Darstellung mit Filter . . . . . . . . . . . . . . . . . . . . . . 101

9

Tabellenverzeichnis

5.1 Klassifizierung - Benennung der Klassen . . . . . . . . . . . . . . . . . . . 27 5.2 Kategorien des Beschreibungsschemas . . . . . . . . . . . . . . . . . . . . . 27 5.3 Typen von Eigenschaften . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 5.4 “Null“-Werte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 5.5 Beispielwerte der Eigenschaft Visualisierungstyp . . . . . . . . . . . . . . . 30 5.6 Werte der Eigenschaft Farbe . . . . . . . . . . . . . . . . . . . . . . . . . . 30 5.7 Werte der Eigenschaft Echtzeit . . . . . . . . . . . . . . . . . . . . . . . . 31 5.8 Werte der Eigenschaft Visualisierungssystem . . . . . . . . . . . . . . . . . 33 5.9 Werte der Eigenschaft Informationsquelle . . . . . . . . . . . . . . . . . . . 35 5.10 Werte der Eigenschaft Einbindung . . . . . . . . . . . . . . . . . . . . . . . 35 5.11 Werte der Eigenschaft Auswirkungen auf Ausf¨ uhrung . . . . . . . . . . . . 36

6.1 Komponenten von Programmcode . . . . . . . . . . . . . . . . . . . . . . . 44 6.2 Darstellungsebenen des Bewertungsschemas . . . . . . . . . . . . . . . . . 44 6.3 Arten der Zuordnung von Komponenten zu T¨ atigkeiten . . . . . . . . . . . 45 6.4 Werte der Bewertungsskala der allgemeinen Bewertung von Visualisierungen 48

7.1 Kategorien von T¨ atigkeiten eines Programmierers . . . . . . . . . . . . . . 50 7.2 Beschreibung der Visualisierung Omondo UML Klassendiagramm . . . . . 59 7.3 Komponenten der Visualisierung Omondo UML Klassendiagramm . . . . . 60 7.4 Allgemeine Bewertung der Visualisierung Omondo UML Klassendiagramm 61 7.5 Beschreibung der Visualisierung SeeSoft Conditional nesting complexity . . 63 7.6 Komponenten der Visualisierung SeeSoft Conditional nesting complexity . 64 7.7 Allgemeine Bewertung der Visualisierung SeeSoft Conditional nesting complexity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 7.8 Durch die Visualisierung SeeSoft Conditional nesting complexity unterst¨ utzte T¨ atigkeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 7.9 Beschreibung der Visualisierung G ^SEE Inheritance Relationship . . . . . . 68 7.10 Komponenten der Visualisierung G ^SEE Inheritance Relationship . . . . . . 69 7.11 Komponenten der Visualisierung G ^SEE Inheritance Relationship . . . . . . 70 7.12 Beschreibung der Visualisierung Creole Nested View . . . . . . . . . . . . . 72 7.13 Komponenten der Visualisierung Creole Nested View . . . . . . . . . . . . 73 7.14 Allgemeine Bewertung der Visualisierung Creole Nested View . . . . . . . 74 7.15 Beschreibung der Visualisierung sv3D . . . . . . . . . . . . . . . . . . . . . 77 7.16 Komponenten der Visualisierung sv3D . . . . . . . . . . . . . . . . . . . . 78 7.17 Allgemeine Bewertung der Visualisierung sv3D . . . . . . . . . . . . . . . . 79 7.18 Beschreibung der Visualisierung IMSOVision . . . . . . . . . . . . . . . . . 83 7.19 Komponenten der Visualisierung IMSOVision . . . . . . . . . . . . . . . . 84 7.20 Allgemeine Bewertung der Visualisierung IMSOVision . . . . . . . . . . . . 85 7.21 Allgemeine Bewertung von Metrics . . . . . . . . . . . . . . . . . . . . . . 88 7.22 Durch Metrics dargestellte Komponenten von Programmcode . . . . . . . . 88

11

Tabellenverzeichnis

7.23 Allgemeine Bewertung von Metrics . . . . . . . . . . . . . . . . . . . . . . 89

7.24 Ergebnisliste zur T¨ atigkeit ” 7.25 Ergebnisliste zur T¨ atigkeit ” Erstellung von Testf¨ allen f¨ ur komplexe Methoden“ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91 7.26 Ergebnisliste zur T¨ atigkeit ” Einsetzen externer Bibliotheken“ . . . . . . . . 92

8.1 “Werkzeugkasten“ der Visualisierungen f¨ ur Programmcode . . . . . . . . . 97 8.2 SimplyView: In der Darstellung einer Klasse abgebildete Informationen . . 98 8.3 SimplyView: Bestandteile der Formel zur Berechnung der Breite der Klassen 99 8.4 SimplyView: Bestandteile der Formel zur Berechnung der St¨ arke der Relationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

12

1 Einleitung

Visualisierungen bilden ein wichtiges Hilfsmittel bei der Erstellung und Wartung von Software. Das Lesen und Verstehen von Programmcode, das Konzipieren und Designen von Software-Systemen sowie die ¨ Uberwachung zur Laufzeit - all diese Aktivit¨ aten, und noch zahlreiche mehr, k¨ onnen durch Visualisierungen erleichtert werden.

Hierbei helfen besonders folgende Haupteigenschaften von Visualisierungen:

• Grafische Darstellung der Informationen,

• Abstraktion der gebotenen Informationen,

• Schwerpunktlegung auf die Darstellung der ben¨ otigten Informationen.

Diese Eigenschaften von Visualisierungen werden von anderen Berufszweigen wie den Maschinenbauern, den Chemikern, den Physikern und den Medizinern, seit langem genutzt. Hierbei finden durch Software generierte Visualisierungen großen Einsatz. In der Softwareentwicklung selber werden jedoch, wie im Buch ” Software Visualization“

von Diehl (2007) beschrieben, bisher nur im geringen Maß Visualisierungen eingesetzt. W¨ ahrend f¨ ur die Planung und das Design von Software-Systemen ausgefeilte Visualisierungen zur Verf¨ ugung stehen (siehe beispielsweise Borland (2008)) erfolgt die eigentliche Umsetzung des Programms - die Entwicklung, der Test und die Wartung des Programmcodes - im großen Maß ohne Visualisierung direkt durch Lesen, Schreiben und Editieren von Programmcode.

Ein gewichtiger Grund hierf¨ ur ist die fehlende ¨ Ubersicht ¨ uber existierende Visualisierungen f¨ ur Programmcode und ihre Einsatzm¨ oglichkeiten. In den oben genannten Berufszweigen und der Planung und dem Design von Software-Systemen haben sich ¨ uber

die Zeit Standards in Spezifikationen und Applikationen herausgebildet, wie beispielsweise UML (spezifiziert von der Object Management Group (2007)). Diese Standardisierung fand im Bezug auf Visualisierungen f¨ ur Programmcode bisher noch nicht statt - mit dem Effekt, dass zwar zahlreiche Visualisierungen existieren, diese jedoch kaum genutzt werden.

Ziel dieser Diplomarbeit ist die Analyse der Anwendbarkeit von Visualisierungen zur Unterst¨ utzung von T¨ atigkeiten im Zusammenhang mit der Arbeit an Programmcode. Hierzu werden Schemata entworfen, welche die Beschreibung und Bewertung von Visualisierungen von Programmcode erm¨ oglichen. Diese Schemata werden verwendet, um bestehende Visualisierungen zu katalogisieren.

Zus¨ atzlich erfolgt eine Analyse ausgew¨ ahlter T¨ atigkeiten. Anhand dieser T¨ atigkeiten wird die Auswahl unterst¨ utzender Visualisierungen auf dem durch das Bewertungsschema beschriebenen Weg demonstriert.

13

1 Einleitung

Die durch die Katalogisierung gewonnenen Informationen werden analysiert und f¨ uhren zu einer ¨

Ubersicht ¨ Programmcode. Auf Basis dieser ¨ Programmcode, welche die existierenden Visualisierungen sinnvoll erg¨ anzt.

1.1 Zweck des Dokuments

Dieses Dokument beschreibt den Ablauf und die Ergebnisse der Diplomarbeit ” Visualisierungen f¨ ur Programmcode“. Es enth¨ alt eine ausf¨ uhrliche Beschreibung der gewonnenen Resultate sowie Anleitungen, wie diese Resultate anzuwenden sind. Zudem enth¨ alt es einen R¨ uckblick ¨ uber den Ablauf der Diplomarbeit.

Abgeschlossen wird das Dokument durch eine Analyse der m¨ oglichen Fortf¨ uhrungen des betrachteten Themas.

Dieses Dokument bildet zudem die Grundlage f¨ ur die Bewertung der Diplomarbeit.

1.2 Leserkreis

Diese Dokument richtet sich an folgende Personen:

• den Bearbeiter der Diplomarbeit,

• den Betreuer der Diplomarbeit,

• den Pr¨ ufer der Diplomarbeit,

• Personen, welche an Visualisierungen f¨ ur Programmcode interessiert sind.

14

2 Aufgabenstellung

An einem Projekt zur Entwicklung eines Software-Systems arbeiten generell mehrere Personen in verschiedenen Rollen, wie beispielsweise Entwickler, Tester und Wartungsingenieure. Hierbei ist es unvermeidlich, dass fremder Programmcode verstanden werden muss. Selbst wenn dieser Programmcode ausf¨ uhrlich kommentiert ist und gute Dokumentation existiert, ist es in komplexen Systemen ausgesprochen schwer, diesen Programmcode in seiner Bedeutung, seinen Zusammenh¨ angen und seinen Seiteneffekten zu verstehen. In der Realit¨ at sind die Bedingungen meist noch deutlich schlechter, da oft mißverst¨ andlich oder gar nicht kommentiert wird und Dokumentation - wenn sie ¨ uberhaupt vorhanden istmeist stark veraltet ist.

Eine Schwierigkeit f¨ ur das menschliche Gehirn bei der Wahrnehmung der Bedeutung eines vorliegenden Programmcodes liegt dabei in der textuellen Darstellung. W¨ ahrend ein Compiler ein Programm Zeile f¨ ur Zeile liest, ben¨ otigt das menschliche Gehirn Analogien zur ” realen Welt“ in Form von Metaphern und grafischen Darstellungen. Wie Diehl (2007) in seinem Buch ” Software Visualization“ beschreibt ist die Verwendung von Metaphern in der Softwareentwicklung stark ausgepr¨ agt. Automaten sortieren die Bl¨ atter von B¨ aumen, die daraus resultierenden Daten werden in Dateien (zusammengesetzt aus Daten und Kartei) gespeichert, welche in Ordnern gespeichert werden. Allein dieser eine Satz aus der Informatik enth¨ alt f¨ unf aus der ” realen Welt“ entliehene

Metaphern und zeigt, wie stark sich der Wortschatz der Informatik an den Objekten des Alltags orientiert.

Die Verwendung von grafischen Darstellungen jedoch ist in der Softwareentwicklung noch kaum vorangeschritten. Es existieren zahlreiche Implementierungen von Visualisierungen, und mit UML wurde eine allgemein akzeptierte Spezifikation zur visuellen Beschreibung eines Software-Systems entwickelt. UML wird jedoch meist zur Darstellung des Programmcodes in externen Dokumenten verwendet, und die meisten Implementierungen von Visualisierungen f¨ ur Programmcode kommen aufgrund mangelnder Bekanntheit kaum zum Einsatz.

2.1 Ziel der Diplomarbeit

Ziel dieser Diplomarbeit ist es nun, Visualisierungen f¨ ur Programmcode greifbar zu machen. Zum Erreichen dieses Ziels werden die folgenden Fragen beantwortet:

• Was ist eine Visualisierung f¨ ur Programmcode?

• Welche Arten von Visualisierungen f¨ ur Programmcode existieren?

• Welche Qualit¨ at, welchen Nutzen und welche M¨ angel haben die existierenden Visualisierungen f¨ ur Programmcode?

• Wie k¨ onnen Visualisierungen f¨ ur Programmcode formal erfasst und damit vergleichbar gemacht werden?

15

2 Aufgabenstellung

• Welche T¨ atigkeiten k¨ onnen durch Visualisierungen f¨ ur Programmcode unterst¨ utzt werden? Wie kann eine Zuordnung von Visualisierungen zu T¨ atigkeiten erfolgen, ohne explizit eine Verbindung zwischen jeder zu einer T¨ atigkeit passenden Visualisierung erstellen zu m¨ ussen?

• Welche Visualisierungen bilden einen optimalen ” Werkzeugkasten“ f¨ ur eine mit Programmcode arbeitende Person? Gibt es Unterschiede in den optimalen Visualisierungen f¨ ur unterschiedliche Rollen wie Entwickler, Tester oder Wartungsingenieur?

• Welche Schwachstellen haben die existierenden Visualisierungen f¨ ur Programmcode? Wie sieht eine Visualisierung f¨ ur Programmcode aus, welche den ” Werkzeugkasten“

neben den existierenden Visualisierungen erg¨ anzt?

Eine ¨ Ubersicht ¨ uber den in diesem Bericht gegangenen Weg zur Beantwortung dieser Fragen ist in Kapitel 4 gegeben. Eine ausf¨ uhrliche Beschreibung erfolgt in den darauffolgenden Kapiteln.

16

3 Verwandte Arbeiten

Visualisierungen wurden bereits in den Anf¨ angen der Softwareentwicklung zur Unterst¨ utzung der Programmierer herangezogen. Bereits von Neumann und Goldstine (1947) beschrieben Flowcharts, ein Verfahren zur grafischen Darstellung der Abl¨ aufe innerhalb eines Programms (siehe Abbildung 3.1).

Abbildung 3.1: Beispiel f¨ ur einen generierten Flowchart, entnommen aus dem Artikel von Haibt (1959)

3.1 Taxonomien

Mit den Jahren nahm die Zahl an Visualisierungen f¨ ur Programmcode stark zu. Zur Verwaltung dieser Menge von Visualisierungen entwickelte Myers (1990) eine Taxonomie zur eindeutigen Einordnung von ” Programm-Visualisierungen“, wie sie von ihm genannt werden. Myers unterscheidet Programm-Visualisierungen dabei nach statischen und dynamischen Visualisierungen und ordnet sie einer Kategorie - ” Data“, ” Code“ oder ” Algorithm“ - zu (siehe Abbildung 3.2).

Myers erm¨ oglicht mit seiner Taxonomie eine grobe Einordnung von Programm-Visualisierungen in eine von sechs Klassen. Diese Einordnung erfolgt rein auf objektiven Eigenschaften der Visualisierungen, eine qualitative Bewertung der Visualisierung erfolgt nicht.

17

3 Verwandte Arbeiten

Abbildung 3.2: Grafische Darstellung der Taxonomie von Brad A. Myers (1990)

Basierend auf der Taxonomie von Myers entwickelten Stasko and Patterson (1993) ein

System zur Beurteilung von Programm-Visualisierungen nach den vier Kriterien ” abstractness“, ”

”

satz zu Myers - nicht das Ziel einer eindeutigen Zuordnung von Visualisierungen zu Klassen. Vielmehr geht es um eine Charakterisierung der Untergruppen von Programm-Visualisierungen wie beispielsweise der Visualisierungen zur Darstellung von Programmzust¨ anden oder Visualisierungen von Algorithmen. Dementsprechend grob f¨ allt auch die Wertebelegung der Kriterien aus - zur Verf¨ ugung stehen ” low“, ” medium“ und ” high“.

Die Anwendung der Charakterisierung von Stasko auf ausgew¨ ahlte Untergruppen ist in Abbildung 3.3 zu sehen.

Abbildung 3.3: Anwendung der Charakterisierung von John T. Stasko auf ausgew¨ ahl-

Price et al. (1992) entwickelten eine komplexere Taxonomie zur Klassifizierung von Software-Visualisierungen“, da ihnen die existierenden Taxonomien zur Beschreibung von

”

Software-Visualisierungen nicht ausreichten. Diese Taxonomie bietet 30 Bewertungskriterien in den sechs in Abbildung 3.4 dargestellten Kategorien. Die Bewertungskriterien umfassen objektive Eigenschaften der Visualisierungen - unter anderem in abgewandelter Form die Kriterien von Myers - und in geringem Maß auch eine subjektive Bewertung durch das Bewertungskriterium ” Appropriateness and Clarity“, welches Teil der Kategorie

F: Effectiveness ist. Zur subjektiven Bewertung werden jedoch keine Anhaltspunkte oder Vorgehen definiert, selbst in den gebotenen Beispielen wird das Kriterium allgemein mit subjective“ belegt. Im Endeffekt ist die Taxonomie damit - wie die Taxonomie von Myers

”

- auch als reine Beschreibung der objektiven Eigenschaften von Software-Visualisierungen zu sehen.

In Price et al. (1993) verfeinern die Autoren ihre Taxonomie durch die Einf¨ uhrung von Unterkategorien zu den 30 Kategorien sowie durch die M¨ oglichkeit der rekursiv fortgesetzten Unterkategorisierung dieser Unterkategorien (auch beschrieben in Stasko et al. (1998)). Diese fortgesetzte Unterkategorisierung ist dargestellt in Abbildung 3.5. Beide

18

Abbildung 3.4: ¨

Abbildungen der Taxonomie wurden dem bereits erw¨ ahnten Artikel von Price et al. (1993) entnommen. Damit entwickelten die Autoren ein nahezu beliebig erweiterbares Beschreibungsschema f¨ ur Software-Visualisierungen, basierend auf ihrem oben beschriebenen Ansatz.

Durch diese Erweiterbarkeit wurde die Taxonomie von Price et al. zur Grundlage f¨ ur zahlreiche weitere, spezifischere Taxonomien f¨ ur Software-Visualisierungen. Ein Beispiel hierf¨ ur ist die im Paper ” Towards a Taxonomy of Network Protocol Visualization

Tools“ von Crescenzi and Innocenti (2002) beschriebene Taxonomie f¨ ur Netzwerkprotokoll-Visualisierungen.

3.2 Abgrenzung

Die vorgestellten Systeme erm¨ oglichen die Beschreibung und Klassifizierung von Programmen in unterschiedlicher Komplexit¨ at. Eines haben sie jedoch gemeinsam - die Bewertung der Visualisierungen erfolgt nahezu vollst¨ andig durch objektive Eigenschaften. Einzig das Bewertungskriterium ” Appropriateness and Clarity“ von Price et al. (1992)

bietet einen Ansatz zu einer qualitativen Bewertung. Diese wird jedoch in dem im Artikel beschriebenen Beispiel nicht durchgef¨ uhrt.

Der in diesem Dokument vorgestellte Ansatz verbindet eine Beschreibung der objektiven Eigenschaften einer Visualisierung f¨ ur Programmcode mit einer subjektiven Bewertung. Diese Bewertung erfolgt zum einen durch eine Analyse der allgemeinen Qualit¨ at der Visualisierung - auf Verst¨ andlichkeit, Korrektheit, etc. - zum anderen durch die Erstellung von Profilen f¨ ur Visualisierungen, mit dem Ziel der Zuordnung von unterst¨ utzenden Visualisierungen zu T¨ atigkeiten im Zusammenhang mit der Arbeit an Programmcode.

19

3 Verwandte Arbeiten

Insbesondere dieses zielorientierte Vorgehen - die Zuordnung von Visualisierungen zu T¨ atigkeiten - stellt eine Neuerung und einen erheblichen Mehrwert dar. W¨ ahrend die genannten existierenden Taxonomien und Beschreibungsschemata Visualisierungen zur reinen Beschreibung oder Klassifizierung analysieren, erfolgt die Betrachtung in dem im Folgenden beschriebenen Bewertungsschema aus der Sicht des Anwenders. Hierdurch wird eine Auswahl nach Nutzen erm¨ oglicht. Visualisierungen k¨ onnen nicht mehr nur nach ihrem ¨ außeren Erscheinungsbild, sondern auch nach ihrer Anwendbarkeit im Allgemeinen und auch im speziellen Fall zur Unterst¨ utzung einer bestimmten Aufgabe ausgew¨ ahlt werden. Hierdurch erfolgt der Br¨ uckenschlag von der theoretischen Einordnung hin zu einer praktischen Verwendbarkeit der Bewertung.

20

4 L ¨ osungsweg

Die L¨ osung der in Kapitel 2 beschriebenen Aufgaben erfolgt in mehreren Schritten. Diese Schritte werden im Folgenden beschrieben, die Beschreibung ihrer Umsetzung erfolgt in den nachfolgenden Kapiteln.

4.1 Abgrenzung des Betrachtungsraumes

Diese Diplomarbeit befasst sich mit Visualisierungen f¨ ur Programmcode. Die Bearbeitung dieses Themas zeigte, dass große Meinungsunterschiede dar¨ uber bestehen, wann eine Visualisierung eine ” Visualisierung f¨ ur Programmcode“ ist. Insbesondere beim Umfang der dargestellten Daten gehen die Meinungen stark auseinander - f¨ ur die einen ist die Darstellung einer Test¨ uberdeckung im Programmcode eine Visualisierung f¨ ur Programmcode, da die Darstellung im Programmcode erfolgt. F¨ ur andere gilt dies nicht, da als Kernaussage der Visualisierung keine Eigenschaft des Programmcodes dargestellt wird.

Aus diesem Grund wird in diesem Abschnitt eine Abgrenzung gezogen, welche Visualisierungen unter die Betrachtung fallen.

4.1.1 Definition von Visualisierung f¨ ur Programmcode

Im Rahmen dieser Arbeit wird die folgende Definition f¨ ur Visualisierung f¨ ur Programmcode verwendet.

Definition 4.1.1 Eine Visualisierung f¨ ur Programmcode ist eine visuelle Darstellung von einer oder mehreren Eigenschaften eines gegebenen Programmcodes, wobei die f¨ ur die Darstellung notwendigen Informationen alleine aus dem Programmcode gewonnen werden.

Diese Definition schr¨ ankt die in dieser Arbeit betrachteten Visualisierungen ein. Es werden ausschließlich Visualisierungen betrachtet, die Eigenschaften von Programmcode darstellen. Zudem werden keine Visualisierungen betrachtet, die Informationen aus einer externen Informationsquelle ben¨ otigen, wie zum Beispiel einer Versionsverwaltung, einer Quelle f¨ ur Test¨ uberdeckungen oder einem Bugtracking Tool.

Einen Grenzfall stellt das ” Visual Programming“ dar. Beim Visual Programming

wird in einem Editor eine grafische Darstellung des zu erstellenden Programms erstellt. Aus dieser grafischen Darstellung wird anschließend oder fortlaufend Programmcode erzeugt. Zum Zeitpunkt direkt nach der Erstellung des Programmcodes stellt die grafische Darstellung eine Visualisierung des generierten Programmcodes dar. Visual Programming wird im Rahmen dieser Diplomarbeit explizit von der Betrachtung ausgeschlossen. Das Ziel von Visual Programming ist die Generierung des Programmcodes, nicht die grafische Darstellung. Das grafische Modell dient prim¨ ar als Mittel zur Definition des Programms.

21

4 L¨ osungsweg

Die Darstellung des Programms wird zudem im Fall von Visual Programming nicht aus dem Programmcode erzeugt. Aus diesem Grund liegt keine Visualisierung f¨ ur Programmcode nach Definition 4.1.1 vor.

4.1.2 Dynamische Visualisierungen zur Darstellung von Laufzeitverhalten

Neben den externe Informationsquellen ben¨ otigenden Visualisierungen werden mit der im vorherigen Abschnitt getroffenen Definition auch Visualisierungen ausgeschlossen, welche Laufzeitverhalten durch Ver¨ anderungen am ausgef¨ uhrten Programm, beispielsweise in Form von Programmcode- oder Bytecode-Instrumentierung, darstellen. Diese Visualisierungen widersprechen der Definition, da sie die ben¨ otigten Informationen nicht aus dem Programmcode selber erlangen, sondern erst durch die durchgef¨ uhrten ¨ Anderungen.

In dieser Diplomarbeit wird die im vorherigen Abschnitt gegebene Definition verwendet. Die Diplomarbeit besch¨ aftigt sich in den Abschnitten mit konkreter Anwendung der Definition jedoch ausschließlich mit statischen Visualisierungen f¨ ur Programmcode, so dass der in diesem Abschnitt beschriebene Grenzfall nicht zum Tragen kommt. In anderen Anwendungsf¨ allen kann es sinnvoll sein, die Definition in Bezug auf die Informationsbeschaffung hinsichtlich der Visualisierungen f¨ ur Programmcode zur Darstellung von Laufzeitverhalten zu modifizieren, so dass ¨ Anderungen am Programmcode als Informationsquelle zul¨ assig werden.

Im Folgenden wird darauf hingewiesen, wann eine solche Modifikation zu Ver¨ anderungen f¨ uhren w¨ urde.

4.2 Schema zur Erfassung existierender

Visualisierungen

Um die betrachteten Visualisierungen erfassen und vergleichen zu k¨ onnen, werden sie in eine einheitliche Form gebracht. Hierzu wird ein Schema entworfen, mit welchem die objektiv erfassbaren Eigenschaften sowie eine subjektive Bewertung der Visualisierungen standardisiert festgehalten werden k¨ onnen.

Dieses Schema besteht aus zwei Teilen. Der erste Teil - das Beschreibungsschemadient der Erfassung der objektiven Eigenschaften der Visualisierungen. Der zweite Teildas Bewertungsschema - erlaubt die Erfassung der subjektiven Bewertung.

4.3 Beschreibungsschema

Zur Erfassung der existierenden Visualisierungen wird ein Beschreibungsschema entworfen. Dieses Beschreibungsschema erlaubt eine objektive Beschreibung einer Visualisierung. Hierin enthalten sind die relevanten eindeutig feststellbaren Eigenschaften, wie zum Beispiel Farbigkeit, Interaktion oder Animation.

Das Beschreibungsschema ist in Kapitel 5 beschrieben.

22