Embed Size (px)
Citation preview
<<<<<Ruprecht-Karls-Universität Heidelberg>>>>><<<Fakultät für Mathematik und Informatik>>>
Sortieralgorithmen und Laufzeiten
Name: Thomas Engelhardt
Kurs: Fachdidaktik Informatik
Dozentin: Frau Prof. Dr. Barbara Paech, Elisabeth Kraus
Datum: 15.02.2012
E-Mail: [email protected]
Table of Contents1.Rahmenbedingungen...............................................................................................................................32. Meine Vorbereitung auf das Thema....................................................................................................... 43. Lehrplanbezug........................................................................................................................................5
3.1 Der Bezug der Stunde zu den Leitgedanken des Informatikunterrichts..........................................53.2 Allgemeinbildung und Informatik................................................................................................... 7
4. Lernziele.................................................................................................................................................94.1 Prinzipielles Verständnis eines Quelltextes..................................................................................... 9
4.1.1 Umgang mit einem Quelltext...................................................................................................94.1.2 Umgang mit verschiedenen Datentypen..................................................................................94.1.3 Umgang mit Feldern................................................................................................................ 9
4.2 Schulung der Kontrollstrukturen................................................................................................... 104.2.1 Abfragen................................................................................................................................ 104.2.2 Schleifen................................................................................................................................ 104.2.3 Zusammenspiel der Abfragen und Schleifen.........................................................................10
4.3 Laufzeiten......................................................................................................................................104.3.1 Quadratisches Wachstum.......................................................................................................104.3.2 Die O-Notation...................................................................................................................... 11
5. Motivation und didaktische Mittel....................................................................................................... 115.1 Motivation „Youtube-Video“.........................................................................................................115.2 Didaktische Mittel......................................................................................................................... 11
6. Verlaufsplan und Zeitplanung.............................................................................................................. 146.1 Begründung für die Zeitplanung................................................................................................... 146.2 Unterrichtsverlaufsplan................................................................................................................. 15
7. Tatsächlicher Verlauf der Doppelstunde.............................................................................................. 167.1 Unmittelbar vor dem Unterricht.................................................................................................... 167.2 Vorstellung und Motivation...........................................................................................................167.3 Funktionsweise der Sortieralgorithmen.........................................................................................177.4 Laufzeiten des Prozessors............................................................................................................. 177.5 Praktische Arbeitsphase I: Programmierung von “Bubblesort” und “Selection Sort”..................18
7.5.1 Praktische Arbeitsphase I: Programmierung von “Bubblesort” und “Selection Sort”.........197.6 Ergebnissicherung......................................................................................................................... 197.7 Praktische Arbeitsphase II: Umsetzung der Zeitmessung in Delphi............................................. 207.8 Zeitmessung...................................................................................................................................207.9 Abschlussgespräch.........................................................................................................................20
8. Fazit......................................................................................................................................................219. Literaturverzeichnis..............................................................................................................................23
1.Rahmenbedingungen
Die Doppelstunde Informatik zum Thema „Sortieralgorithmen und Laufzeiten“ hielt ich in einer 12.
Klasse am Friedrich-Ebert-Gymnasium in Sandhausen. Da 2012 bekanntlich der erste G8-Jahrgang in
Baden-Württemberg das Abitur absolviert, setzt sich die Klasse sowohl aus Schülern des 9-jährigen
Zuges, als auch des 8-jährigen Zuges zusammen.
Die Schüler des 9-jährigen Zuges hatten im Jahr zuvor mit dem Informatikunterricht begonnen und die
Schüler des 8-jährigen Zuges hatten bereits in Klasse 10 eine Wochenstunde Informatikunterricht.
Informatik ist an dieser Schule lediglich ein Wahlfach und folglich finden sich in diesem Kurs
hauptsächlich interessierte SchülerInnen. Des Weiteren können die Schüler in diesem Fach keine
Abiturprüfung ablegen.
Diese Klasse teilt sich in 3 Schülerinnen und 10 Schüler auf. Von diesen sind 5 aus dem 9-jährigen und
8 aus dem 8-jährigen Zug. Besondere Vorkenntnisse im Programmieren, welche außerhalb der Schule
erworben wurden, weist laut Aussage der Lehrerin niemand auf. Laut ihr befinden sich in der Klasse
einerseits einige Schüler die durchaus Potential, jedoch wenig Arbeitseifer aufweisen, andererseits
einige Schüler die weniger Potential, jedoch eine Menge Arbeitseifer zeigen.
Im laufenden Schuljahr 2011/2012 wurde die Klasse neu zusammengestellt. Der Großteil der Klasse
hatte im Jahr zuvor das Programmieren mit Delphi gelernt. Der kleinere Teil, welcher lediglich aus
zwei Schülern besteht hatte den Umgang mit Java gelernt. Es lässt sich also feststellen, dass die Klasse
aufgrund der Einführung von G8 und der Zusammenlegung zweier unterschiedlicher Klassen sehr
heterogen ist.
Der Unterricht findet Donnerstags in der ersten und zweiten Schulstunde statt. Aus diesem Grund sind
die Schüler, laut ihrer Lehrerin, meist noch etwas verschlafen und einige verspäten sich regelmäßig.
Offiziell beginnt der Unterricht daher um 7.45 Uhr, da viele Schüler zu spät kommen ist dies jedoch
eher selten praktisch möglich.
Die Computer, mit denen der Raum ausgestattet ist, sind ziemlich veraltet, jedoch muss gelobt werden,
dass mit insgesamt 35 Computern mehr als genug Rechner vorhanden sind, um die Schüler einzeln an
einem Computer arbeiten zu lassen. Auf den Rechnern ist das Betriebssystem Windows-Vista
installiert. Zahlreiche Programmierumgebungen wie z.B. Delphi, BlueJ und Scratch sind ebenfalls
vorinstalliert. Darüber hinaus verfügt der Raum über einen festen Beamer der an den Lehrer-Computer
angeschlossen ist. Neben der Projizierfläche des Beamers befindet sich ein Whiteboard, welches mit
dafür bestimmten Stiften beschrieben werden kann. Es bleibt festzuhalten, dass man beide parallel
benutzen kann.
Da ich an dieser Schule von September bis Dezember 2011 mein Praxissemester absolvierte, hatte ich
einige Male die Gelegenheit den Unterricht dieser Klasse zu hospitieren, um einen ersten Eindruck zu
erhalten.
Die Doppelstunde zum Thema „Sortieralgorithmen und Laufzeiten“ wurde direkt nach den
Weihnachtsferien am 12.01.2012 als Einführung in das Thema Laufzeiten gehalten. Vor den
Weihnachtsferien beschäftige sich die Klasse zunächst mit dem Thema Schaltungslogik bzw. Boolesche
Algebra und anschließend ausführlich mit dem Thema Datenbanken. Ursprünglich sollte im Anschluss
an die Einführung in die Laufzeiten eine Doppelstunde zum Thema Kryptologie folgen. Da die Klasse
das Thema Datenbanken jedoch noch nicht vollends abgehandelt hatte, wurde in der Folgestunde
nochmals dieses Thema behandelt.
2. Meine Vorbereitung auf das Thema
Das Thema an sich suchte ich mir nicht selbst aus, sondern es wurde mir von der Lehrerin, welche
diese Klasse normalerweise unterrichtet, zugeteilt. Da ich die Arbeit mit dem Computer im Informatik-
Unterricht als unerlässlich erachte entschied ich mich dafür eine praktische Programmierübung mit in
den Unterricht einzubinden. Die Behandlung der Sortieralgorithmen wurde im Bezug auf die
Laufzeiten eines Computers vom Lehrbuch, welches an dieser Schule Standard ist, empfohlen.1
Diesbezüglich muss angemerkt werden, dass lediglich die Lehrer, nicht aber die Schüler im Besitz
dieses Lehrbuches sind.
Bezüglich der praktischen Übung wurde mir von der Lehrerin nahe gelegt, dass ich diese in Delphi
durchführen lassen sollte. Da ich selbst der Sprache noch nicht mächtig war, brachte ich sie mir anhand
eines Lehrbuches, „Delphi für Kids“, bei.2 Hierzu ist anzumerken, dass es sich bei Delphi nicht um ein
Open-Source-Produkt handelt sondern um ein Produkt, welches kommerziell vertrieben wird. Durch
den Kauf des Buches erhält man jedoch auch eine Vollversion von Delphi 7, welche völlig ausreicht um
den Schülern Grundlagenwissen zu vermitteln.
Auf der Grundlage von C++ lässt sich Delphi sehr schnell erlernen und ich war nach kurzer Zeit in der
Lage dazu Programme in Delphi zu erstellen. Daher konnte ich das Programm, welches die Schüler als
Basis für ihr Programm nutzen sollten, sehr schnell programmieren.
Auf den Computern im Friedrich-Ebert-Gymnasium ist lediglich eine Vollversion von Delphi 2
1 Peter Brichzin, Ulrich Freiberger, Klaus Reinold, Albert Wiedemann: Informatik I. Funktionale Modellierung, Datenmodellierung, Oldenburg 2007, S. 130.
2 Schumann, Hans-Georg: Delphi für Kids, Heidelberg 2008.
installiert. Dies führte, wie ich später bemerkte, zu Kompatibilitätsproblemen. Die dynamischen Felder,
welche ich an meinem Computer in Delphi 7 programmiert hatte, existierten in Delphi 2 nicht. Zum
Glück überprüfte ich die Funktionalität meines Programms am Montag vor der Unterrichtseinheit. Da
sich zu Delphi 2 nur sehr schwer bzw. gar kein Material finden lässt und mir die Lehrer versicherten,
dass dynamische Felder in Delphi 2 nicht existierten entschied ich mich für eine wenig elegante, doch
effiziente Lösung meines Problems. Anstelle eines dynamischen Feldes deklarierte ich einfach ein Feld,
dessen Größe die für meine Zwecke erforderliche weit übertraf.
In puncto didaktische Reduktion des Laufzeiten-Themas entschied ich mich ebenfalls streng die
Anweisungen des Buches einzuhalten und das Thema auf die Formulierung der Gaußschen
Summenformel und die Einführung der O-Notation zu beschränken.3 Komplexere Sachverhalte wie das
„Traveling Salesman Problem“, das „Damenproblem“ oder das „Türme von Hanoi Problem“ wollte ich
vorerst nicht behandeln.
Im Lehrbuch befand sich auch eine Tabelle, welche Zeitmessungen für die Umsetzung eines Befehls in
einer Hochsprache auf der Prozessorebene anzeigte.4 Da ich diese Tabelle auch für mich selbst als sehr
informativ erachtete, entschloss ich mich sie den Schülern ebenfalls zu präsentieren.
Nach einer kurzen Rücksprache mit der Lehrerin von der Schule und der mir zugewiesenen
didaktischen Fachkraft von der Universität stand der stoffliche Inhalt meiner Unterrichtsstunden nun
fest.
3. Lehrplanbezug
3.1 Der Bezug der Stunde zu den Leitgedanken des Informatikunterrichts
Bereits unter den Leitgedanken zum Kompetenzerwerb lässt sich das Thema finden. In der
Beschreibung der Leitgedanken wird erwähnt, dass die Schüler „ein systematisches und zeitbeständiges
Grundwissen, das über reine Bedienerfertigkeiten hinausgeht und auch Kenntnisse über die
Wirkprinzipien, die innere Struktur, die Möglichkeiten und Grenzen informationstechnischer Systeme
umfasst” erlernen sollen.5
Ein „systematisches und zeitbeständiges Grundwissen“ erlernen die Schüler in der Programmierung der
Sortieralgorithmen, indem sie programmiertechnische Grundwerkzeuge wie Schleifen oder „if-
Abfragen“ anwenden.6 Außerdem gehören auch die Suchalgorithmen selbst meines Erachtens zur
3 Brichzin, S. 133/134.4 Ebenda, S. 125.5 Bildungsplan 2004, S. 438. 6 Bildungsplan 2004, S. 438.
Kategorie „zeitbeständiges Grundwissen“.7
Ein Gefühl für „die Möglichkeiten und Grenzen informationstechnischer Systeme“ entwickeln die
Schüler durch die Analyse der Laufzeiten der Sortieralgorithmen. Da dies ein sehr weites Feld ist,
werden die Schüler in dieser Einführungsstunde lediglich dafür sensibilisiert.8
Auch die Forderung, den Schülern „Strategien zur Lösung komplexer Probleme” zu vermitteln, wird
durch die Behandlung der Sortieralgorithmen erfüllt.9 Dies wird durch das Arbeiten mit dem
Pseudocode gewährleistet.
In dem Kapitel „Kompetenzen und Inhalte“ lässt sich das Thema im zweiten Kapitel, „2. Leitidee
'Algorithmen und Daten'“, wiederfinden.10 Die Doppelstunde behandelt alle Unterpunkte, welche in
diesem Kapitel genannt werden. Während der Programmierphase müssen die Schüler die elementaren
Datentypen anwenden, „Algorithmen entwerfen“ und „Benutzerschnittstellen mit einfachen
Komponenten gestalten“.11 Der Punkt „Algorithmen entwerfen“ kann bestritten werden, da die Schüler
lediglich den Pseudocode umsetzen müssen, jedoch muss gesagt werden, dass die Umsetzung eines
Sortieralgorithmus für ungeübte Programmierer sehr anspruchsvoll ist und diese lange brauchen um
einen solchen nachzuvollziehen.12
In der späteren Analyse der Laufzeiten werden die Schüler dazu gebracht, sich mit der „Effizienz und
Korrektheit“ einfacher „Algorithmen“ zu beschäftigen.13 Diese Überlegung überschneidet sich auch mit
den „Grenzen des Rechnereinsatzes“, jedoch bleibt festzuhalten, dass dieses Thema lediglich peripher
berührt wird.14
Auch der Punkt „5. Leitidee 'Informatik und Gesellschaft'“ wird meines Erachtens angeschnitten, da die
Schüler sehen wie leicht sich große Datenmengen sortieren und damit auch verwalten lassen.15
3.2 Allgemeinbildung und Informatik
Andreas Schwill erklärt in seinem Aufsatz, dass der Informatikunterricht sich aufgrund der rasanten
Entwicklung der Informatik nicht an der Forschung orientieren solle. Er argumentiert vielmehr, dass er
7 Ebenda.8 Ebenda.9 Ebenda. 10 Ebenda, S. 439. 11 Ebenda. 12 Ebenda.13 Ebenda. 14 Ebenda. 15 Ebenda, S. 441.
auf unveränderlichen Grundkonzepten aufbauen solle.16 Diese Grundkonzepte nennt er die
fundamentalen Ideen der Informatik.17 Für die Identifizierung solch fundamentaler Ideen nennt Schwill
5 Kriterien.
Das erste Kriterium welches Schwill nennt ist das Horizontalkriterium. Hierbei handelt es sich um die
Forderung, dass eine fundamentale Idee der Informatik in mehreren „Wirkungsbereichen“ anwendbar
sein müsse.18 Ferner bedeutet es, dass die Grundlagen der Informatik „jedem Menschen in jedem Alter
in irgendeiner Form beigebracht werden können.“19 Dies trifft auf die Sortieralgorithmen zu, da sie in
unzähligen Bereichen Anwendung finden. Ihr Grundprinzip ist intuitiv und man könnte sie benutzen
um jegliche Art von Gegenständen zu sortieren. Vor allem der „Selection Sort“-Algorithmus ist sehr
intuitiv und viele Menschen benutzen diese Technik auch im Alltag um beispielsweise ein Kartendeck
zu sortieren. Des Weiteren könnte man argumentieren, dass die Laufzeiten eines Prozessors ebenfalls
unter diese Kategorie fallen, da sie ein Hindernis oder die Lösung für eine Vielzahl von Problemen
sind. Insofern wird man durch eine diesbezügliche Sensibilität in die Lage versetzt, intuitiv entscheiden
zu können, ob ein Problem mit dem Computer lösbar ist.
Das Vertikalkriterium besagt, dass man fundamentale Ideen in vielen unterschiedlichen
Schwierigkeitsniveaus anwenden kann.20 Auch dieses Kriterium trifft auf die behandelten
Sortieralgorithmen zu. Letztendlich kann man mit ihnen einfache Programme schreiben, dennoch
bilden sie auch die Grundlage für schwierigere Sortier- und Suchalgorithmen. Wichtiger als die
Sortieralgorithmen sind bezüglich der Horizontalkriterien allerdings die Basisanweisungen. Die
Schleifen und „if-Abfragen“ sind schließlich essentielle Grundbausteine von Computerprogrammen,
welche sowohl in den leichtesten als auch den kompliziertesten Quelltexten vorhanden sind. Die
Datentypen und Datenstrukturen zählen selbstverständlich aus demselben Grund auch dazu.
Das nächste Kriterium ist die Weite. Schwill verlangt, dass eine Idee, um Weite zu besitzen, „einen
gewissen Spielraum für Interpretationen zulässt.“21 Diese Forderung schließt exakt formulierte
„Axiome oder Regeln“ aus. Die Sortieralgorithmen an sich richten sich nicht nach festen Regeln und
man kann sie auf mehreren Wegen implementieren. Des Weiteren muss gesagt werden, dass die
Grundprinzipien dieser Algorithmen auch für andere Sortieralgorithmen angewendet werden können.
Ein weiteres Kriterium ist das des Sinnes. Dieses Kriterium prüft Ideen auf ihre Anwendbarkeit im
16 Schwill, A.: Fundamentale Ideen der Informatik. Zentralblatt für Didaktik der Mathematik, Heft 1 (1993), S. 22, 23.17 Ebenda, S. 25.18 Schwill, S. 21.19 Ebenda.20 Ebenda.21 Ebenda, S. 22.
Alltag.22 Es ist wohl unbestreitbar, dass Konzepte wie das von Such- und Sortieralgorithmen zum
Alltag von Menschen gehören, da sie diese in einer Vielzahl von alltäglichen Situationen nutzen.
Aufgrund der graphischen Nutzeroberflächen sind sich viele Benutzer nicht im klaren darüber, welche
Prozesse dahinter ablaufen, jedoch sollten sich die Bürger besser darüber im klaren sein, wie solche
Prozesse funktionieren. Dies ist vor allem im Bezug auf das Thema „Informatik und Gesellschaft“ von
zentraler Bedeutung.
Das letzte Kriterium ist das der Zeit. Fundamentale Ideen sind laut Schwill von einem eher zeitlosen
Charakter geprägt, was bedeuten soll, dass „fundamentale Ideen einer Wissenschaft längerfristig gültig
bleiben.“23 Sortieralgorithmen sind definitiv ein Thema zeitlosen Charakters. Seit Jahrzehnten werden
ständig neue und bessere Verfahren gesucht um bestimmte Datensätze zu sortieren und zu durchsuchen.
Die Laufzeiten stehen im Zusammenhang mit der Optimierung noch mehr im Rampenlicht der
Entwicklung und sind daher genauso zeitbeständig.
Als fundamentale Ideen in der Informatik spezifiziert Schwill den Software life cycle. Dieser besteht
aus den 6 Schritten Problemanalyse, Entwurf, Implementierung, Funktions-/Leistungsüberprüfung,
Installation und Wartung.24 Die gehaltene Unterrichtsstunde lässt sich vor allem in den Unterpunkten
Implementierung und Leistungsüberprüfung wiederfinden. Die Punkte Entwurf und Implementierung
mit in den Unterricht einzubeziehen wäre zweifelsfrei auch sehr interessant gewesen, jedoch ließ sich
das aus zeitlichen Gründen nicht realisieren. Diese Punkte wurden durch die Präsentation des
Pseudocodes etwas verkürzt.
Zusammenfassend lässt sich also sagen, dass sich die einzelnen Bestandteile des Themas als
fundamentale Ideen der Informatik identifizieren lassen. Daher ist die Stunde nicht nur für die Schüler,
welche ein Informatikstudium oder eine Ausbildung im informationstechnischen Bereich anstreben,
interessant. Die hier behandelten Probleme bilden das Hintergrundwissen für eine Vielzahl von
Problemen mit denen man im Alltagsleben konfrontiert wird. Auch in puncto Datenbanken ist dies
meines Erachtens ein interessantes Thema, da es auch dafür ein wichtiges Grundwissen darstellt.
22 Ebenda, S. 22.23 Schwill, S. 22.24 Schwill, S. 26.
4. Lernziele
4.1 Prinzipielles Verständnis eines Quelltextes
4.1.1 Umgang mit einem Quelltext
Die Schüler sollen mit einem vorprogrammierten Quelltext arbeiten. Um diese Aufgabe zu erfüllen
müssen sie den Quelltext verstehen, nachvollziehen und interpretieren. Folglich werden mit diesem
Lernziel vor allem die kognitiven Fähigkeiten der Schüler im Umgang mit Quelltexten geschult.
4.1.2 Umgang mit verschiedenen Datentypen
In der praktischen Phase des Unterrichts müssen die Schüler mit Variablen umgehen. Die Schüler
müssen die bereits von mir deklarierten Variablen und deren Datentypen identifizieren und im weiteren
Verlauf des Programms nutzen. Selbstverständlich können sie auch ihre eigenen Variablen deklarieren
und nutzen, sofern sie dies bevorzugen oder weitere Hilfsvariablen benötigen.
Folglich werden die Schüler in der Nutzung verschiedener Datentypen geschulter, was die Grundlage
eines Computerprogramms ist.
4.1.3 Umgang mit Feldern
Die Sortieralgorithmen sollen Felder sortieren. Daher müssen sich die Schüler, um diese zu
programmieren, die Funktionsweise von Feldern bewusst machen. Sie müssen die unterschiedlichen
Werte des Feldes sowohl vergleichen als auch verändern.
Die Sortieralgorithmen eignen sich für diesen Zweck sehr gut, da sie sowohl Operationen, in welchen
lediglich auf die Daten zugegriffen wird, als auch Operationen, in welchen die Daten verändert werden
enthalten. Gerade für den Umgang mit Feldern ist dies eine Übung, welche den Schülern das
Verständnis der Funktionsweise erleichtert. Der wiederholte Zugriff auf die Indexwerte zeigt ihnen auf,
dass sich die Funktionsweise eines Feldes mit der eine Inhaltsverzeichnisses vergleichen lässt.
4.2 Schulung der Kontrollstrukturen
4.2.1 Abfragen
Da in beiden Algorithmen wiederholt Abfragen auftauchen, müssen sich die Schüler die Funktion
dieser erneut vor Augen führen. Die Bedingungen für die Abfragen sind ihnen zwar bereits im
Pseudocode vorgegeben, jedoch müssen sie sich Gedanken über deren Tragweite machen um die
Algorithmen zu verstehen.
4.2.2 Schleifen
Da beide Algorithmen verschachtelte Schleifen beinhalten, müssen sich die Schüler die Bedeutung von
inneren und äußeren Schleifen nochmals genau vor Augen führen. Obwohl ihnen die Schleifen
ebenfalls bereits im Pseudocode vorgegeben wurden, müssen die Schüler trotzdem peinlichst genau
darauf achten, dass sie das Prinzip der Abbruchbedingung richtig anwenden, um Endlosschleifen zu
vermeiden.
4.2.3 Zusammenspiel der Abfragen und Schleifen
Genauso wichtig, wie die Basisanweisungen an sich, ist das Zusammenspiel dieser in einer längeren
Folge von Anweisungen. In den Sortieralgorithmen werden die Schüler dafür sensibilisiert, dass bereits
der kleinste Fehler im Programmcode zu einer völlig falschen bzw. gar keiner Ausgabe führt. So
müssen die Schüler darauf achten, dass sie die Schleifenzähler an den richtigen Stellen inkrementieren
oder wieder auf Null setzen. Außerdem dürfen sie die Schleifenzähler nicht lediglich in den „if-
Abfragen“ verändern, da dies zu den vorhin erwähnten Endlosschleifen führt.
4.3 Laufzeiten
4.3.1 Quadratisches Wachstum
In der Testphase sehen die Schüler, dass sich kleine Unterschiede im Programmiercode massiv auf die
Laufzeit der Algorithmen auswirken können. Anhand der unterschiedlichen Testwerte können die
Schüler sehen, dass die Laufzeiten der Algorithmen nicht linear sondern quadratisch wachsen. Dies
sensibilisiert sie dafür, dass die Verwaltung von Daten mit zunehmender Datenmenge
unverhältnismäßig schwieriger wird.
4.3.2 Die O-Notation
Im Anschluss an die Beobachtung werden die Begriffe des „besten“ und des „ungünstigsten Falles“
eingeführt. Im Zusammenhang mit diesen lernen die Schüler die Gaußsche Summenformel kennen,
welche das Wachstum der Laufzeiten beider Sortieralgorithmen beschreibt. Anschließend wird die O-
Notation eingeführt und die Schüler sollen verstehen, dass für die Abschätzung der Laufzeit eine
ungefähre Angabe, in Form des am schnellsten wachsenden Teils der Gleichung, ausreichend ist.
5. Motivation und didaktische Mittel
5.1 Motivation „Youtube-Video“
Als Einstieg in die Stunde wählte ich zwei Youtube-Videos, welche die Funktionsweise der
Algorithmen erklären. Die Videos erklären die Funktionsweise innerhalb von zwei Minuten kurz und
prägnant. Ich wählte die Videos zur Motivation, da ich es für sinnvoll hielt, den Schülern die
Funktionsweise sowohl visuell als auch auditiv vorzuführen. Zusätzlich nahm ich an, dass sich die
Schwächen der Schüler in dieser kurzen Zusammenfassung schnell offenbaren würden, so dass
eventuelle Unklarheiten schnell geklärt werden könnten. Des Weiteren hoffte ich, dass das Video das
Vorwissen der Schüler reaktivieren würde.
Obwohl die Stunde auch das Thema Laufzeiten thematisierte, lag der Schwerpunkt des Einstiegs auf
den Sortieralgorithmen, da die Schüler zunächst diese verstehen und programmieren sollten. Der
Einstieg erklärte den Schülern das Grundprinzip der Algorithmen, so dass sie später in der Lage waren,
den Pseudocode auf dem Arbeitsblatt nachzuvollziehen.
Im Anschluss an die Videos sollten die Schüler das Funktionsprinzip der Algorithmen in eigenen
Worten wiedergeben. Dies erachtete ich als sinnvoll, da es eine weitere Wiederholung des Inhalts war.
Zusätzlich dachte ich, dass es schwächeren Schülern eventuell leichter fiele die Zusammenfassung
ihrer Mitschüler zu verstehen. Darüber hinaus war es auch als Leistungskontrolle gedacht, um
sicherzustellen, dass die Schüler diesen ersten wichtigen Teil der Unterrichtsphase verstanden hatten.
5.2 Didaktische Mittel
Da sich in dem Raum ein fest installierter Beamer, ein Whiteboard und ein Tageslichtprojektor
befindet, lässt sich eine Vielzahl an unterschiedlichen Medien in den Unterricht miteinbeziehen. Für
den Einstieg entschied ich mich wie gesagt dafür, ein Video an die Leinwand zu projizieren.
Für den anschließenden Lehrervortrag entschied ich mich für eine kurze Präsentation, welche ebenfalls
über den Beamer an die Leinwand projiziert wurde. Da ich den Schülern Informationen vermitteln
wollte, welche meines Erachtens keiner von ihnen wissen konnte, hielt ich diesen Weg für den
einprägsamsten. Dank der Präsentation konnten die Schüler die Informationen nicht nur hören sondern
auch auf den Folien ablesen. Die Präsenz dieser erschien mir sinnvoll, um die Schüler zu präzisen
Rückfragen zu motivieren. Dieser Unterrichtsabschnitt behandelte den Zeitaufwand des Prozessors um
essentielle Befehle, wie etwa Variablendeklarationen, aus Hochsprachen auszuführen. Da es sich
hierbei lediglich um Nanosekunden handelt, erschien es mir sinnvoll dies visuell durch die Präsentation
zu unterstreichen.
Schon in den Leitgedanken zum Kompetenzerwerb wird gesagt, dass „die Methodik des Faches
Informatik […] durch ein arbeitsteiliges Vorgehen in Gruppen unterstützt“ wird.25 Aus diesem Grund
entschied ich mich dafür die praktische Arbeitsphase als Gruppenarbeit durchführen zu lassen. Genauer
gesagt wollte ich sie als Partnerarbeit in zwei Gruppen durchführen. Hierfür teilte ich die Klasse in
zwei Hälften, wobei die rechte Hälfte der Klasse den „Selection Sort“-Algorithmus und die linke Hälfte
den „Bubblesort“-Algorithmus programmieren sollte. Für den Fall, dass einige Schüler schneller sind
als andere, plante ich ein, diese den anderen Algorithmus, welchen sie noch nicht programmiert hatten,
auch noch programmieren zu lassen. Eine größere Gruppenarbeit hielt ich für kontraproduktiv, da
meines Erachtens aus praktischen Gründen nicht mehr als zwei Leute an einem Computer arbeiten
sollten. Da sich in der Klasse jedoch 13 Schüler befinden, war mir bewusst, dass es entweder eine
dreier Gruppe oder eine Einzelarbeit geben müsse. Welches von beidem eintrifft, wollte ich den
Schülern überlassen.
Um die Schüler in der Partnerarbeit nicht zu überfordern wollte ich ein Arbeitsblatt austeilen, welches
die Funktionsweise der Algorithmen sowohl beschrieb als auch im Pseudocode darstellte. Da die
Sortieralgorithmen für ungeübte Programmierer meines Erachtens sehr kompliziert sind, dachte ich,
dass die Schüler eine solch vereinfachte Darstellung benötigen würden um die Aufgabe zu lösen.
Im Anschluss daran kam abermals der Beamer zum Einsatz, da die Schüler nun anhand ihres eigenen
Programmcodes beschreiben sollten wie ihr Algorithmus funktionierte. Dies schien mir die
unkomplizierteste Alternative für diesen Teil des Unterrichts. Ob die Schüler für ihren Vortrag nach
vorne an die Tafel kommen oder nicht, wollte ich ihnen überlassen. In erster Linie war die Erklärung
der Sortieralgorithmen am eigenen Programmcode als Leistungskontrolle gedacht. Gleichzeitig wollte
ich allerdings auch sicherstellen, dass alle Schüler eine korrekte Lösung ihrer Mitschüler zu sehen
25 Bildungsplan 2004, S. 438.
bekommen und dass eventuelle Umsetzungsprobleme an einem konkreten Beispiel erklärt werden.
Insofern dient die erneute Wiederholung als zusätzliche Absicherung, sollten nicht alle Schüler in der
Lage sein ihr Programm zu vollenden.
Als nächstes plante ich ein kurzes Unterrichtsgespräch um den Schülern zu erklären wie die
Zeitmessung in Delphi funktioniert. Ich wählte hierzu die Form des Unterrichtsgesprächs, da die
Funktionsweise der Zeitmessung völlig logisch ist und der einer Stoppuhr entspricht. Daher ging ich
davon aus, dass die Schüler in der Lage seien sich dieses Grundprinzip selbst herzuleiten. Im weiteren
Verlauf wollte ich dann am Beamer demonstrieren wie die tatsächliche Umsetzung im Programmcode
aussieht.
Anschließend sollten die Schüler die Zeitmessung in Partnerarbeit umsetzen. Des Weiteren sollten sie
ihren Algorithmus ebenfalls in Partnerarbeit mit den auf dem Arbeitsblatt angegebenen Werten testen.
Im Anschluss plante ich ein kurzes Unterrichtsgespräch zur Verarbeitung der Ergebnisse. Dies erschien
mir sinnvoll, da die Schüler nach der Zeitmessung meines Erachtens genug Informationen besaßen, um
das quadratische Wachstum festzustellen. Die Ergebnisse dieses Gesprächs wollte ich am Whiteboard
festhalten, um den Schülern das Mitschreiben der wichtigsten Informationen zu ermöglichen.
Wie sich aus den obigen Schilderungen leicht erkennen lässt, benutze ich den Beamer sehr häufig in
meiner Unterrichtsplanung. Dies resultiert daraus, dass er sich sehr vielfältig einsetzen lässt. Man kann
über ihn Videos, Auszüge des Programmcodes und auch ein Präsentationen an die Wand projizieren.
Wenn man in der Didaktik von einer Vielfalt von Medien und Unterrichtsmitteln die Rede ist, so muss
man berücksichtigen, dass der Beamer ein Medium ist, welches für viele verschiedene Zwecke
eingesetzt werden kann. Daher denke ich, dass die mehrfache Verwendung des Beamers in meiner
Unterrichtsstunde keineswegs monoton war.
Die Partnerarbeit, welche mehrfach zum Einsatz kommt, erscheint mir auch als sinnvolle Methode, da
die Schüler sich auf diese Weise gegenseitig unterstützen konnten. Außerdem halbierte es den Kurs, so
dass ich als Lehrperson besser in der Lage war auf die einzelnen Probleme einzugehen.
Das Unterrichtsgespräch ist auch sehr nützlich, da es die Schüler aktiv in den Unterricht mit einbezieht.
Gleichzeitig ist es eine Leistungskontrolle der zuvor geleisteten Gruppenarbeit. Zudem ermöglicht das
Unterrichtsgespräch es den Schülern sich die gewünschten Ergebnisse größtenteils selbst herzuleiten.
Dies ist im Gegensatz zum Lehrervortrag sehr wünschenswert. Dennoch muss gesagt werden, dass
auch dieser sich an manchen Stellen nicht vermeiden lässt, da die Schüler gewisse Sachinformationen
weder wissen noch herleiten können.
Zum Abschluss der Unterrichtsstunde eignet sich die Tafel oder das Whiteboard sehr gut, da man hier
sehr gut die individuellen Schülerantworten festhalten kann. Abgesehen davon, dass dies sehr flexibel
ist, bringt es auch noch den Vorteil mit sich, dass die Schüler das Gefühl haben, sich die Informationen
selbst erarbeitet zu haben, und selbst etwas verstanden zu haben. Aus diesem Grund eignet sich dieses
Medium besonders für das Unterrichtsgespräch am Ende der Stunde.
6. Verlaufsplan und Zeitplanung
6.1 Begründung für die Zeitplanung
Für den Einstieg mit den zwei Videos plante ich 8 Minuten ein. Dies erschien mir sinnvoll, da ich jedes
Video zweimal vorspielen wollte und jedes ungefähr zwei Minuten beanspruchte. Des Weiteren
rechnete ich mit Unterbrechungen und Fragen der Schüler. Zudem wollte ich das Thema der Stunde
und den Inhalt der Videos noch vor dem Abspielen dieser verkünden. Hierfür veranschlagte ich weitere
2 Minuten. Außerdem wollte ich, dass die Schüler das Prinzip der Suchalgorithmen jeweils nach dem
Abspielen der Videos mündlich zusammenfassen. Dies sollte meines Erachtens nicht mehr als 5
Minuten beanspruchen, da das Grundprinzip des Algorithmus in den Videos anhand sehr einfacher
Beispiele erklärt wurde.
Für den anschließenden Lehrervortrag kalkulierte ich 10 Minuten ein. Ich schätzte meine eigene
Sprechdauer auf ungefähr 7 Minuten und 3 Minuten wollte ich den Schülern für eventuelle Rückfragen
geben.
Für die praktische Arbeitsphase plante ich 25-30 Minuten ein. Da mir der ehemalige Lehrer der Klasse
versichert hatte, dass er die Sortieralgorithmen mit den Schülern schon einmal programmiert hatte, war
ich zuversichtlich, dass sie die Programme in dieser Zeit vollenden könnten. Die unklare Zeitspanne
von 5 Minuten kalkulierte ich für eventuell auftauchende Probleme mit den Computern, das Austeilen
der Arbeitsblätter und die Gruppeneinteilung ein.
Nach der praktischen Arbeitsphase sollten die Schüler die Algorithmen anhand ihres eigenen
Programmcodes am Beamer beschreiben. Da die Algorithmen nicht besonders lang sind, rechnete ich
damit, dass jede Gruppe etwa 5 Minuten für die Beschreibung ihres Algorithmus benötigen würde.
Für das darauffolgende Unterrichtsgespräch mitsamt der Vorführung am Beamer plante ich weitere 5
Minuten ein. Ich rechnete damit, dass die Schüler ungefähr 2 Minuten für die Herleitung des
Grundprinzips bezüglich der Zeitmessung in Delphi brauchen würden und weitere 3 Minuten für die
Umsetzung am Beamer inklusive einer anschließenden Klärung offener Fragen.
Für die erneute praktische Arbeitsphase kalkulierte ich lediglich 10 Minuten ein, da die Schüler den
Programmcode zur Laufzeitmessung ihrer Algorithmen lediglich abschreiben mussten. Dies sollte nicht
mehr als 5 Minuten beanspruchen. Die anschließende Analyse der Laufzeiten für die angegebenen
Werte sollte ebenfalls höchstens 5 Minuten beanspruchen.
Das abschließende Unterrichtsgespräch sollte meiner Einschätzung nach ungefähr 10 Minuten dauern.
Ich nahm an, dass die Erkenntnis, dass die Laufzeit nicht linear sondern quadratisch anwächst,
ungefähr 2 bis 3 Minuten dauern würde. Weitere 2 Minuten veranschlagte ich für die Erklärung des
„besten“ und des „ungünstigsten Falles“ und die verbleibenden 5 Minuten wollte ich für die Einführung
der Gaußschen Summenformel und der O-Notation verwenden.
6.2 Unterrichtsverlaufsplan
Dauer Phase Form Medium
10 Minuten Motivation Youtube-Videos Beamer
5 Minuten Funktionsweise der
Sorieralgorithmen
Unterrichtsgespräch Evtl. Whiteboard
10 Minuten Laufzeiten des
Prozessors
Lehrervortrag Beamer: Präsentation
25-30 Minuten Praktische
Arbeitsphase I:
Programmierung von
“Bubblesort” und
“Selection Sort”
Gruppenarbeit /
Partnerarbeit
Schüler-PCs
10 Minuten Ergebnissicherung Gruppenarbeit /
Partnerarbeit
Beamer – Schüler erklären Lösung
anhand eigener Algorithmen
5 Minuten Zeitmessung in
Delphi
Unterrichtsgespräch Beamer – Umsetzung der Zeitmessung
in Delphi im Programmiercode
5 Minuten Praktische
Arbeitsphase II:
Umsetzung der
Gruppenarbeit /
Partnerarbeit
Schüler-PCs
Zeitmessung in
Delphi
5 Minuten Zeitmessung Gruppenarbeit /
Partnerarbeit
Schüler-PCs
10 Minuten Abschlussgespräch Unterrichtsgespräch Whiteboard
7. Tatsächlicher Verlauf der Doppelstunde
7.1 Unmittelbar vor dem Unterricht
Am Donnerstag nach den Weihnachtsferien machte ich mich um 7 Uhr auf den Weg zum Friedrich-
Ebert-Gymnasium. Ich wollte etwas früher da sein, um die Arbeitsblätter, welche ich austeilen wollte,
zu kopieren. Nachdem ich dies erledigt hatte traf ich die Lehrerin und begab mich mit ihr auf den Weg
zum Klassenzimmer. Einige Schüler warteten bereits vor der Tür als wir dort ankamen. Die Lehrerin
sah jedoch auf den ersten Blick, dass noch einige Schüler fehlten. Sie teilte mir mit, dass es sich hierbei
um die Schüler handelte, die üblicherweise zu spät kommen.
7.2 Vorstellung und Motivation
Trotz der fehlenden Schüler begann ich den Unterricht pünktlich um 7.45 Uhr. Zunächst stellte ich
mich kurz vor und bat die Schüler Namensschilder zu schreiben, so dass ich sie mit ihrem Namen
ansprechen konnte. Direkt im Anschluss kündigte ich das Thema der heutigen Stunde an und stellte die
Frage was sie sich unter Sortieralgorithmen vorstellten. Da die Schüler sehr verhalten darauf reagierten,
sagte ich, dass sie das Thema im vorigen Jahr bereits behandelt hatten und fragte sie an was sie sich
denn noch erinnerten. Auch diese Frage wurde sehr zögerlich und unpräzise beantwortet.
Aus diesem Grund begann ich nach einer kurzen Ankündigung die Youtube-Videos abzuspielen.
Zunächst spielte ich das Video zum „Bubblesort“-Algorithmus, wie geplant, zweimal ab. Bereits beim
ersten Abspielen bemerkte ich, dass den Schülern das Englisch in den Videos Probleme bereitete.
Daher spielte ich das Video beim zweiten mal mit Pausen ab und hakte an gewissen wichtigen Stellen
nach. Hierbei stellte sich heraus, dass die Schüler sich nichts unter dem Begriff „array“ vorstellen
konnten. Auch das deutsche Wort „Feld“ kam ihnen nicht bekannt vor. Aus diesem Grund erklärte ich
ihnen die Funktionsweise der Datenstruktur anhand des Beispiels eines Buches. Außerdem versuchte
ich es zu visualisieren indem ich die bildliche Darstellung des Feldes aus den Videos zeigte und daran
mehrfach die Funktionsweise erklärte.
Natürlich überzog ich aufgrund dieses nicht eingeplanten Einschubs meinen ursprünglichen Zeitplan.
Jedoch musste ich dies tun, da die Funktionsweise des „Feldes“ unerlässlich für den weiteren
Unterrichtsverlauf war. Insgesamt verlor ich schätzungsweise 5 Minuten durch diese nicht eingeplante
Exkursion.
Im Anschluss daran zeigte ich das zweite Video wie geplant auch zweimal, allerdings zeigte ich es
bereits beim ersten mal mit Pausen, um sprachliche Probleme, welche durch das in den Videos
verwendete Englisch entstand, aus dem Weg zu räumen.
Binnen der ersten 5 Minuten trafen noch drei weitere Schüler, die zu spät kamen, ein. Ich sah von
Disziplinarmaßnahmen ab, da mir die Klassenlehrerin diesbezüglich nichts vorgegeben hatte und ich
ihr dies daher überlassen wollte.
7.3 Funktionsweise der Sortieralgorithmen
Das auf die Videos folgende Unterrichtsgespräch funktionierte gut und zahlreiche Schüler beteiligten
sich lebhaft. Die Zusammenfassung der Funktionsprinzipien gelang so gut, dass ich den Eindruck hatte
die Schüler hätten die Funktionsweise bereits grob verinnerlicht.
Im Anschluss daran stellte ich den Schülern die Frage ob sie sich vorstellen könnten wofür
Sortieralgorithmen nützlich seien. Nachdem mehrere Erklärungsversuche von Seiten der Schüler
erfolgt waren, pauschalisierte ich die Antworten indem ich sagte sortierte Datensätze seien leichter zu
verwalten.
7.4 Laufzeiten des Prozessors
Es folgte der 10-minütige Lehrervortrag. Aufgrund des fest installierten Beamers konnte ich meine
Präsentation direkt starten ohne eine zeitliche Verzögerung in Kauf nehmen zu müssen. Die Schüler
hörten dem Vortrag zu und waren sichtlich erstaunt über die Anzahl an Rechenprozessen, welche der
Prozessor binnen einer Sekunde durchführen kann. Im Anschluss daran kamen auch die von mir
erwünschten Fragen, wie zum Beispiel wofür die Laufzeiten denn eine Rolle spielen wenn die
Prozessoren doch so schnell seien. Diese Frage war gut dafür geeignet um die Schüler dafür zu
sensibilisieren wie viele Rechenprozesse ein Prozessor durchführen muss um eine große Menge an
Daten zu verwalten. Als Beispiel hierfür nahm ich die Suchmaschine Google und fragte die Schüler ob
sie sich vorstellen könnten wie viele Vergleiche Google wohl machen müsse um eine Suchanfrage
durchzuführen. Dieser Unterrichtsabschnitt lief ohne Verzögerung und in der dafür eingeplanten Zeit
ab.
7.5 Praktische Arbeitsphase I: Programmierung von “Bubblesort” und “Selection
Sort”
In der praktischen Arbeitsphase traten zunächst vereinzelt Probleme mit Delphi auf, obwohl ich am
Montag davor die Kompatibilität mit dem von mir geschriebenen Programm überprüft hatte. Das
Problem wurde durch das Netzwerk verursacht, da die Schüler lediglich Zugriff auf ihren eigenen
Arbeitsordner hatten. Binnen weniger Minuten war das Problem geklärt und gelöst.
Nachdem nun alle Schüler startbereit waren, konnten sie mit der Programmierung beginnen. Die
Programmierung sollte viel mehr Zeit in Anspruch nehmen als ich dies vorher eingeplant hatte. Dies
wurde mir bereits nach wenigen Minuten bewusst. In der praktischen Programmierphase stellte sich
heraus, dass die Schüler die Grundkonzepte der Kontrollstrukturen, welche ich als bekannt
vorausgesetzt hatte, nicht richtig verstanden hatten. Zahlreiche Schüler hatten Probleme damit, die
Bedingung für die äußere Schleife zu formulieren, obwohl diese auf dem ausgeteilten Arbeitsblatt
stand. Andere Schüler, welche bereits zu den besseren zählten, programmierten mehrere
Endlosschleifen. Auf die individuellen Bedürfnisse der Schüler einzugehen erwies sich als sehr
zeitaufwändig. Damit hatte ich bereits bei der Planung gerechnet, allerdings hatte ich nicht damit
gerechnet, dass die Probleme bereits bei so essentiellen Dingen auftauchen würden.
Vor allem die Differenzierung zwischen äußerer und innerer Schleife bereitete den Schülern Probleme.
Es dauerte lange dies den einzelnen Gruppen zu erklären und sogar nach der Erklärung verwechselten
die Schüler reihenweise die Zähler der inneren und der äußeren Schleife. Auch der Umgang mit den
Feldern bereitete den Schülern sichtlich Probleme. Folglich kamen wir zeitlich enorm in Verzug, so
dass die Programmierung den Rest der Doppelstunde in Anspruch nehmen sollte. Auffällig war, dass
die Schüler nach der Pause sehr lange brauchten um wieder richtig anzufangen. Dennoch hatte ich den
Eindruck als seien sie sehr ehrgeizig bezüglich der Lösung des Problems. Leider mangelte es ihnen
jedoch an essentiellen Grundlagen um die Aufgabe schnell und korrekt zu erledigen. Da ich es für eine
sinnvolle Übung hielt, gab ich den Schülern die Zeit, welche sie für die Programmierung benötigten
und sprach bereits während der Stunde mit der Lehrerin ab, dass ich die folgende Doppelstunde auch
halten würde. Letztendlich schafften es lediglich zwei Schülerinnen den „Bubblesort“-Algorithmus zu
vollenden.
7.5.1 Praktische Arbeitsphase I: Programmierung von “Bubblesort” und
“Selection Sort”
Da ich die Woche zuvor gesehen hatte, dass die meisten Schüler immer noch Probleme damit hatten ihr
Programm zum laufen zu bringen, wollte ich in der zweiten Doppelstunde genau da wieder anknüpfen
wo wir die Stunde zuvor aufhören mussten.
Ich kalkulierte nun jedoch noch mehr Zeit für die Programmierung der Algorithmen ein, da ich wusste,
dass viele Schüler essentielle Lücken aufwiesen. Ich nahm an, dass die Programmierung der
Sortieralgorithmen in etwa 55 Minuten in Anspruch nehmen sollte. Abermals wollte ich Schüler die
schneller waren als andere den Algorithmus, welchen sie noch nicht programmiert hatten, schreiben
lassen.
Am Anfang der Stunde entstand wieder eine kleine Verzögerung dadurch, dass die Schüler ihre
Programme nicht sofort laden konnten. Ein Schüler hatte seinen Programmcode auch nicht komplett
gespeichert, so dass er komplett neu anfangen musste.
Die zwei Schülerinnen, welche in der vorherigen Doppelstunde den „Bubblesort“-Algorithmus
programmiert hatten ließ ich mit dem „Selection Sort“-Algorithmus beginnen. Der Rest der Klasse
sollte an ihren alten Algorithmen weiter arbeiten. Nach wie vor traten viele Probleme auf, so dass die
Programmierung erneut viel Zeit in Anspruch nahm. Ich muss auch zugeben, dass es mir auch nicht
immer auf Anhieb gelang den Fehler in den Algorithmen der Schüler zu finden. Größtenteils arbeiteten
die Schüler sehr unstrukturiert, so dass sich ihre Quelltexte sehr schwer lesen ließen. Ich versuchte dies
zu verbessern, indem ich ihnen zeigte wie man die Quelltexte übersichtlicher gestalten kann. Des
Weiteren kommentierten die Schüler ihre Quelltexte kaum. Auch dazu riet ich ihnen.
Trotz zahlreicher Hindernisse schafften wir es diesmal meine Zeitplanung ungefähr einzuhalten. Zwar
waren zwei Schüler auch dieses mal nach dem Ablauf der Zeit noch nicht mit ihrem Programm fertig,
jedoch entschloss ich mich trotzdem zur nächsten Unterrichtsphase überzugehen.
7.6 Ergebnissicherung
Daher beendete ich offiziell die praktische Arbeitsphase und leitete den nächsten Unterrichtsabschnitt
ein. Zunächst fragte ich die Schüler welche Gruppe ihren Algorithmus zuerst präsentieren wolle. Es
meldeten sich die zwei Schülerinnen, welche als erste den „Bubblesort“-Algorithmus vollendet hatten.
Sie erklärten ihren Quelltext von ihren Plätzen aus. Daher musste ich den Schülern am Beamer zeigen
wo wir uns momentan im Quelltext befanden. Ich stellte zusätzliche Fragen zu den Themen, welche
meines Erachtens immer noch Probleme bereiteten. Vor allem versuchte ich das Thema Felder ein für
alle mal zu klären, indem ich noch einmal gezielt nach deren Funktion im Quelltext fragte. Des
Weiteren ließ ich die Funktion der inneren und äußeren Schleifenzähler nochmals erklären.
Auch für die Präsentation des zweiten Algorithmus fanden sich schnell zwei Freiwillige. Auch bei
dieser Präsentation ging ich noch einmal speziell auf die Funktionsweise der Zähler und der Felder ein.
Stichprobenhaft fragte ich nun auch andere Schüler, ob sie die Funktionsweise erklären könnten. Dies
funktionierte gut und ich hatte den Eindruck, dass die Schüler nun sowohl die Funktionsweise der
geschachtelten Schleifen, als auch die der Felder verstanden hatten.
Letztendlich schafften wir es auch für diesen Teil in meinem zeitlich gesetzten Rahmen zu bleiben.
Folglich konnte ich pünktlich zum nächsten Teil überleiten.
7.7 Praktische Arbeitsphase II: Umsetzung der Zeitmessung in Delphi
Die Herleitung des Funktionsprinzips gelang auf Anhieb sehr schnell. Danach präsentierte ich den
Schülern den Quelltext für die Umsetzung der Zeitmessung. Die Umsetzung von diesem durch die
Schüler nahm erneut mehr Zeit in Anspruch als erwartet. Aus Angst meine Stunde abermals nicht
beenden zu können brach ich diese Unterrichtsphase ab bevor alle die Zeitmessung implementiert
hatten.
7.8 Zeitmessung
Da noch nicht alle Schüler die Zeitmessung korrekt implementiert hatten entschloss ich mich dazu, die
Zeitmessung für alle am Beamer durchzuführen. Ich nutzte dafür die Quelltexte von den Schülern,
welche die Zeitmessung bereits korrekt umgesetzt hatten. Dies ermöglichte es mir die letzte Phase des
Unterrichts pünktlich anzufangen und den Schülern trotzdem die Zeitmessung und den wachsenden
Aufwand zu präsentieren.
7.9 Abschlussgespräch
Im letzten Unterrichtsteil ließ ich die Schüler ihre Beobachtungen während der Zeitmessung schildern.
Ich wollte auf den quadratisch wachsenden Zeitaufwand hinaus, welchen die Schüler nach
wiederholtem Nachfragen identifizieren konnten. Die Begriffe des „günstigsten“ und des
„ungünstigsten“ Falles führte ich im Anschluss am Beispiel des „Bubblesort“-Algorithmus ein.
Stichpunktartig hielt ich die schon erwähnten Schlagbegriffe unter der Überschrift „Laufzeiten von
Algorithmen“ am Whiteboard fest. Danach führte ich die Gaußsche Summenformel zur Berechnung
des Zeitaufwandes sowohl des „Bubblesort“-, als auch des „Selection Sort“-Algorithmus ein. Im
Zusammenhang damit führte ich auch die O-Notation ein. Abschließend fragte ich die Schüler, woraus
der Geschwindigkeitsunterschied des „Bubblesort“-, und des „Selection Sort“-Algorithmus resultierten.
Erfreulicherweise konnte mir eine Schülerin die richtige Antwort geben, indem sie auf die
Vertauschungen verwies. In diesem Augenblick klingelte auch schon die Pausenglocke und die
Doppelstunde war zu Ende.
8. Fazit
Wie sich an meinen Schilderungen ganz klar erkennen lässt liefen in meiner Doppelstunde einige
Sachen gewaltig schief. Insbesondere in Sachen Zeitplanung hatte ich mich vertan. Bereits vor der
Doppelstunde wurde mir von der Lehrerin gesagt, dass sie meinen Plan für sehr ehrgeizig, jedoch nicht
undurchführbar hielt. Daher hatte sie mich bereits vor der Doppelstunde gefragt, ob ich bereit wäre die
Unterrichtseinheit in der Folgewoche zu vollenden, sollte ich nicht fertig werden. Dazu erklärte ich
mich selbstverständlich bereit.
Das größte Problem in meiner Unterrichtsplanung war, dass ich viel zu wenig Zeit für die
Programmierung der Sortieralgorithmen eingeplant hatte. Ich hatte keine konkreten Anhaltspunkte um
das Niveau der Klasse in puncto Programmieren einschätzen zu können. Im Nachhinein muss gesagt
werden, dass ich das Niveau der Klasse zu hoch eingeschätzt hatte und die praktische Phase daher zu
anspruchsvoll für sie war.
Sollte ich die Stunde erneut in einer Klasse auf ähnlichem Niveau halten, würde ich die Doppelstunde
in zwei Doppelstunden aufteilen, wobei ich in der ersten die Sortieralgorithmen behandeln würde und
in der zweiten die Laufzeiten. In einer Klasse, welche programmiertechnisch auf einem höheren
Niveau ist, würde ich nochmals probieren die Doppelstunde wie ursprünglich geplant zu halten.
Die Arbeitsblätterwürde ich im Nachhinein auch anders gestalten, da mir während des Unterrichts
auffiel, dass sich die Schüler fast ausschließlich am Pseudocode orientierten. Der geschriebene Text
war demnach vollkommen überflüssig, da ihm keinerlei Beachtung geschenkt wurde.
Ein weiterer Kritikpunkt sind die Videos, welche ich zur Motivation zeigte. Das in den Videos
verwendete Englisch erwies sich als problematisch. Da die Schüler Verständnisprobleme hatten,
verzögerte sich meine Unterrichtsgestaltung. Insofern wäre es geschickter deutsche Videos zu
verwenden.
Des Weiteren benutzte ich immer wieder Entscheidungsfragen wie zum Beispiel: „Habt ihr das
verstanden?“ Besonders aufgefallen ist mir dies, als ich die Schüler selbst ihre Algorithmen erklären
ließ und bezüglich der Felder nochmals spezifisch nachhakte.
Außerdem gelang es mir nicht alle Schüler für meinen Unterricht zu begeistern. Obwohl ich mich
generell sehr über die aktive Mitarbeit der Schüler freute, muss ich zugeben, dass es mir nicht gelang
zwei Schüler zur Beteiligung zu bewegen. Die beiden Schüler erwiesen sich sowohl in den mündlichen
als auch in den praktischen Unterrichtsphasen als extrem inaktiv. Als besonders enttäuschend empfand
ich die Tatsache, dass sie in der praktischen Arbeit keinerlei Fortschritt zeigten. Die Klassenlehrerin
versicherte mir jedoch, dass sich diese Schüler bei ihr ähnlich verhielten und auch nicht richtig
mitarbeiteten.
Auch der Abschluss meiner Stunde missfiel mir ein wenig, da es meines Erachtens zu abrupt beendet
wurde. Ich hätte mir gewünscht, die Diskussion mit den Schülern noch etwas in die Länge zu ziehen,
da ich sie als sehr anregend empfand.
Allgemein lässt sich sagen, dass einige Sachen schief liefen, da mir die Nähe zur Klasse fehlte. Ich
hatte zwar den Unterricht dieser Klasse zur Zeit meines Praxissemesters einige Male hospitiert, jedoch
hatte ich dort keinen Einblick in die Programmierkenntnisse der Schüler gewinnen können.
9. Literaturverzeichnis
Peter Brichzin, Ulrich Freiberger, Klaus Reinold, Albert Wiedemann: Informatik I. Funktionale
Modellierung, Datenmodellierung, Oldenburg 2007.
Schwill, A.: Fundamentale Ideen der Informatik. Zentralblatt für Didaktik der Mathematik, Heft 1
(1993).
Schumann, Hans-Georg: Delphi für Kids, Heidelberg 2008.
Bildungsplan 2004, Allgemein bildendes Gymnasium, Bildungsstandard Informatik Gymnasium: URL:
http://www.bildung-staerkt-menschen.de/service/downloads/Bildungsstandards/Gym/Gym_Inf_wb_bs.pdf (15.02.2012,
14:08)
Youtube-Videos:
Bubblesort: URL: http://www.youtube.com/watch?v=P00xJgWzz2c (15.02.2012, 20:24)
Selection Sort: URL: http://www.youtube.com/watch?v=6nDMgr0-Yyo (15.02.2012, 20:25)
