Strukturiertes aktives Lernen von Algorithmen mit interaktiven Visualisierungen

Dissertation

zur Erlangung des Grades eines Doktors der Ingenieurwissenschaften

am Fachbereich Informatik der Carl von Ossietzky Universitt Oldenburg

von

Dipl.-Inf. Nils Faltin

Gutachter: Prof. Dr.-Ing. Peter GornyProf. Dr. Gnther StiegeProf. Dr. Wolfram Luther

Tag der Disputation: 31.5.2002

http://docserver.bis.uni-oldenburg.de/publikationen/dissertation/2002/falstr02/falstr02.html

Strukturiertes aktives Lernen von Algorithmen mit interaktiven Visualisierungen

Dissertation

zur Erlangung des Grades eines Doktors der Ingenieurwissenschaften

am Fachbereich Informatik der Carl von Ossietzky Universitt Oldenburg

von

Dipl.-Inf. Nils Faltin

Gutachter: Prof. Dr.-Ing. Peter GornyProf. Dr. Gnther StiegeProf. Dr. Wolfram Luther

Tag der Disputation: 31.5.2002

http://docserver.bis.uni-oldenburg.de/publikationen/dissertation/2002/falstr02/falstr02.html

Danksagung

Mein herzlicher Dank gilt allen, die mich bei meiner Doktorarbeit untersttzt haben:

Meinem Doktorvater Prof. Dr. Peter Gorny fr den groen Freiraum bei der Gestaltung der Doktorar-beit, die guten Arbeitsmglichkeiten in seiner Abteilung und dafr, dass er mir das Gefhl gab, an ei-nem wertvollen Thema zu arbeiten.

Prof. Dr. Gnther Stiege und Prof. Dr. Wolfram Luther fr das Interesse an meiner Arbeit und diebernahme des Gutachtens.

Ingvor, Paul und Gnter Faltin fr die emotionale und materielle Untersttzung. Der Heinz Neumller Stiftung Oldenburg fr das Stipendium. Den Diplomanden und studentischen Hilfskrften Karsten Block, Jan Schormann und Tobias Gross

fr die fachliche Diskussion und die Arbeit an den Lernprogrammen. Prof. Dr. Sonnenschein fr die Mglichkeit, die Lernprogramme in seiner Lehrveranstaltung zu erpro-

ben. Den Lehrenden und Studierenden fr ihre Anmerkungen auf den Fragebgen. Den Korrekturlesern Gernot Lorz, Ines Faltin, Marco Eichelberg und Guido Rling, die Fehler und

Schwachstellen beheben halfen. Und nicht zuletzt meiner Frau Ines und meinem Sohn Elias, dass sie bereit waren, so manchen Tag auf

mich zu verzichten und mir immer den Rcken gestrkt haben.

Kurzfassung

Bei der Softwareentwicklung mssen immer wieder Grundprobleme, wie z. B. Sortieren, Suchen unddas Finden krzester Wege, gelst werden. Dafr stellt die Informatik eine reiche Auswahl an Algorith-men und Datenstrukturen bereit.

Da Algorithmen oft schwer zu verstehen sind, ist es wichtig, sie fr die Informatik-Ausbildung didak-tisch gut aufzubereiten. Diese Arbeit stellt eine neue Methode fr die Vermittlung von Algorithmen vor,die auf dem Konzept des entdeckenden Lernens und einer starken Modularisierung des Algorithmusbasiert. Die Studierenden lernen einen Algorithmus mithilfe interaktiver visueller Simulationen, die inLehrtexte eines Lernprogramms eingebettet sind. Es ist die Aufgabe der Studierenden, eine korrekteSchrittfolge fr den Algorithmus zu finden.

Fr Autoren von Lernprogrammen wurde eine Gestaltungsmethode ausgearbeitet, die ein Grundgerstfr die Gliederung der Programme und die Funktionsweise der darin enthaltenen interaktiven Simula-tionen von Algorithmenteilen beschreibt. Als Beispiel wird die Gestaltung eines Lernprogramms zuHeapsort vorgestellt. Weitere Hinweise zur software-ergonomischen und didaktischen Gestaltung sol-cher Simulationen werden als Gestaltungsregeln bereitgestellt. Die im Rahmen dieser Arbeit entwickel-te Bibliothek SALABIM erleichtert die Implementierung der interaktiven Simulationen.

Zwei Lernprogramme zu den Themen Heapsort und Binomial Heap sind nach der Gestaltungsmethodeentwickelt worden. Sie wurden im Grundstudium der Informatik eingesetzt und erprobt. Studierendeund Lehrende bewerteten ber Fragebgen die Lernprogramme und das dahinter stehende didaktischeKonzept. Insgesamt kamen sie zu einer positiven Einschtzung. Einsichten in die Nutzung der webba-sierten Lernprogramme lieferte eine Analyse der Logdateien des Webservers. So konnten das Navigati-onsverhalten, die Intensitt der Nutzung und das Verhltnis von Online- zu Offline- Nutzern ermitteltwerden.

Abstract

During software development basic problems like sorting, searching and finding a shortest path mustbe solved. Computer science provides a wealth of algorithms and data structures for such problems.

As algorithms can be difficult to understand it is important for computer science education to preparetheir presentation well. This thesis presents a new method for the teaching of algorithms throughcourseware. It is based on the concept of exploratory learning and on strong modularization of the al-gorithm. Students learn an algorithm with the help of interactive visual simulations that are containedin courseware tutorial text. It is the students task to find a correct sequence of steps for the algorithm.

For authors of courseware a design method has been developed. It describes the framework of thecourseware and the functioning of the interactive simulations contained therein. As an example the de-sign of a courseware on the heapsort algorithm is described. Additionally didactic and usability orienteddesign rules for the simulations are provided. The software library SALABIM developed in this projecteases the implementation of the interactive simulations.

Two courseware on heapsort and binomial heap have been developed following the design method.They have been evaluated in a first year university computer science course. Students and teachers as-sessed the courseware and its didactic concept on questionnaires. Overall the assessment was positive.The use of the web based courseware was analyzed. So the user navigation behavior, intensity of useand proportion of online to offline users could be determined.

Inhaltsverzeichnis 5

Inhaltsverzeichnis

Kurzfassung 3Abstract 3Abbildungsverzeichnis 9

1 Einleitung 111.1 Ansatz dieser Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111.2 Historische Entwicklung: Algorithmen in grafischen Lernmedien. . . . . . . . . . . . . . 12

1.2.1 Statische Bilder und mechanische Lehrmittel............................................................. 121.2.2 Neue Mglichkeiten im Medium Film.......................................................................... 131.2.3 Interaktive Visualisierung............................................................................................ 14

1.3 Akzeptanz und Effektivitt von Algorithmen-Animationen . . . . . . . . . . . . . . . . . . . 151.3.1 Verbreitung und Akzeptanz ........................................................................................ 151.3.2 Untersuchungen zur Effektivitt.................................................................................. 16

1.4 bersicht ber die folgenden Kapitel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2 Lerngegenstand Algorithmus 192.1 Aspekte eines Algorithmus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

2.1.1 Der Algorithmusbegriff................................................................................................ 192.1.2 Korrektheit .................................................................................................................. 202.1.3 Effizienz...................................................................................................................... 202.1.4 Datenstruktur .............................................................................................................. 202.1.5 Trace .......................................................................................................................... 20

2.2 Darstellung des Verfahrens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.2.1 Pseudocode oder Programmcode.............................................................................. 212.2.2 Modularitt.................................................................................................................. 212.2.3 Algorithmen und Entwurfsprinzipien ........................................................................... 21

3 Verwandte Arbeiten zum aktivem Lernen von Algorithmen 233.1 berblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.1.1 Lerner fhren Algorithmus aus ................................................................................... 233.1.2 Lerner entwickeln Algorithmen-Animation .................................................................. 243.1.3 Lerner programmieren Algorithmus............................................................................ 25

3.2 Visuelle Programmierung mit OPSIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263.2.1 bersicht .................................................................................................................... 263.2.2 Notation der visuellen Programmiersprache .............................................................. 263.2.3 Programme sind nicht strukturierbar .......................................................................... 263.2.4 Das Werkzeug OPSIS................................................................................................ 273.2.5 Erprobung der Lehrmethode ...................................................................................... 283.2.6 Bewertung des Ansatzes............................................................................................ 28

3.3 Studierende entwickeln und prsentieren Animationen . . . . . . . . . . . . . . . . . . . . . 293.3.1 Lerntheoretischer Hintergrund.................................................................................... 293.3.2 Erprobung der Lehrmethode ...................................................................................... 293.3.3 Das Visualisierungswerkzeug ALVIS ......................................................................... 303.3.4 Bewertung der Arbeiten Hundhausens....................................................................... 31

4 Die Gestaltungsmethode Strukturiertes Aktives Lernen von Algorithmen (SALA) 33

4.1 Einfhrung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334.1.1 Das Potential multimedialer Lernprogramme ............................................................. 334.1.2 Die Methode SALA..................................................................................................... 334.1.3 Vom Lehrbuch zum Lernprogramm............................................................................ 34

6 Inhaltsverzeichnis

4.1.4 Gestaltung nach SALA am Beispiel des Heapsort ..................................................... 344.2 Lernpsychologische Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

4.2.1 Entdeckendes versus rezeptives Lernen.................................................................... 354.2.2 Entdeckendes Lernen nach Bruner ............................................................................ 364.2.3 Vertiefung in eine Aufgabe ......................................................................................... 374.2.4 Intrinsische Motivation ................................................................................................ 37

4.3 SALA: Gliederung des Lernprogramms in Sektionen . . . . . . . . . . . . . . . . . . . . . . . 394.4 Funktionale Struktur eines Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

4.4.1 Methodische Grundlage: Algorithmen als modulare Software ................................... 404.4.2 Funktionale Struktur in SALA ..................................................................................... 424.4.3 Reihenfolge der Funktionen ....................................................................................... 434.4.4 Heapsort: Struktur, Reihenfolge und Schnittstellen.................................................... 43

4.5 Erlernen einer Funktion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444.5.1 Lernphasen beim entdeckenden Lernen .................................................................... 444.5.2 Modulare Darstellung der Funktion ............................................................................ 454.5.3 Heapsort: Build-Heap Funktion .................................................................................. 46

4.6 Interaktive Simulation einer Algorithmen-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . 494.6.1 Die interaktive Simulation ........................................................................................... 494.6.2 Heapsort: Aufgabe zur Funktion Build-Heap .............................................................. 49

4.7 Simulation und Animation mit SALABIM-Applets . . . . . . . . . . . . . . . . . . . . . . . . . . 49

5 Gestaltungsregeln fr interaktive Visualisierungen von Algorithmen 535.1 Algorithmen-Animationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

5.1.1 Gestaltungsregeln fr Algorithmen-Animationen........................................................ 535.1.2 Beispiele fr Algorithmen-Animationen ...................................................................... 54

5.2 Algorithmen-bungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555.2.1 Gestaltungsregeln fr Algorithmen-bungen ............................................................. 555.2.2 Beispiele fr Algorithmen-bungen............................................................................ 55

5.3 Algorithmen-Simulationen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565.3.1 Gestaltungsregeln fr Algorithmen-Simulationen ....................................................... 565.3.2 Beispiele fr Algorithmen-Simulationen...................................................................... 57

6 Software-Bibliothek SALABIM 596.1 Einfhrung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596.2 Anforderungen an die Bibliothek. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596.3 Beispielapplet Simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606.4 Java-Swing einbinden. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606.5 SALABIM als Framework . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616.6 Kontrollfluss im Applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

6.6.1 Initialisierung............................................................................................................... 616.6.2 Interaktionsschleife..................................................................................................... 63

6.7 Klassen eines SALABIM-Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646.7.1 Klassendiagramm....................................................................................................... 646.7.2 Die Klassen ................................................................................................................ 656.7.3 SimpleModel Programmcode ..................................................................................... 66

6.8 Beispielapplet Blcke stapeln. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 676.9 Verwandte Arbeiten zu Undo/Redo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

7 Studierende bewerten SALA-Lernprogramme und SALA 697.1 Einfhrung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

7.1.1 Eingesetzte Lernprogramme ...................................................................................... 697.2 Lehrbetrieb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

7.2.1 Lehrveranstaltung Datenstrukturen ............................................................................ 707.3 Gestaltung der Evaluation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

7.3.1 Wahl der Evaluationsmethode.................................................................................... 717.3.2 Gestaltung der Erhebung ........................................................................................... 72

Inhaltsverzeichnis 7

7.3.3 Vortest von Lernprogrammen und Fragebgen ......................................................... 737.4 Auswertung der Fragebgen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

7.4.1 Abgegebene Fragebgen........................................................................................... 747.4.2 Studienfach der Studierenden.................................................................................... 747.4.3 Vorwissen ber den Algorithmus................................................................................ 747.4.4 bung im Umgang mit Webbrowsern......................................................................... 757.4.5 Technische Probleme mit dem Lernprogramm .......................................................... 757.4.6 Gesamteinschtzung des Lernprogramms................................................................. 757.4.7 Punkte fr die Aufgaben............................................................................................. 767.4.8 Gesamteinschtzung von SALA................................................................................. 767.4.9 Einschtzung didaktischer Punkte.............................................................................. 77

7.5 Auswertung der Anmerkungen auf den Fragebgen . . . . . . . . . . . . . . . . . . . . . . . 787.6 Anmerkungen der Lehrenden auf den Fragebgen . . . . . . . . . . . . . . . . . . . . . . . . 797.7 Anmerkungen der Studierenden zu Heapsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . 807.8 Anmerkungen der Studierenden zu Binomial Heap . . . . . . . . . . . . . . . . . . . . . . . . 83

8 Analyse der Nutzung zweier SALA-Lernprogramme 878.1 Einfhrung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 878.2 Struktur der Lernprogramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

8.2.1 Blcke bei Heapsort ................................................................................................... 878.2.2 Blcke bei Binomial Heap........................................................................................... 908.2.3 Standardpfad.............................................................................................................. 908.2.4 Verzweigungspunkte fr die freie Navigation ............................................................. 90

8.3 Ermittlung der Nutzungsdaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 918.3.1 Technische Basis der Lernprogramme....................................................................... 918.3.2 Auswertung von Logdaten.......................................................................................... 92

8.4 Visualisierung der Nutzungsdaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 938.5 Analyse der Nutzungsdaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

8.5.1 Das Navigationsverhalten........................................................................................... 968.5.2 Die Intensitt der Nutzung.......................................................................................... 978.5.3 Das Verhltnis von Online-Nutzung zu Offline-Nutzung............................................. 988.5.4 Zusammenfassung..................................................................................................... 98

9 Zusammenfassung und Ausblick 999.1 Zusammenfassung. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 999.2 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

9.2.1 Lernprogramme fr weitere Algorithmen.................................................................... 999.2.2 Erweiterung von SALABIM......................................................................................... 999.2.3 Wissensbasierte tutorielle Hilfe ................................................................................ 1009.2.4 Evaluation der Lernprogrammen und des didaktischen Konzepts ........................... 1009.2.5 Aktives und soziales Lernen..................................................................................... 100

9.3 Zukunftsaussichten fr interaktive Lernmedien . . . . . . . . . . . . . . . . . . . . . . . . . . 100

10 Anhang: Unterlagen zur Evaluation 10110.1 Aufgabenblatt zu Heapsort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10110.2 Aufgabenblatt zu Binomial Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10210.3 Fragebogen zu Heapsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10310.4 Fragebogen zu Binomial Heap. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10410.5 Antwortdaten der Fragebgen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10510.6 Anmerkungen der Nutzer auf den Fragebgen . . . . . . . . . . . . . . . . . . . . . . . . . . 108

11 Quellenverzeichnis 11311.1 Quellen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

Index 117Lebenslauf 121

8 Inhaltsverzeichnis

Abbildungsverzeichnis 9

Abbildungsverzeichnis

1 Interaktive Simulation eines Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 Double-Ended-Queue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 Heapsort-Vertauschungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134 Sorting out Sorting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 BALSA insertion sort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 Animated Algorithms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 Stepwise Refinement bei Algorithms in Action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238 Heapsort im Modus ben bei Algorithms in Action . . . . . . . . . . . . . . . . . . . . . . . . . . 249 Endlicher Automat in JFLAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

10 ANIMAL - Interaktiver Editor fr Animationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2511 Visuelles Programm fr Suche im Binrbaum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2612 OPSIS im Editiermodus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2713 OPSIS im Tracemodus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2714 Erstellen der Bubblesort-Animation in ALVIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3115 Prsentieren der Animation in ALVIS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3116 Heapbaum mit markiertem Knoten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3517 Gliederung des Lernprogramms zu Heapsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4018 Funktionale Struktur des Heapsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4319 Gliederung der Funktionenseite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4520 Funktion Build-Heap im Lernprogramm zu Heapsort (oberer Teil der Seite) . . . . . . . . 4721 Funktion Build-Heap im Lernprogramm zu Heapsort (unterer Teil der Seite). . . . . . . . 4822 Simulation des Build-Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4923 Bedienelemente eines SALABIM-Applets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5024 Ablaufsteuerung eines SALABIM-Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5125 Lernen mit Animationen: Bubblesort. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5426 Lernen durch bung: Verschmelzen-Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5627 Simulation zu Heapify-Locally aus Heapsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5728 Standardverfahren Heapify-Locally. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5729 Alternatives Verfahren Heapify-Locally. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5730 Simple - Beispielapplet zu SALABIM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6032 Initialisierung des Applets in SALABIM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6131 Interaktionsschleife im SALABIM-Applet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6233 History-Liste der Call-Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6334 Klassen eines SALABIM-Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6535 GUI eines SALABIM-Applets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6536 NumberCall::perform Programmcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6637 SimpleModel::setNumberSelected Programmcode . . . . . . . . . . . . . . . . . . . . . . . . . . . 6638 NumberCall::equalsCall Programmcode. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6639 SimpleModel::finish Programmcode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6740 Beispielapplet: Blcke stapeln . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6741 Startseite Binomial Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6942 Seitenstruktur des Lernprogramms zu Heapsort zur Zeit der Evaluation . . . . . . . . . . . 8843 Seitenstruktur des Lernprogramms zu Binomial Heap . . . . . . . . . . . . . . . . . . . . . . . . 8944 Nutzung des Lernprogramms Heapsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9445 Nutzung des Lernprogramms zu Binomial Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95

10 Abbildungsverzeichnis

1 Einleitung 11

1 Einleitung

1.1 Ansatz dieser Arbeit

Bei der Softwareentwicklung mssen immer wie-der Grundprobleme, wie z.B. Sortieren, Suchenund das Finden krzester Wege, gelst werden.Dafr stellt die Informatik eine reiche Auswahl anAlgorithmen und Datenstrukturen bereit. Sie wer-den typischerweise im ersten Jahr des Informatik-studiums in der Vorlesung Algorithmen und Da-tenstrukturen behandelt. Auch in derMathematik spielen Algorithmen eine wichtigeRolle. Einfache mathematische Algorithmen, wiedas schriftliche Addieren, werden bereits in derGrundschule eingefhrt.

Da Algorithmen oft schwer zu verstehen sind, istes wichtig, dass sie fr die Vermittlung in der In-formatik-Ausbildung didaktisch gut aufbereitetwerden. Diese Arbeit stellt eine neue Methode frdie Vermittlung von Algorithmen vor, die auf demKonzept des entdeckenden Lernens und einer star-ken Modularisierung des Algorithmus basiert. DieStudierenden lernen einen Algorithmus mithilfeinteraktiver visueller Simulationen, die in Lehrtex-te eines Lernprogramms eingebettet sind.

Durch die Arbeit werden fr die Fachdidaktik derInformatik zwei wesentliche Innovationen er-reicht:

Die im Rahmen dieser Arbeit entwickelten Lern-programme erlauben Lernern einen neuartigen,motivierenden und kreativen Zugang zum Ler-nen von Algorithmen.

Die in dieser Arbeit vorgestellte Gestaltungsme-thode mit der Sammlung von Gestaltungshin-weisen und der Softwarebibliothek SALABIMerleichtern es zuknftigen Autoren didaktischund softwareergonomisch ansprechende Lern-programme zu Algorithmen zu erstellen.

Forschungsgebiet Algorithmen-AnimationDozenten und Lehrbuchautoren verwenden seitlangem grafische Darstellungen der Datenstruk-tur, um die Arbeitsweise eines Algorithmus zu er-klren. Da ein Algorithmus whrend seiner Lauf-zeit die Daten verndert, werden sie zumeist ineiner Folge statischer Bilder dargestellt.

Das Forschungsgebiet der Algorithmen-Animati-on beschftigt sich mit der Erstellung und Bewer-tung von Trickfilmen, die die Vernderung der Da-ten darstellen. Dabei wurden bisher vor allemSoftwarebibliotheken und Autorensysteme entwi-ckelt, die die Erstellung von Algorithmen-Anima-tionen erleichtern. Hingegen wurde wenig unter-sucht, welche Eigenschaften eine Animationaufweisen muss, damit der Algorithmus von Stu-dierenden gut verstanden wird. Auch gehen diebisherigen Systeme zumeist von einer Prsentationdes Algorithmus als Animation aus, bei der dieStudierenden nur die Rolle eines Betrachters ha-ben.

Entdeckendes Lernen in einer MikroweltDiese Arbeit prsentiert eine neue Methode fr dasLernen von Algorithmen, in der die Studierendeneine aktive Rolle einnehmen. Whrend bestimmteTeile des Algorithmus den Studierenden in einemhypermedialen tutoriellen Teil prsentiert werden,sollen sie andere Teile selbst entwickeln. Als Ar-beitsmittel erhalten sie dazu eine interaktive grafi-sche Simulation des Algorithmus mit der sie expe-rimentieren knnen. Da die Lsung in derSimulation verborgen ist und quasi nur gefundenwerden muss, spricht man von entdeckendem Ler-nen. Die Simulation bildet fr die Studierendeneine eigene kleine Welt (sogenannte Mikrowelt) inder sie fr eine gewisse Zeit handeln und Erfah-rungen sammeln knnen.

In der Mikrowelt knnen im Allgemeinen von ei-ner Situation aus verschiedene Schritte gegangenwerden. Diese Vielfalt macht den Reiz einer Simu-lation aus, kann aber Studierende auch berfor-dern. Sollten Studierende an der Aufgabe schei-tern, so knnen sie eine Musterlsung abrufen. DieSimulation zeigt dann eine Algorithmus-Funktionals Pseudocode und fhrt die Lsungsschritte au-tomatisch aus. Anschlieend knnen die Studie-renden die Schritte der Musterlsung selbst aus-fhren. Dabei achtet die Simulation darauf, dassnur die Schritte der Musterlsung ausgefhrt wer-den, so dass in jeder Situation nur ein Schritt mg-lich ist.

12 1.2 Historische Entwicklung: Algorithmen in grafischen Lernmedien

Phasen einer SimulationTechnisch gesehen arbeitet die Simulation wieder-holt die folgenden Phasen ab:

1. Visualisierung: Die Simulation stellt die Daten-struktur des Algorithmus grafisch dar.

2. Interaktion: Der Studierende whlt mit demZeigegert Elemente der Datenstruktur und ei-ne Algorithmus-Funktion, die auf diesen Ele-menten gestartet werden sollen.

3. Regelprfung: Die Simulation prft, ob dieseAlgorithmus-Funktion jetzt ausgefhrt werdendarf.

4. Ausfhrung: Falls erlaubt wird die Funktionausgefhrt und die Datenstruktur entsprechendverndert.

Visualisierung und Interaktion bilden die Benut-zungsoberflche zur Regelprfung und Ausfh-rung (Abb. 1).

Diese Phasen werden bisher von den Studierendenmit Papier und Stift bearbeitet, wenn sie als Haus-aufgabe den Ablauf eines Algorithmus durchge-hen. Demgegenber bernimmt eine Simulationdie Phasen Visualisierung und Ausfhrung, sodass sich der Studierende auf die eigentliche Ar-beitsweise des Algorithmus konzentrieren kann.Die Phase Regelprfung verhindert, dass der Stu-dierende eine fehlerhafte Lsung weiter bearbeitet.

Studierender1. Visualisierung 3. Regelprfung

Abb. 1: Interaktive Simulation eines Algorithmus

2. Interaktion 4. Ausfhrung

1.2 Historische Entwicklung: Algorithmen in grafischen Lernmedien

Im Folgenden sollen wichtige Phasen in der Ent-wicklung grafischer Darstellungen von Algorith-men aufgezeigt werden. Neue Techniken wieLehrfilme oder interaktive Animationen brachtenneben neuen Mglichkeiten auch neue Herausfor-derungen fr einen didaktisch sinnvollen Einsatzals Lernmedium. Die Kenntnis dieser Zusammen-hnge kann helfen, die neue Lehrmethode gegen-ber den bestehenden Lehrmethoden und ihren Me-dien einzuordnen. Umfassende bersichten berAlgorithmen-Visualisierungen und Systeme zurErstellung solcher Visualisierungen bieten derSammelband [SDBP 1998] und die Dissertationvon Rling [Rling 2001b].

1.2.1 Statische Bilder und mechani-sche Lehrmittel

Bereits in frhen Lehrbchern zu Algorithmenwird die Datenstruktur grafisch dargestellt. Ein be-sonders schnes Beispiel findet sich in Abbildung2. Hier wird das Bild eines Rangierbahnhofs alsMetapher verwendet, um die Datenstruktur Doub-le-Ended-Queue (deque) zu illustrieren. Sie ist eineVerallgemeinerung einer Warteschlange und einesStapels. Elemente knnen jeweils am Anfang undEnde der Liste angefgt und entnommen werden.Die Darstellung ldt zum spielerischen Erkundenein. Man kann als Betrachter mit dem Finger dieGleise entlangfahren und an den Weichen ver-

schiedene Wege whlen. Nimmt man kleine Ge-genstnde wie z.B. verschiedenfarbige Reizwe-cken als Symbol fr Elemente, so kann man damitdie Double-Ended-Queue visualisieren und simu-lieren.

In der Regel findet man aber eine nchterne Dar-stellung der Datenstruktur vor. Oft wird in einerBildfolge die Vernderung der Datenstruktur ge-zeigt. Ein typisches Beispiel ist Abbildung 3, dieMomentaufnahmen aus dem Heapsort-Algorith-mus zeigt. Es werden dort solange Schlssel ver-tauscht, bis die Heapbedingung hergestellt ist.Zum besseren Verstndnis habe ich im Bild die Be-reiche markiert, die verndert werden oder vern-dert wurden.

Mechanische LehrmittelWill man als Leser selbst einen Ablauf durchspie-len, so wird man in der Regel die Grafiken fr meh-rere Momentaufnahmen zeichnen mssen. Alter-

Abb. 2: Double-Ended-Queue.[Knuth 1969], S. 236

1 Einleitung 13

nativ kann man ein mechanisches Lehrmittelherstellen, wie ich es fr Heapsort getan habe. Frdie Schlssel schnitt ich kleine Quadrate aus Pappeaus, die auf dem festen Hintergrund eines binrenBaumes mit leeren Knoten verschoben werdenknnen.

1.2.2 Neue Mglichkeiten im Medium Film

Der Ablauf eines Algorithmus kann auch als Filmdargestellt werden. Analog zur Trickfilm-Produk-tion spricht man dann von einer Algorithmen-Ani-mation. Zum einen erlaubt dies, viel mehr Zwi-schenzustnde der Datenstruktur zu zeigen, als esbei einer Bildfolge auf Papier mglich ist. Zum an-deren kann der bergang zwischen zwei Zustn-den der Datenstruktur mit weichen Bewegungendargestellt werden. Zum Beispiel kann man bei ei-nem Sortieralgorithmus zwei als Balken dargestell-te Schlssel in einer weichen Bewegung die Pltzetauschen lassen. Auch ist es einfacher die Auf-merksamkeit des Betrachters auf die entscheiden-den Stellen der Datenstruktur zu lenken, indemman z.B. Elemente kurz aufblinken lsst.

Meilenstein: Sorting out SortingDer Lehrfilm Sorting out Sorting von 1981 giltheute als Meilenstein in der Entwicklung des Ge-bietes Algorithmen-Animation ([Baecker 1981],[Baecker 1998]). In dem 30-mintigen vertontenFarbfilm werden 9 Sortieralgorithmen vorgestelltund miteinander verglichen. In Abb. 4 ist der gro-e Wettlauf der 9 Sortieralgorithmen zu sehen,der am Ende des Filmes gezeigt wird. Jeder Algo-rithmus hat dort ein ungeordnetes Array mit 2500Elementen zu sortieren. Das Array ist als Streu-graph dargestellt: die horizontale Achse entsprichtden Indizes und die Hhe der Punkte entsprichtdem unter dem Index gespeicherten Schlsselwert.Ein ungeordnetes Array erscheint als Punktwolke,ein sortiertes Array als Linie von links unten nachrechts oben. Bei den langsamen O(n^2) Algorith-men verndert sich die Punktwolke whrend des

Abb. 3: Heapsort-Vertauschungen[Ottmann, Widmayer 1996], S. 92

Hervorhebungen durch N.F.

Wettlaufes nur wenig. Bei den schnellen O(n logn)-Algorithmen bildet sich schnell die Linie. Sokann der Betrachter den Unterschied in der Lauf-zeit gut wahrnehmen. Gut zu erkennen sind auchdie Rechtecke, die sich bei Quicksort bilden. Sieentstehen zwischen Pivotelementen, die ihrenPlatz gefunden haben.

Im Gegensatz zu vielen spteren interaktiven Ani-mationen wurde dieser Lehrfilm didaktisch sorg-fltig gestaltet. Die Animationen werden von ei-nem Sprecher erklrt, wobei aktive Elementehervorgehoben werden. Whrend der Erklrungeines Algorithmus werden die Schritte der Anima-tion langsam abgespielt, damit die Betrachter denAlgorithmus verstehen knnen. Danach wird dasTempo gesteigert, damit der Algorithmus schnel-ler zum Ende kommt, und die Betrachter nichtdurch immer gleiche Schritte gelangweilt werden.

Nachteil des Mediums LehrfilmEin wesentlicher Nachteil des Mediums Lehrfilm(und teilweise auch der spteren interaktiven Ani-mationen) ist die passive Rolle der Studierenden.Es ist blich, dass Studierende als Hausaufgabeden Ablauf eines Algorithmus als Bildfolge zeich-nen sollen. Auch knnen sie mit statischen Bilderndie Funktionsweise eines Algorithmus mit Studi-enkollegen und Lehrenden besprechen. Da dieHerstellung eines Lehrfilms aber in der Regel sehraufwndig ist, knnen Studierende ihn nicht selbstproduzieren. Das Medium Lehrfilm steht alsbungs- und Kommunikationsmedium nicht zurVerfgung.

Abb. 4: Sorting out Sorting[Baecker 1981]; entnommen aus [Price, Baecker, Small 1993]

14 1.2 Historische Entwicklung: Algorithmen in grafischen Lernmedien

1.2.3 Interaktive Visualisierung

BALSAMit dem Aufkommen leistungsstarker Computermit grafischen Benutzungsoberflchen entstandein neues Medium: interaktive Algorithmen-Ani-mationen. Der Betrachter kann damit auf vielflti-ge Weise den Inhalt und die Gestaltung derAnimation beeinflussen. Insbesondere kann er denAblauf selbst steuern und z.B. in Einzelschrittendie Animation weiterschalten. Als Meilenstein isthier das System BALSA von Marc Brown anzuse-hen, das fr den Apple Macintosh erstellt wurde([Blumstengel 1998a], [Brown 1998]). Man kann alsBetrachter selbst eine Animation zusammenstel-len. Dazu:

1. Whlt man einen oder mehrere Algorithmen2. Verknpft man einen Algorithmus mit Sichten,

die die Operationen des Algorithmus auf derDatenstruktur oder seinen Pseudocode zeigen.Man kann die Fenster der Sichten auf dem Bild-schirm frei arrangieren, zoomen und scrollen.

3. Whlt man einen Satz Eingabedaten4. Startet man die Animation. Man kann die Ani-

mation kontinuierlich laufen lassen, unterbre-chen und fortsetzen. Oder man bewegt sich ineinzelnen Schritten durch die Animation.

Abb. 5 zeigt BALSA bei der Animation des Inserti-on Sort. Die linke Sicht zeigt das zu sortierende Ar-ray, wobei der aktuell einzufgende Schlssel alsSchatten dynamisch verschoben wird. In derrechten Sicht ist die gesamte bisherige Geschichteder bentigten Vergleiche und Vertauschungen vi-sualisiert.

Es ist auch mglich, mehrere Algorithmen parallelablaufen zu lassen. BALSA synchronisiert die Al-gorithmen dabei so, dass sie gleich viel Rechen-zeit pro Zeiteinheit der Animation erhalten.

Abb. 5: BALSA insertion sortBildschirmabzug von [Brown 1998]

Ein zentrales Konzept in BALSA sind die Interes-santen Ereignisse (interesting events). Der Autor ei-ner Animation legt fest, welche Operationen einesAlgorithmus interessant sind und in der Anima-tion gezeigt werden sollen. Die Sichten werden soprogrammiert, dass sie die interessanten Ereignis-se grafisch darstellen, indem sie z.B. die vernder-ten Teile der Datenstruktur neu zeichnen.

Der Betrachter ordnet den interessanten Ereignis-sen jeweils eine virtuelle Rechenzeit zu. BeimAblauf des Algorithmus werden diese Rechenzei-ten aufaddiert, so dass man am Ende die Gesamt-laufzeit ablesen kann.

Ebenso kann der Betrachter selbst entscheiden, aufwelche interessanten Ereignisse er besonders ach-ten mchte. Damit steuert er die Schrittweite derAnimation, d.h. an welchen Punkten die Animati-on pausiert und auf den Befehl des Betrachterszum Weiterlaufen wartet.

Animated Algorithms

BALSA ist ein reines Animationssystem, das keineerklrenden tutoriellen Texte und Grafiken bietet,wie man es von einem Lehrbuch gewohnt ist. Einweiterer Meilenstein war daher die Entwicklungdes Systems Animated Algorithms, das Anima-tionen mit tutoriellen Bestandteilen verbindet[Gloor 1998]. Es enthlt folgende, hypermedialverknpfte Elemente:

Digitale Videos, die die Bedienung des Systemserklren

24 Algorithmen-Animationen Einfhrende Texte und Grafiken zu den Anima-

tionen

Abb. 6: Animated AlgorithmsBildschirmabzug von [Gloor, Dynes, Lee 1993]

1 Einleitung 15

Das Lehrbuch Introduction to Algorithms[Cormen, Leiserson, Rivest 1990] in Hypertext-form

Abb. 6 zeigt einen Bildschirmabzug des Pro-gramms Animated Algorithms. Er enthlt Fens-ter mit Steuerung der Ausfhrung, Datenstruktur,Pseudocode und tutoriellem Text.

Die Lernumgebung wurde mit HyperCard frApple Macintosh Computer erstellt und wird alsCD-ROM vertrieben [Gloor, Dynes, Lee 1993].

Lernplattform WWWMit dem World Wide Web (WWW) ist eine neuePlattform fr interaktive Lernmedien entstanden.Bereits mit den Standardformaten des Web wie

HTML und GIF fr Text und Bilder und Java-App-lets fr interaktive Animationen lassen sich umfas-sende und interessante Lernmedien entwickeln.Sie lassen sich auf einfache Weise ber Webserverbereitstellen und sind plattformunabhngig innormalen Webbrowsern ausfhrbar.

Betrachtet man Lernmedien fr das individuelleLernen (im Gegensatz zu z.B. Teleteaching undkollaborativen Lernformen), so liegt der Vorteilder Lernplattform Internet hauptschlich im Zu-gang zu dem riesigen Informationsraum desWWW. Die einzelnen Lernmedien aus dem WWWsind per Mausklick ohne Beschaffungsaufwandund Installation verfgbar.

1.3 Akzeptanz und Effektivitt von Algorithmen-Animationen

Nach der exemplarischen Darstellung der histori-schen Entwicklung grafischer Lernmedien zu Al-gorithmen soll nun untersucht werden, in wel-chem Ma Algorithmen-Animationen in derAusbildung eingesetzt werden und welche Fakto-ren den Lernerfolg beeinflussen.

1.3.1 Verbreitung und Akzeptanz

Algorithmen-Animationen sind leicht er-hltlichEs sind heute eine Vielzahl von Algorithmen-Ani-mationen frei aus dem Internet erhltlich. In seinerDiplomarbeit ermittelte Frank Peters rund 200 in-teraktive Visualisierungen von Algorithmen, dieber das Internet erhltlich sind [Peters 2000]. Re-daktionell gepflegte Listen von Algorithmen-Ani-mationen finden sich z.B. beim Deutschen Bil-dungsserver [DBS 2001] und bei einer von GuidoRling gefhrten Datenbank [Rling 2001a].Eine bersicht ber weitere computergesttzteLernmedien zur Informatik stellen wir in der un-ten genannten OLLI-Sammlung bereit.

Studierende nutzen webbasierte Lernmedi-enIm Projekt Medienuntersttztes Studium der In-formatik [Gorny, Faltin 2000] haben wir 18 web-basierte Lernmedien zu Themen der Informatik er-

stellt und in der Sammlung OldenburgerLernprogramme zur Informatik (OLLI) [Faltin2001a] zusammengefasst. Sie knnen online undoffline zu den Bedingungen der GNU GeneralPublic License kostenlos genutzt werden.

Eine Auswertung der Zugriffe im Juni/Juli 2001 er-gab, dass an einem Tag durchschnittlich 137 Perso-nen (genauer: IP-Adressen) auf den Webserver zu-greifen, 1051 Seiten abrufen und 35 Dateienherunterladen. Etwa zwei Drittel der heruntergela-denen Dateien enthalten Archive der Lernpro-gramme fr Benutzer, der Rest enthlt Versionenfr die Weiterentwicklung der Lernprogramme.Die Lernmedien sind in der Regel in Deutsch ver-fasst, so dass wir vor allem Zugriffe aus demdeutschsprachigen Bereich verzeichnen.

Bei den Lernmedien aus OLLI handelt es sich umspezielle Themen, die wohl vor allem fr Informa-tikstudierende, kaum aber fr typische Informatik-Anwender oder Privatpersonen relevant sind.Selbst bei einer konservativen Schtzung, die nurvon den rund 20 Downloads der Nutzerversionender Lernprogramme am Tag ausgeht und reineOnline-Nutzer ignoriert, erhlt man die beachtli-che Zahl von etwa 7000 Personen im Jahr, die mitunseren webbasierten Lernmedien lernen. Darauskann man schlieen, dass das Interesse der Studie-renden an webbasierten Lernmedien offensichtlichgro ist.

16 1.3 Akzeptanz und Effektivitt von Algorithmen-Animationen

Wenige Lehrende nutzen Algorithmen-Ani-mationenDemgegenber wird von Fachleuten aus dem Be-reich Algorithmen-Animation immer wieder be-dauert, dass Algorithmen-Animationen nur vonwenigen Lehrenden in der Informatikausbildungeingesetzt werden ([Hundhausen 1999], S. 3). Souert sich z.B. Jim Foley, einer der Pioniere derComputergrafik, in der Einleitung der Aufsatz-sammlung Software Visualization:

My only disappointment with the fieldis that Software Visualization has not yethad a major impact on the way we teachalgorithms and programming or theways in which we debug our programsand systems. While I continue to believein the promise and potential of SV, it isat the same time the case that SV has notyet had the impact that many have pre-dicted and hoped for. ([SDBP 1998], S.xii)

In der Einladung zum Dagstuhl Seminar on Soft-ware Visualization 2001 waren die Teilnehmeraufgefordert worden die Frage zu errtern:

Why is software visualization not wide-ly used in education and software devel-opment? [SV 2001]

Auf dem Seminar war diese Frage das Thema einerDiskussionsveranstaltung. Die Teilnehmer best-tigten die Ansicht, dass Algorithmen-Animationenbisher nur wenig in der Lehre eingesetzt werden.

1.3.2 Untersuchungen zur Effektivitt

Diese Zurckhaltung knnte darin begrndet sein,dass die Lehrenden skeptisch sind, ob das Betrach-ten der derzeit verfgbaren Algorithmen-Animati-onen den Studierenden besser hilft, Algorithmenzu verstehen, als es die statischen Diagramme tun.

Einflufaktoren auf den LernerfolgEs gibt eine ganze Reihe Faktoren, die den Lerner-folg beeinflussen knnen. Es ist daher wichtig zuermitteln, welche Faktoren tatschlich eine Rollespielen und wie sie ausgeprgt sein sollen, um dasLernen von Algorithmen bestmglich zu unter-sttzten. In den letzten Jahren sind eine Reihe for-maler Experimente durchgefhrt worden, die diesber vergleichende Experimente ermittelt haben.Dabei wurden Gruppen von Studierenden unter-schiedlich unterrichtet und danach ihr neu erlang-tes Wissen in einem schriftlichen Test bewertet.

Die Daten wurden statistisch analysiert. Zeigtesich ein deutlicher (d.h. signifikanter) Unterschiedzwischen den Gruppen, so hatte der untersuchteFaktor einen Einfluss auf den Lernerfolg. Andern-falls konnte man schlieen, dass der Faktor in die-ser Lernkonstellation keinen wesentlichen Einflussauf den Lernerfolg hat.

Christopher Hundhausen listet in einer Meta-Stu-die die Ergebnisse zehn solcher Experimente auf([Hundhausen 1999], Kapitel 2.5). Wie mir Hund-hausen mitteilte kommt eine neue von ihm mitver-fasste, noch unverffentlichte Studie von 24 Expe-rimenten im Wesentlichen zu den gleichenSchlssen bezogen auf die Wichtigkeit aktiven Ler-nens [Hundhausen, Douglas, Stasko].

Abweichend von der Aufteilung bei Hundhausenfasse ich die Faktoren hier in drei Bereichen zu-sammen (Tabellen 1, 2 und 3):

Prsentation des AlgorithmusDer Algorithmus wird den Studierendenber Lernmedien prsentiert. Neben der Dy-namik der Medien wird hier die grafische Re-prsentation des Algorithmus und die Red-undanz der Darstellung betrachtet.Erstaunlicherweise gab es bei 6 von 8 Teilex-perimenten keine signifikanten Unterschiede.Die Studierenden scheinen das Wesentlichedes Algorithmus in all diesen Fllen ungefhrgleich gut aufgefasst zu haben.

Individuelle UnterschiedeIn zwei Teilexperimenten wurde untersucht,ob Personen mit berdurchschnittlichemrumlichen Vorstellungsvermgen oder ver-balen Fhigkeiten eine Algorithmen-Anima-tion besser dekodieren und damit den Algo-rithmus besser verstehen knnen. Es zeigtensich aber keine signifikanten Unterschiede.

Beteiligung der LernerIn der Praxis werden Algorithmen-Animatio-nen den Studierenden zumeist wie ein Filmgezeigt, den sie passiv betrachten. Man kannStudierende aber viel strker am Lernprozessbeteiligen, indem man ihnen die Aufgabe gibtden Algorithmus zu programmieren, Einga-bedaten zu erstellen, Schritte vorherzusagenoder selbst eine Animation zu erstellen. Diefnf hierzu durchgefhrten Teilexperimenteergaben durchgngig signifikante Ergebnis-se. Je strker die Studierenden am Lernpro-zess beteiligt waren, desto besser hatten sieden Algorithmus verstanden.

1 Einleitung 17

Tabelle 1: Einfluss der Prsentation auf den Lernerfolg

Faktor Betrachtete Werte

Anzahl Experimente

signifikant nicht signifikant

Lernmedium nur Text, Text und Animation 1

Reihenfolge Lernmedien zuerst Text, zuerst Animation 2

Gre Datensatz 9, 25 oder 41 Elemente 1

Darstellung der Daten horizontale Balken, vertikale Balken, Punkte 1

Farbigkeit farbig, schwarzwei 1

Beschriftung der Daten beschriftet, unbeschriftet 1

Benennung der Schritte benannt, unbenannt 1

Tabelle 2: Einfluss individueller Unterschiede

Faktor Betrachtete Werte

Anzahl Experimente

signifikant nicht signifikant

Rumliche Fhigkeiten Test zum Papierfalten 1

Sprachliche Fhigkeiten Vokabeltest 1

Tabelle 3: Einfluss der Beteiligung der Lerner

Faktor Betrachtete Werte

Anzahl Experimente

signifikant nicht signifikant

Beteiligung der Lerner 1.Passiv Animation betrachten2.Nach dem Betrachten der Animation den

Algorithmus programmieren3.Animation aktiv betrachten

- eigene Eingabedaten konstruieren- Schritte vorhersagen

4.Animation erstellen

5

Aktives Lernen als ErfolgsfaktorDie Skepsis vieler Lehrender gegenber Algorith-men-Animationen wurde durch diese Experimen-te in dem Sinn besttigt, dass die bewegte Darstel-lung allein noch kein besseres Verstndnisbewirkt. Die wesentliche Erkenntnis ist aber, dassAlgorithmen so gelehrt werden sollten, dass die

Studierenden sich aktiv mit dem Lehrstoff ausein-andersetzen knnen. Dies ist ein starkes Argumentdafr, neue Lehrformen zu entwickeln, die, demAnsatz dieser Arbeit entsprechend darauf abzie-len, die Studierenden aktiv in den Lernprozess ein-zubeziehen.

18 1.4 bersicht ber die folgenden Kapitel

1.4 bersicht ber die folgenden Kapitel

Es wird nun ein berblick ber die folgenden Ka-pitel gegeben. Fr Entwickler von Lernprogram-men zu Algorithmen sind vor allem Kapitel 4 bis 6interessant. Im Einvernehmen mit dem Betreuerder Arbeit wurden Teile der Kapitel 4 bis 6 aufFachtagungen prsentiert und in den Tagungsbn-den verffentlicht.

2 Lerngegenstand AlgorithmusDer Lerngegenstand Algorithmus wird ausfachdidaktischer Sicht betrachtet. Dazu wer-den Aussagen zum Algorithmusbegriff, zurDarstellung von Algorithmen und zur Bedeu-tung von Algorithmen aus bekannten Lehr-bchern und dem Informatik-Duden zusam-mengestellt.

3 Verwandte Arbeiten zum aktivem Lernenvon AlgorithmenEs werden verwandte Lehrmethoden vorge-stellt bei denen die Studierenden Algorith-men nicht nur als Animation betrachten son-dern aktiv erlernen. Diese Lehrmethodennutzen den Computer als interaktives grafi-sches Medium, um Algorithmen darzustel-len, unterscheiden sich aber in der Art derEinbeziehung der Studierenden in den Lern-prozess.

4 Die Gestaltungsmethode StrukturiertesAktives Lernen von Algorithmen (SALA)Im Rahmen dieser Arbeit wurde die MethodeStrukturiertes Aktives Lernen von Algorith-men (SALA) fr die Gestaltung von Lern-programmen zu Algorithmen entwickelt.Wie oben in der Einfhrung beschrieben,setzt sie auf ein entdeckendes Lernen ber in-teraktive grafische Simulationen eines Algo-rithmus. Als Beispiel wird gezeigt, wie nachder Methode ein Lernprogramm zum Heap-sort-Algorithmus entwickelt wurde.

5 Gestaltungsregeln fr interaktive Visuali-sierungen von AlgorithmenEs werden drei Arten interaktiver Visualisie-rungen von Algorithmen unterschieden: Ani-mation, bung und Simulation. Fr diesewerden Beispiele genannt und aus didakti-scher und software-ergonomischer Sicht Ge-staltungsregeln angegeben.

6 Software-Bibliothek SALABIMDie Java-Bibliothek SALABIM erleichtert dieErstellung interaktiver Visualisierungen vonAlgorithmen als Java-Applet. Der Algorith-mus und seine Visualisierung muss nur ein-mal programmiert werden und steht dann inden Modi Simulation, ben und Animationzur Verfgung. In den Modi ben und Simu-lation haben die Studierenden die Aufgabe,die Schritte des Algorithmus selbst auszufh-ren. Die Bibliothek realisiert die Ablaufsteue-rung der interaktiven Visualisierung, stelltTipps zur Lsung der Aufgabe bereit undkann Benutzereingaben mit den Schritten desAlgorithmus vergleichen.

7 Studierende bewerten SALA-Lernprogram-me und SALAZwei nach der Methode SALA gestalteteLernprogramme wurden in der Lehrveran-staltung Datenstrukturen erprobt. Die Stu-dierenden arbeiteten als Hausaufgabe mitden Lernprogrammen. Sie bewerteten auf ei-nem Fragebogen die Lernprogramme unddas dahinter stehende didaktische KonzeptSALA.

8 Analyse der Nutzung zweier SALA-Lern-programmeDie Nutzung der Lernprogramme wurde auf-gezeichnet. Die Daten werden ausgewertetum das Navigationsverhalten, die Intensittder Nutzung und das Verhltnis von Online-zu Offline-Nutzung zu ermitteln.

2 Lerngegenstand Algorithmus 19

2 Lerngegenstand Algorithmus

Dieses Kapitel betrachtet den Lerngegenstand Al-gorithmus aus fachdidaktischer Sicht. Will manein Lernmedium erstellen, so muss man sich berdie Aspekte des Lerngegenstandes und die Mg-lichkeiten seiner Darstellung bewusst sein, da die-se den Gestaltungsraum bilden. Daher werdennun Definitionen und Aussagen zum Algorith-musbegriff und zur Darstellung von Algorithmenaus Lehrbchern zu Algorithmen und aus Fachle-xika zusammengestellt. Das Kapitel dient auch zurDefinition grundlegender Begriffe, die in den fol-genden Kapiteln benutzt werden.

Bedeutung der AlgorithmenAlgorithmen spielen in der Informatik eine zentra-le Rolle. Fr viele Probleme der Informatik sind Al-gorithmen entwickelt worden. Auch in anderenformalen Wissenschaften wie der Mathematik sindsie von Bedeutung. Die zentrale Bedeutung wird inLehrbchern, wie z.B. bei Sedgewick und Ott-mann/Widmayer immer wieder angefhrt:

Algorithms are the 'stuff' of computerscience: they are central objects of studyin many, if not most areas of the field.([Sedgewick 1992], S. 4)

Sie [Algorithmen] sind das zentraleThema der Informatik. Die Entwicklungund Untersuchung von Algorithmen zurLsung vielfltiger Probleme gehrt zuden wichtigsten Aufgaben der Informa-tik. ([Ottmann, Widmayer 1996], S. 1,Hervorhebung im Original)

KapitelinhaltIn der Informatik gibt es eine lange Tradition desUmgangs mit Algorithmen. Es herrscht weitge-hende Einigkeit darber, welche formalen Bedin-gungen eine Verfahrensbeschreibung erfllenmuss, um als Algorithmus zu gelten. Zur Beschrei-bung eines Algorithmus gehren in der Regel derNachweis seiner Korrektheit und die Bestimmungdes Ressourcenbedarfs. Um das Verstndnis desAlgorithmus zu erleichtern, werden zumeist dieEigenschaften der Datenstruktur besprochen undein Ablauf als Beispiel angegeben. Auch die Nota-tion der Verfahrensbeschreibung und deren Mo-dularitt beeinflussen die Verstndlichkeit. Wer-den mehrere Algorithmen behandelt, so kann eshilfreich sein, gemeinsame Entwurfsprinzipien he-rauszuarbeiten.

2.1 Aspekte eines Algorithmus

2.1.1 Der Algorithmusbegriff

Definitionen des Algorithmenbegriffes finden sichz. B. in bekannten Lehrbchern zu Algorithmenund im Informatik-Duden. Da keine dieser vonmir untersuchten Quellen alle mir wesentlich er-scheinenden Merkmale nennt, stelle ich im Folgen-den die Merkmale aus verschiedenen Quellen zu-sammen.

Algorithmus: Verfahren zur Lsung einesProblemsEin Algorithmus ist ein Verfahren, das sich als Pro-gramm fr einen Computer implementieren lsst.Das Verfahren lst ein zuvor definiertes formalesProblem. Zu einer Instanz des Problems (der Ein-gabe) berechnet der Algorithmus eine Lsung (die

Ausgabe). Das Verfahren muss dabei fr alle Pro-bleminstanzen nach endlich vielen Schritten einResultat liefern (Terminierung) [DudenInf 1988].

The term algorithm is used in computerscience to describe a problem-solvingmethod suitable for implementation as acomputer program ([Sedgewick 1992],S. 4)

Informally, an algorithm is any well-defined computational procedure thattakes some value, or set of values, as in-put and produces some value, or set ofvalues, as output. An algorithm is thus asequence of computational steps thattransform the input into the output.We can also view an algorithm as a toolfor solving a well-specified computa-

20 2.1 Aspekte eines Algorithmus

tional problem. The statement of theproblem specifies in general terms thedesired input/output relationship. The al-gorithm describes a specific computa-tional procedure for achieving that input/output relationship. ([Cormen, Leiser-son, Rivest 1990], S. 1)

Anforderungen an das VerfahrenDie Beschreibung des Verfahrens muss folgendenAnforderungen gengen:

Statische Finitheit. Die Beschreibung des Verfahrens hat endli-che Lnge. ([DudenInf 1988], S. 27)

Definit (engl. Definiteness).Bei jeder Anweisung ist eindeutig klar, waszu tun ist. ([Knuth 1969], S. 5)

Ausfhrbar (engl. Effectiveness). Jede Anweisung ist ausfhrbar und ihre Aus-fhrung dauert endlich lange. ([Knuth 1969],S. 6)

Die weitaus meisten Algorithmen der Informatiksind deterministisch und determiniert:

Deterministisch. Zu jedem Zeitpunkt gibt es nur eine Fortset-zungsmglichkeit. ([DudenInf 1988], S. 27)

Determiniert. Wird der Algorithmus mehrfach mit gleicherEingabe gestartet, liefert er jedesmal die glei-che Ausgabe. ([DudenInf 1988], S. 27)

2.1.2 Korrektheit

Ein Algorithmus ist korrekt, wenn er fr jede Pro-bleminstanz in endlicher Zeit ein korrektes Ergeb-nis liefert. Meist wird in Lehrbchern im Begleit-text auf die Stellen des Algorithmus eingegangen,deren Korrektheit nicht unmittelbar einleuchtetund teils formal, teils umgangssprachlich argu-mentiert. Teilweise werden im Pseudocode zumNachweis der Korrektheit Schleifeninvariantenund Schleifenvarianten angegeben.

Die wichtigste formale Eigenschaft ei-nes Algorithmus ist zweifellos dessenKorrektheit. [...] Wo aber die Korrekt-heit eines Algorithmus nicht unmittelbaroffensichtlich ist, geben wir durch Kom-mentare, Angaben von Schleifen- undProzedurinvarianten und anderen Hin-weisen im Text ausreichende Hilfen, auf

die der Leser selbst formalisierte Kor-rektheitsbeweise grnden kann. ([Ott-mann, Widmayer 1996], S. 2)

2.1.3 Effizienz

Unter der Effizienz eines Algorithmus verstehtman seinen Verbrauch an Ressourcen wie Rechen-zeit und Speicherplatz in Abhngigkeit von derGre der Eingabe. Die Rechenzeit ist meist amschwierigsten zu berechnen. In der Regel wird imBegleittext ein Beweis skizziert, der sich auf Rekur-sionsgleichungen und Summenformeln sttzt. ImPseudocode findet man meist keine Kommentarezur Effizienz.

Die weitaus wichtigsten Mae fr dieEffizienz sind der zur Ausfhrung desAlgorithmus bentigte Speicherplatzund die bentigte Rechenzeit. ([Ott-mann, Widmayer 1996], S. 2)

2.1.4 Datenstruktur

Viele Algorithmen arbeiten auf komplexen Daten-strukturen. Zum Verstndnis des Algorithmus ge-hrt daher auch das Verstndnis der Datenstruk-tur.

Die meisten Algorithmen erfordern je-weils geeignete Methoden zur Struktu-rierung der von den Algorithmenmanipulierten Daten. Algorithmen undDatenstrukturen gehren also zusam-men. ([Ottmann, Widmayer 1996], S.1)

Most algorithms of interest involvecomplicated methods of organizing thedata involved in the computation. Ob-jects created in this way are called datastructures, and they also are central ob-jects of study in computer science. Thusalgorithms and data structures go hand inhand [...] and thus need to be studied inorder to understand the algorithms.([Sedgewick 1992], S. 4, Hervorhebungim Original)

2.1.5 Trace

Startet man einen Algorithmus auf konkreten Ein-gabedaten, so fhrt er eine Folge konkreter Schritteaus, die hier als Trace bezeichnet wird. Zu einemSchritt gehrt dabei auch die Vernderung der Da-ten. Bei der groen Mehrzahl der Algorithmenbe-schreibungen wird ein Beispiel des Ablaufes als

2 Lerngegenstand Algorithmus 21

Trace angegeben, indem zu wichtigen Zeitpunktendes Ablaufes die Daten des Algorithmus darge-stellt werden (siehe z.B. Abb. 3, S. 13).

2.2 Darstellung des Verfahrens

2.2.1 Pseudocode oder Programmcode

Ein Algorithmus kann auf verschiedene Weisendargestellt und implementiert werden, z.B. in ei-ner Programmiersprache, als Pseudocode oder alsHardwareimplementierung. In Lehrbchern wirdzumeist Pseudocode verwendet, da dies den Auto-ren die Mglichkeit gibt programmiersprachlicheNotation mit natrlichsprachlichen Anweisungenzu mischen. ([Cormen, Leiserson, Rivest 1990], S.2)

2.2.2 Modularitt

Whrend fr Programme im allgemeinen gefor-dert wird, dass sie modular und fehlerrobust er-stellt werden sollen (siehe z.B. [Meyer 1997]),scheint unter den von mir betrachteten Lehrbuch-autoren zu Algorithmen ein stillschweigenderKonsens zu bestehen, diese Anforderung bei derDarstellung von Pseudocode zu ignorieren. Sowerden z.B. Hilfsfunktionen nur eingefhrt, wenneine Funktion mehrfach verwendet wird. Dabei istden Lehrbuchautoren wohl bewusst, dass eine mo-dulare Darstellung leichter zu verstehen ist, dennder Algorithmus wird im Begleittext oft entlangdes logischen Aufbaus der Kontrollstruktur er-klrt. Bei den betrachteten Lehrbchern findet sichnur bei [Cormen, Leiserson, Rivest 1990], S. 2) eineAussage dazu:

Another difference betweenpseudocode and real code is thatpseudocode is not typically concernedwith issues of software engineering. Is-sues of data abstraction, modularity, anderror handling are often ignored in orderto convey the essence of the algorithmmore concisely

In dieser Arbeit wird ein modularer Ansatz ver-folgt, bei dem der Pseudocode auf mehrere Funkti-onen aufgeteilt wird. Dies soll einerseits das Ver-stndnis erleichtern, ermglicht andererseits aberauch erst das entdeckende Lernen ber Simulatio-nen.

Wiederverwendung eines AlgorithmusEin modularer Ansatz erleichtert auch die Wieder-verwendung eines Algorithmus oder seiner Be-standteile in einem neuen Kontext. Gelegentlichkann man einen bestehenden Algorithmus so ab-wandeln, dass er ein neues Problem lst. Dazu istes hilfreich, wenn der ursprngliche Algorithmusmglichst modular dargestellt war. Er muss dannnur an wenigen Stellen gendert werden.

Beispielsweise kann man den Heapbaum desHeapsort-Algorithmus verwenden, um eine Prio-ritten-Warteschlange zu realisieren (siehe dazudas Kapitel zum Lernprogramm Heapsort und([Ottmann, Widmayer 1996], S. 378). Ein weiteresBeispiel ist die Abwandlung des Quicksort-Algo-rithmus, um einen N-Order-Median zu bestim-men.

Algorithmen werden auch als Ganzes (unvern-dert) als Teil eines neuen Algorithmus genutzt. Sobentigt man fr die krzeste-Wege-Suche nachDijkstra eine Hilfsdatenstruktur, die die als Nchs-tes zu untersuchenden Knoten des Graphen spei-chert. Es bietet sich an, hierfr eine Priorittenwar-teschlange zu nutzen ([Ottmann, Widmayer 1996],S. 379-382).

2.2.3 Algorithmen und Entwurfsprinzi-pien

Ein Algorithmus wird in der Regel ausgehend voneinem Entwurfsprinzip entwickelt. Beispiele frEntwurfsprinzipien sind Divide and Conquer,Inkrementeller Entwurf und Backtracking. Lehr-bcher, die eine Sammlung von Algorithmen be-schreiben, benennen und erklren zumeist dasEntwurfsprinzip im Begleittext zum Algorithmus(z.B. [Ottmann, Widmayer 1996], [Sedgewick1992], grter Teil von [Cormen, Leiserson, Rivest1990]). Es kann aber auch umgekehrt ein Entwurf-sprinzip zum Thema werden, whrend eine Reihevon Algorithmen danach aus dem Blickwinkel die-ses Entwurfsprinzips beschrieben werden (insbe-sondere bei [Ottmann 1998], aber auch in Teilenvon [Cormen, Leiserson, Rivest 1990]). An ameri-

22 2.2 Darstellung des Verfahrens

kanischen Universitten werden die Vorlesungenzu Algorithmen oft nach den Entwurfsprinzipiengegliedert:

CIS 315, 'Algorithms', typifies the thirdyear undergraduate course taught withinthe computer science departments ofAmerican universities. In the course,students explore efficient algorithmicproblem-solving techniques, including

divide-and-conquer, dynamic program-ming, and greedy approaches.([Hundhausen 1999], S. 47)

Studierenden sollten mehrere Entwurfprinzipienerlernen, da diese nicht nur das Verstndnis vonAlgorithmen erleichtern, sondern auch als Struk-turierungstechniken beim Entwurf eigener Pro-gramme einsetzbar sind.

3 Verwandte Arbeiten zum aktivem Lernen von Algorithmen 23

3 Verwandte Arbeiten zum aktivem Lernen von Algorithmen

3.1 berblick

Die Untersuchungen zur Effektivitt von Algorith-men-Animationen ergaben, dass die bewegte Dar-stellung allein noch kein besseres Verstndnis desAlgorithmus bewirkt. Algorithmen sollten viel-mehr so gelehrt werden, dass die Lerner sich aktivmit dem Lehrstoff auseinandersetzen knnen (vgl.Kap. 1.3, S. 15). Daher werden nun neue Lehrme-thoden und Systeme betrachtet und bewertet, die,dem Ansatz dieser Arbeit entsprechend darauf ab-zielen, die Studierenden aktiv in den Lernprozesseinzubeziehen. In den Lehrmethoden haben dieLerner die Aufgabe, den Algorithmus auszufh-ren, eine Animation zum Algorithmus zu entwi-ckeln oder den Algorithmus zu programmieren.Einige weitere Systeme zum aktiven Lernen vonAlgorithmen werden in den bersichten vonHundhausen und Rling aufgefhrt ([Hundhau-sen, Douglas, Stasko], [Rling 2001b]). Es handeltsich dabei zumeist um Systeme, bei denen die Ler-ner den Algorithmus selbst ausfhren.

3.1.1 Lerner fhren Algorithmus aus

Die erste Klasse von Lehrmethoden lsst die Ler-ner den Algorithmus selbst ausfhren. Der Algo-rithmus wird zunchst auf klassische Weise in derVorlesung oder ber ein Lehrbuch gelehrt. Dannarbeiten die Lerner mit einer Lernumgebung, inder sie den Algorithmus auf Beispieldaten selbstausfhren knnen. Sie mssen sich dabei genau andie Schrittfolge des Standardverfahrens halten.Die unten genannten Methoden unterscheidensich darin, ob der Lerner Basisoperationen oderOperationen hherer Ordnung angeben muss.

Lernumgebung Algorithms in ActionDie Lernumgebung Algorithms in Action ent-hlt eine Reihe von Elementen, die fr ein eigen-stndiges Lernen wichtig sind und in vielen kon-ventionellen Algorithmen-Animationen fehlen([Stern, Sondergaard, Naish 1999], [Stern 2001]).Sie bietet ausfhrliche Erklrungen zum Algorith-mus als Ganzes und zu den einzelnen Teilen desPseudocodes. Der Pseudocode des Algorithmuswird als hierarchische Struktur dargestellt, bei derdie Lerner den gewnschten Detaillierungsgradeinstellen knnen.

Dieses Konzept des stepwise refinement ent-spricht in etwa der in SALA verwendeten funktio-nalen Struktur. Die Bestandteile werden aber imAllgemeinen nicht benannt und als Funktionen de-klariert, sondern ber ein kleines Ordnersymbolneben der Pseudocodezeile kenntlich gemacht.Durch Klicken auf das Symbol kann dieser Teil desPseudocodes auf- und zugeklappt werden. In Abb.7 ist der Teil Restore Heap Order und die darinenthaltene Downheap-Funktion aufgeklappt wor-den. Lsst man die Animation ablaufen, so ent-spricht ein Schritt in der Animation einer sichtba-ren Zeile im Pseudocode. Ist ein Teil desPseudocodes komplett eingeklappt, so wird dieserTeil also in einem Schritt ausgefhrt (in der Abbil-dung z.B. der Aufbau des Heap). Vorteilhaft istauch die flexible Ablaufsteuerung, mit der man inEinzelschritten vor und zurck durch die Animati-on gehen kann.

Die Lernumgebung bietet einen Animationsmo-dus (Normal Mode) und einen bungsmodus(Self Test Mode). Schaltet man in den bungs-modus, so wird man an bestimmten Stellen des Al-gorithmus aufgefordert, Parameter fr die aktuelleOperation anzugeben. Dazu whlt man Objekte inder grafischen Darstellung der Daten mit der Mausaus. Wurden die richtigen Objekte gewhlt, soluft der Algorithmus weiter, andernfalls hat maneinen weiteren Versuch. Nach drei Fehlversuchenwechselt die Lernumgebung in den Animations-modus zurck. In Abb. 8 ist Heapsort im Modusben dargestellt. Die Lernumgebung verlangt,dass der Kindknoten mit dem greren Schlsselausgewhlt wird. In der gesamten bung zu He-

Abb. 7: Stepwise Refinement bei Algorithms in ActionBildschirmabzug von [Stern 2001]

24 3.1 berblick

apsort werden nur die Basisoperation grererKindknoten finden und Zwei Schlssel vertau-schen abgefragt. Es wird also nur fr einen klei-nen Teil des Pseudocodes eine Interaktion angebo-ten, whrend der grere Teil automatisch abluft.Ein weiterer Schwachpunkt ist, dass die interakti-ven Basisoperationen sehr oft wiederholt werden.Als Lerner fragt man sich, warum man immer wie-der die gleichen Basisoperationen ausfhren muss.Dies lsst sich nicht abschalten, da die Lernumge-bung im bungsmodus die gewhlte Detaillierungdes Pseudocodes ignoriert.

Algorithms in Action bietet aus didaktischer Sichtvieles, was andere Lernumgebungen vermissenlassen. Innovativ ist besonders der bungsmodus,der aber noch ausgebaut und verbessert werdensollte.

JFLAP: formale Sprachen ineinander um-wandelnSusan Rodger entwickelte die LernumgebungJFLAP fr eine universitre Lehrveranstaltung zurAutomatentheorie [Hung, Rodger 2000]. JFLAP er-laubt es, Automaten interaktiv zu erstellen und zusimulieren (Abb. 9), sowie Automaten, Grammati-ken und regulre Ausdrcke ineinander umzu-wandeln. Die Reprsentationen der regulrenSprachen knnen in JFLAP auf drei Arten ineinan-der berfhrt werden. Bei der reinen Animationlsst sich der Nutzer schrittweise die Entstehungder neuen Reprsentation vorfhren. Im bungs-modus fhrt der Nutzer selbst einen Konstrukti-onsschritt aus und lsst diesen von JFLAP mit dementsprechenden Schritt des Standardverfahrensvergleichen. JFLAP analysiert die Teillsung undgibt Hinweise auf die festgestellte Abweichungvon der Standardlsung. Reicht der Hinweis nichtaus, so kann der Nutzer den Schritt von JFLAPausfhren lassen. Im Modus der Konstruktion er-

Abb. 8: Heapsort im Modus ben bei Algorithms in Action

Bildschirmabzug von [Stern 2001]

stellt der Nutzer ohne Hilfe die komplette Repr-sentation und lsst diese dann von JFLAP mit derMusterlsung vergleichen.

JFLAP ist ein leistungsfhiges und relativ ausge-reiftes Werkzeug, das mit dem bungsmodus einaktives Lernen ermglicht. Leider wird der jeweilsverwendete Konversionsalgorithmus nicht ange-zeigt, so dass man ohne externe Hilfsmittel (z.B.Lehrbuch) schwer den nchsten richtigen Schrittfindet. Es scheint auch kein erklrendes Lernmate-rial in die Lernumgebung integriert zu sein. JFLAPstellt den Algorithmus nicht strukturiert dar, sodass man nicht in greren Schritten, die hherenOperationen entsprechen, durch die Animationoder bung gehen kann. Da die Konversionsalgo-rithmen in allen Schritten ausgefhrt werden ms-sen, ist das Werkzeug nur fr kleine Beispiele ge-eignet.

3.1.2 Lerner entwickeln Algorithmen-Animation

Die Lerner knnen einen Algorithmus aktiv erler-nen, indem sie eine Animation zum Algorithmusentwickeln. Der Algorithmus wird den Lernernzunchst konventionell ber eine Vorlesung oderein Lehrbuch vermittelt. Anschlieend erhalten sieHilfsmittel und Werkzeuge, mit denen sie eineAnimation zum Algorithmus erstellen.

Stasko: Studierende entwickeln Animatio-nen mit SAMBAJohn Stasko setzte diese Lehrmethode in der uni-versitren Veranstaltung Design and Analysis ofAlgorithms ein [Stasko 1996]. Die Studierendenentwickelten als Hausaufgabe mit dem Visualisie-rungssystem SAMBA Animationen zu zwei Algo-rithmen. Anschlieend uerten sie sich auf einem

Abb. 9: Endlicher Automat in JFLAP[Rodger 2001]

3 Verwandte Arbeiten zum aktivem Lernen von Algorithmen 25

Fragebogen zu ihren Erfahrungen. Stasko ziehteine positive Bilanz zum Einsatz der Lehrmethode.Die Studierenden hatten die Algorithmen sehr gutverstanden und waren sehr motiviert bei der Ar-beit.

It also was clearly evident, however,that the animations helped the studentsto truly learn and understand the two al-gorithms under study. Feedback on thestudent surveys indicated this as studentsnoted how they felt that they understoodan algorithm well, but then discoveredhow their early conceptions were incor-rect. Likewise, although an informalmeasure, student performance on finalexam questions regarding the two algo-rithms was nearly perfect. ([Stasko1996], S. 11)

The animation assignments provided aforum that encouraged diligence, studyand creativity in the students, and didthis in an engaging way. Is this not thefundamental objective of education?(ebd., S. 12)

Stasko fhrt dies darauf zurck, dass die Studie-renden gerne programmieren und dass man ambesten lernt, wenn man lehrt.

Fundamentally, building an algorithmanimation forces a student to become theteacher, if only for a brief time. Instruc-tors certainly know that the best way tolearn a concept is to have to teach it.(ebd., S. 12)

Hundhausen: fachliche Kommunikations-fhigkeit entwickelnChristopher Hundhausen hat Staskos Lehrmetho-de empirisch untersucht und unter soziokulturel-len Gesichtspunkten weiterentwickelt. Seine Ar-beiten werden unten ausfhrlich besprochen (vgl.Kap. 3.3, S. 29). Hundhausen besttigt den Wertdieser Lehrmethode, kritisiert aber, dass es fr Stu-dierende recht aufwndig ist, Animationen mit Vi-sualisierungssystemen wie SAMBA zu erstellen.

Rling: Interaktiver Editor fr Animatio-nenEin Weg um den Aufwand fr die Studierenden zusenken, ist der Einsatz direkt-manipulativer Ani-mationseditoren, die hnlich einem Zeichenpro-gramm bedient werden. Als ein aktueller Vertretersoll hier der Animationseditor ANIMAL vorge-stellt werden.

ANIMAL wurde von Guido Rling an der Uni-versitt Siegen entwickelt [Rling 2001b]. DasWerkzeug luft plattformunabhngig unter Java.Es ist kostenlos verfgbar und auch ohne Netzan-bindung lauffhig. Neben der Vernderung derDaten kann der Pseudocode angezeigt werden,wobei die aktive Zeile hervorgehoben wird. DieSchritte der Animation knnen zeitlich genau ge-steuert werden. Animationen knnen ber API-Aufrufe, eine Skriptsprache oder einen interakti-ven Editor erzeugt werden. Mit dem Editor kn-nen Objekte auf die Zeichenflche platziert undverschoben werden (Abb. 10). Eigenschaften derObjekte, wie ihr dynamisches Verhalten, werdenber Dialogfelder eingestellt.

Dank der einfachen Bedienbarkeit konnten auchstudentische Tutoren Animationen mit ANIMALentwickeln, so dass nun rund 50 Animationen zurVerfgung stehen. Sie wurden in Vorlesungen ander Universitt Siegen verwendet, um Studieren-den Algorithmen zu erklren. Diese empfandendie Animationen als motivierend und als hilfreichfr das Verstndnis der Algorithmen.

3.1.3 Lerner programmieren Algorith-mus

Bei der dritten Kategorie des aktiven Lernens vonAlgorithmen erhalten die Lerner die Aufgabe, denAlgorithmus selbst zu programmieren. Der Pseu-docode des Algorithmus wird zunchst auf her-kmmliche Weise in einer Vorlesung oder ber einLehrbuch gelernt. Die Lerner arbeiten mit einerEntwicklungsumgebung, in der die Datenstrukturund grundlegende Basisoperationen des Algorith-mus bereits implementiert sind. Als wichtiger Ver-treter dieser Lehrmethode wird im folgenden Ab-

Abb. 10: ANIMAL - Interaktiver Editor fr Animationen[Rling 2001b], Fig. 1.

26 3.2 Visuelle Programmierung mit OPSIS

schnitt der Ansatz von Amir Michail besprochen,der Studierende den Algorithmus in einer visuel-len Programmiersprache entwickeln lsst.

3.2 Visuelle Programmierung mit OPSIS

3.2.1 bersicht

Amir Michail stellt in [Michail 1996] eine Lehrme-thode fr Algorithmen vor, die Elemente aus denBereichen Programmierung und Algorithmen-Animation mit Beweistechniken kombiniert. DieStudierenden erstellen in einer fr diesen Zweckgeschaffenen visuellen Programmiersprache Algo-rithmen fr binre Suchbume. Der erstellte Pro-grammgraph ist zugleich eine Art visueller Beweisfr die Korrektheit des Programms. Anschlieendknnen sie das visuelle Programm auf Beispielda-ten ausfhren und erhalten einen visuellen Tracedes Programms. Der Trace zeigt in einer Folge sta-tischer Bilder, die ausgefhrten Operationen unddie Zustnde der Datenstruktur.

3.2.2 Notation der visuellen Program-miersprache

Abb. 11 zeigt ein visuelles Programm fr die Suchenach einem Knoten mit Schlssel K in einem bin-ren Suchbaum. Ein Knoten des Programmgraphensteht fr eine Menge von konkreten Binrbumen,die bestimmte Bedingungen erfllen. Das grafi-sche Symbol des Knotens beschreibt den Aufbaudes binren Baumes aus Fragmenten. Die Farbeder Fragmente bezeichnet die Bedingung, die frdie Knoten des Fragmentes gilt. So steht z.B. Pinkfr Knoten kleiner K und Magenta fr Knoten gr-er K. Unter dem Symbol ist die Operation angege-ben, die in diesem Zustand ausgefhrt wird. Para-meter der Operation sind dabei die gestricheltumrahmten Fragmente. Nach Ausfhrung derOperation kann die Datenstruktur verschiedeneZustnde haben. Daher gibt es zu einem Zustanddes Programmgraphen ein oder mehrere Folgezu-stnde. Schleifen entstehen dadurch, dass der Fol-gezustand ein bereits bestehender Zustand ist (inAbb. 11 ist dies von (4a) nach (2) der Fall).

3.2.3 Programme sind nicht struktu-rierbar

Whrend kleine Programme, wie das in Abb. 11,gut zu berblicken sind, werden grere Program-me schnell unbersichtlich. Dieses Phnomenzeigt sich bereits beim dritten Programm ([Michail1996], S. 4, Fig. 3). Michails visuelle Programmier-sprache enthlt keine Mechanismen, um bereitsdefinierte Programme als Hilfsfunktionen aufzu-rufen. Hilfsfunktionen wrden es aber erlauben,grere Programme in berschaubare Teile zu zer-legen, die getrennt verstanden und bearbeitet wer-den knnen. Michail begrndet seine Ablehnungeiner solchen Strukturierung mit dem erhhtenLernaufwand der Studierenden. Dass Hilfsfunkti-onen eigentlich bentigt werden, sieht man aberbereits im zweiten Programm ([Michail 1996], S. 3,Fig 2). Michail durchbricht dort die von ihm ge-schaffene Notation, indem er die zuvor definierteSuchen-Funktion als Hilfsfunktion aufruft.

Abb. 11: Visuelles Programm fr Suche im Binrbaum[Michail 1996], S. 3, Fig. 1

3 Verwandte Arbeiten zum aktivem Lernen von Algorithmen 27

3.2.4 Das Werkzeug OPSIS

Fr die visuelle Programmiersprache entwickelteMichail den grafischen Editor und Interpreter OP-SIS. Abb. 12 zeigt OPSIS im Editiermodus. In derMitte ist ein Zustand des Programmgraphen dar-gestellt. Der Nutzer selektiert Fragmente undwhlt eine Operation aus. Daraufhin erzeugt OP-SIS automatisch die Folgezustnde. Dies wieder-holt der Nutzer, bis alle bentigten Zustnde er-zeugt sind und das visuelle Programm damiterstellt ist.

Programmgraph wird nicht dargestelltDer Programmgraph wird allerdings nicht als Gra-fik dargestellt. OPSIS stellt nur einen kleinen Aus-schnitt aus einer Liste der Zustnde dar (Abb. 12,rechts neben dem aktuellen Zustand). Als Nutzerhat man daher nie den berblick, den z.B. Abb. 11bietet. Auch ersetzt der Nachfolgezustand ber-gangslos den bisher aktuellen Zustand auf demBildschirm. Beides erschwert nach meiner Erfah-rung mit OPSIS die Orientierung im Programm-graphen. Entsprechend uert sich auch eine Nut-zerin:

When a change was made and I pro-gressed to the next state it was almostimpossible to find where I had previous-ly been working. ([Michail 1996], S.12)

Abb. 12: OPSIS im EditiermodusBildschirmabzug von [Michail 1998]

Mchtige OperationenMichail stellt bewusst recht mchtige Operationenzur Verfgung, die es den Studierenden ermgli-chen, sich auf den Kern des Algorithmus zu kon-zentrieren. Sie sollen davon entlastet werden, sichGedanken um Implementierungsdetails, wie z.B.der Verwaltung von Zeigern, zu machen.

Generally speaking, one should provideoperations that are high-level but that donot trivialize the algorithm being taught.Moreover, we provide only operationsthat maintain the key ordering propertyof the binary search tree; otherwise, wefeel that the operation is too low-leveland error prone. ([Michail 1996], S. 6)

Ausfhren des ProgrammsNachdem das Programm erstellt ist, knnen es dieStudierenden auf Beispieldaten ausfhren. Abb. 13zeigt einen von OPSIS erzeugten visuellen Tracezum Programm aus Abb. 11.

Abb. 13: OPSIS im TracemodusBildschirmabzug von [Michail 1998]

28 3.2 Visuelle Programmierung mit OPSIS

3.2.5 Erprobung der Lehrmethode

Michail erprobte die Lehrmethode in den bun-gen einer Vorlesung zu Algorithmen und Daten-strukturen. Die Hrer studierten Informatik alsNebenfach (non-majors) und waren im drittenStudienjahr. Sie hatten die Aufgabe, sich eigen-stndig zwei Algorithmen auf balancierten bin-ren Suchbumen aus Lehrbchern zu erarbeitenund anschlieend zu programmieren. Mindestenseiner der Algorithmen musste mit OPSIS imple-mentiert werden. Fr den verbleibenden Algorith-mus konnte eine textuelle Programmierspracheverwendet werden.

Aus der Erprobung ergaben sich u.a. folgende Er-kenntnisse:

Es gelang den Studierenden, sich in das fr sieneue Paradigma der visuellen Programmierungeinzudenken und die Algorithmen mit OPSIS zuprogrammieren.

Entgegen der Erwartung der Autoren zeigte sichweder beim Programmieraufwand noch beimVerstndnis des Algorithmus ein eindeutigerUnterschied zwischen Gruppen die einen Algo-rithmus visuell programmiert hatten und denen,die ihn textuell implementierten. Die Autoren er-klren dies mit der zu kleinen Stichprobe, da nuracht Gruppen teilgenommen hatten und dieWerte sehr stark von Gruppe zu Gruppeschwankten.

Die Studierenden gaben an, dass die Visualisie-rungen der binren Bume und der Schleifenin-varianten ihnen geholfen hatten, die Algorith-men besser zu verstehen.

3.2.6 Bewertung des Ansatzes

Abstraktion und StrukturierungAbstraktion und Strukturierung sind meines Er-achtens sehr wesentliche Arbeitsmittel der Infor-matik. Vergleicht man OPSIS mit typischen Algo-rithmen-Animationen, so fllt an OPSIS der hoheGrad an Abstraktion auf. OPSIS arbeitet auf abs-trakten Zustnden der Datenstruktur, die ber Be-dingungen auf Fragmenten definiert sind. Da-durch lassen sich die wesentlichen Flle derBelegung der Datenstruktur kompakt darstellen.

Neben der Datenstruktur wird auch die Lsungdes algorithmischen Problems auf der Ebene einesallgemeingltigen Programms angegegangen stattauf der Ebene von Schrittfolgen (Trace) fr mehre-re Probleminstanzen (Eingabedaten). Hilfreich fr

die Studierenden sind die leistungsstarken Opera-tionen, die OPSIS zum Aufbau der Lsung bereit-stellt.

Als groer Nachteil erscheint mir das Fehlen vonHilfsfunktionen in OPSIS. Das Abstraktionsniveauist dadurch festgefroren. Es ist den Studierendennicht mglich, ihr Programm zu strukturieren undProgrammteile fr verwandte Probleme wiederzu-verwenden.

Die Abstraktion der Datenstruktur und der Pro-grammschritte ermglichen es, mit einem visuel-len Programm gleichzeitig eine Art visuellen Be-weises der Korrektheit des Programmes zuerstellen. Meines Wissens hat Michail damit Neu-land betreten. Im Bereich der Algorithmen-Anima-tion kenne ich keine derartige Verknpfung vonBeweistechniken mit visuellen Darstellungen derDatenstruktur. Ich sehe hierin eine kreative Leis-tung Michails und einen Fortschritt fr die Aus-drucksmglichkeiten in der Darstellung von Algo-rithmen fr Lehrzwecke. Es ist damit mglich, inVorlesungen einen Beweis fr die Korrektheit ei-nes Algorithmus sehr anschaulich auszudrcken.Der Dozent kann z.B. den Programmgraphen wieeine Karte durchgehen und die Beweisschrittemndlich kommentieren.

Visualisierung und InteraktionDie Visualisierung der abstrakten Zustnde derDatenstruktur ist ansprechend und aussagekrftig.OPSIS setzt moderne Interaktionstechniken ein. Sowird die Fragmentfarbe in OPSIS textuell erklrt,sobald man mit dem Mauszeiger ein Fragment be-rhrt (Tooltip). Operationen werden einfach auseiner Liste ausgewhlt und ihre Parameter in derDatenstruktur markiert.

Zu bemngeln ist, dass der Zustandsgraph in OP-SIS nicht visualisiert und der Folgezustand ber-gangslos eingeblendet wird.

Lernuntersttzung und Aktivitt Die von Michail prsentierte Lehrmethode unddas Werkzeug OPSIS bieten kaum Untersttzungfr ein eigenstndiges Lernen, wie es z.B. im Fern-studium blich ist. Mit dem Werkzeug sind keineLehrtexte zum Lerninhalt oder den Aufgaben ver-knpft. OPSIS bercksichtigt nicht, dass geradeeine Aufgabe bearbeitet wird. Es gibt keine kon-textabhngigen Tipps zur Lsung der Aufgabe,keine Hinweise wie nahe man einer Lsung ge-kommen ist und keine Musterlsung. Erschwe-rend kommt hinzu, dass den meisten Studierenden

3 Verwandte Arbeiten zum aktivem Lernen von Algorithmen 29

das Paradigma der visuellen Programmierungund die hier genutzte Notation noch unbekanntsein drften.

Positiv an der Lehrmethode ist, dass die Studieren-den sehr aktiv lernen, indem sie selbst einen Algo-rithmus programmieren. Dies ist wesentlich an-spruchsvoller, als z.B. einen gegebenenAlgorithmus von Hand abzuarbeiten oder dieSchritte eines Algorithmus fr eine konkrete Pro-bleminstanz zu finden. OPSIS wurde im Rahmeneiner klassischen Prsenzveranstaltung erfolgreicherprobt. Fr ein eigenstndiges Lernen, z.B. im

Rahmen eines Fernstudiums, sollte es aber umLehrtexte und kontextabhngige Hilfen zur L-sung der Aufgaben erweitert werden.

FazitMichails Lehrmethode und das Werkzeug OPSISsind ein innovativer und vielversprechender An-satz, Algorithmen visuell und aktiv zu lernen. Umden Studierenden ein eigenstndiges Lernen zu er-mglichen, mssten die genannten Schwchen be-seitigt werden. Leider scheinen die Arbeiten andem Projekt aber seit einigen Jahren zu ruhen.

3.3 Studierende entwickeln und prsentieren Animationen

3.3.1 Lerntheoretischer Hintergrund

In der Wirtschaft und an den Hochschulen werdenviele Entwicklungsaufgaben im Team bearbeitet.Die entwickelten technischen Systeme werden denFachkollegen prsentiert und mit diesen disku-tiert. Deshalb sollte ein Informatiker nicht nurFachwissen, sondern auch die Kompetenz besit-zen, ber technische Inhalte zu kommunizieren.Neuere pdagogische Richtungen greifen dieseAnforderung auf und betonen das Lernen in sozi-alen Zusammenhngen sowie die Anwendung deserlernten Wissens zur Lsung von Problemen.

Christopher Hundhausen ordnet seine Arbeiten indie Lerntheorie des Soziokulturellen Konstruktivis-mus ein ([Hundhausen 1999], Kap. 3). Das Lehrzielist dort, dem Studierenden Fachwissen und sozialeFhigkeiten zu vermitteln, die es ihm ermglichen,ein vollwertiges Mitglied einer professionellen Ar-beitsgruppe zu werden. Als eine entscheidende so-ziale Kompetenz fr die Mitarbeit in einer Arbeits-gruppe zu Algorithmen sieht Hundhausen dieFhigkeit, einen Algorithmus visuell aufzuberei-ten und mit Fachkollegen ber Ablauf, Korrektheitund Effizienz des Algorithmus zu diskutieren.

3.3.2 Erprobung der Lehrmethode

Hundhausen entwickelte Aufgaben zur VorlesungAlgorithms an der Universitt von Oregon(USA), die es den Studierenden ermglichen soll-ten, diese Fhigkeit auszubilden ([Hundhausen1999], Kap 4). Die Studierenden sollten selbst eineAlgorithmen-Animation entwickeln, diese an-schlieend vor dem Dozenten und den Mitstudie-

renden prsentieren und Fragen zum Algorithmusmit ihnen diskutieren. Das Verhalten und die Ein-schtzung der Studierenden erfasste Hundhausenmit ethnographischen Techniken wie teilnehmen-der Beobachtung, Videoaufzeichnung und Frage-bogen. Im ersten Durchlauf der Veranstaltung er-stellten die Studierenden die Animationen mitdem Visualisierungssystem SAMBA. Es zeigte sichaber, dass dabei sehr viel Implementierungsarbeitanfiel, die von der Beschftigung mit den Kernfra-gen des Algorithmus ablenkte. Daher wurde imfolgenden Semester die Aufgabenstellung vern-dert.

Beliebige Eingabe oder Satz Beispieldaten