You are on page 1of 50

Leitfaden zum erfolgreichen

Programmieren eines schulischen


Abmeldungssystems

Besondere Lernleistung - Informatik


von Jan Leufen und Nele Schorer
S4 – Tutor: Herr Fritz
Inhaltsverzeichnis
Vorwort ................................................................................................................... 3
Einleitung - Ideenentwicklung ............................................................................... 4
Absprache ......................................................................................................... 4
Bedarf und Realisierbarkeit .............................................................................. 5
1. Organisation ...................................................................................................... 6
Arbeit aufteilen .................................................................................................. 6
Einen Plan erstellen .......................................................................................... 6
Termine und Treffen .......................................................................................... 7
2. Datenschutz ....................................................................................................... 9
Schülerdaten ..................................................................................................... 9
Benutzerverwaltung ........................................................................................ 10
SSL Verschlüsselung ....................................................................................... 11
Passwörter........................................................................................................ 11
3. Programmierung .............................................................................................. 13
Programmierung im Team ............................................................................... 13
Technologien ................................................................................................... 15
Ajax.............................................................................................................. 15
Menüleiste ................................................................................................... 17
Suchfunktion ............................................................................................... 18
Kalender – jQuery ....................................................................................... 19
Zeichenkodierung ....................................................................................... 21
Gestaltung mit CSS .................................................................................... 22
Benutzerfreundlichkeit .................................................................................... 23
Redundanz von Daten .................................................................................... 25
4. Zukunft und Wartung ....................................................................................... 26
5. Testphase......................................................................................................... 27
Planung und Durchführung ............................................................................. 27
Auswertung der Testphase ............................................................................. 28
6. Reflexion .......................................................................................................... 29
Reflexion von Jan Leufen ............................................................................... 29
Reflexion von Nele Schorer ............................................................................ 30
Anhang ................................................................................................................. 32
Quellen ............................................................................................................ 32
Befragung der Lehrer ...................................................................................... 34
Feedback von Frau Wünsche .................................................................... 35
Feedback von Herr Kudling ........................................................................ 37
Frau Rosanowski ........................................................................................ 39
Feedback der Lehrer ....................................................................................... 41
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.

Vorwort (von Nele Schorer)


Sehr geehrter Leser und sehr geehrte Leserinnen,
diese Arbeit handelt von dem Informatik Projekt SES, mit dem wir uns die letzten zwei
Jahre beschäftigt haben.
2014 haben wir für Herrn Schmidt eine Website für den Natex-Wettbewerb programmiert.
Am Anfang der Oberstufe ist er mit einer neuen Idee auf uns zu- gekommen. Er schlug
uns vor etwas zu entwickeln, was das Entschuldigen von Fehlzeiten vereinfacht,
digitalisieren und transparenter machen würde. Aus dieser Idee haben wir ein Konzept
entwickelt. Wir stellten uns die Aufgabe, die Arbeit des Sekretariats zu erleichtern. Wir
wollten eine Website mit dem Namen SES programmieren. SES steht hier für „Schul-
Entschuldigungs-System“. Das Sekretariat hat auf dieser Website die Funktionen, zum
einen morgens bei Anrufen von Eltern oder den Schülern selbst, diese in SES zu
vermerken und zum anderen die Schüler einzutragen, die während des Schultages nach
Hause gehen und deswegen nicht mehr am restlichen Unterricht teilnehmen können.
Die Lehrer haben durch SES die Möglichkeit, Schüler oder ganze Klassen schon im
Vorfeld abzumelden, wenn sie zum Beispiel eine Exkursion planen. Im Lehrerzimmer
soll ein Bildschirm stehen, der eine Auswertung mit allen am jeweiligen Tag
abgemeldeten Schüler anzeigt.

Durch dieses Projekt haben wir vor allem gelernt, wie es ist, ein Informatikprojekt von
Anfang an zu entwickeln und zu begleiten. Der Leitgedanke, der sich demnach durch die
nächsten Seiten zieht, ist die Entwicklung eines Leitfadens zum erfolgreichen
Programmieren einer schulischen Anwesenheitsverwaltung. Er besteht überwiegend
aus Problemstellungen denen wir selbst im Projekt gegenüberstanden und für die w ie
Lösungen gefunden haben.

Doch zuerst möchten wir uns noch bei Martin Kiehne bedanken, der uns im ersten Jahr
des Projektes als Tutor begleitete und uns mit Rat zur Seite stand. Außerdem ebenfalls
vielen Dank an Olaf Schmidt für die erste Inspiration und Idee. Vielen Dank auch an
Herrn Fritz der uns im letzten Jahr als Tutor und Berater geholfen hat.

Wir wünschen Ihnen viel Freude beim Lesen unserer Besonderen Lernleistung.

Jan Leufen Nele Schorer


Hamburg, am 20.02 2016 Hamburg, am 20.02 2016

Besondere Lernleistung Nele Schorer, Jan Leufen 3


Einleitung - Ideenentwicklung

Absprache (von Jan Leufen)


Bei einem größeren Informatikprojekt, mit mehr als einem Teilnehmer, ist es wichtig, auf
die Kommunikation zu achten. Nichts ist ärgerlicher, als wenn ein bestimmte Sache
doppelt oder am Ende gar nicht gemacht wurde, weil die Absprache nicht funktionierte.
Um dieses Problem zu umgehen, braucht man eine gesunde Kommunikation, das heißt,
es gibt regelmäßige Meetings (→ Kapitel 1 „Termine und Treffen“), in denen jeder seine
Erfolge und Probleme darstellt.
Dabei ist darauf zu achten, dass nicht jedes kleinste Problem mit allen Teilnehmern
besprochen werden wird. Das hält nur auf und ist sehr wahrscheinlich nicht zielführend,
schließlich soll sich jeder auf seine eigenen Probleme konzentrieren. Dass heißt aber
wiederum nicht, dass es nicht bestimmte Probleme gibt, über die alle Teilnehmer
informiert werden müssen. In diesem Fall sollte man sich diese Probleme aufschreiben
und diskutieren. Die Lösung kann so im Team erarbeitet werden. Das macht das Ganze
effizienter.
Wenn man bei der Kommunikation auf digitale Mittel setzt, ist es ganz wichtig, dass die
Informationen dauerhaft und immer wieder abrufbar bereit stehen. Sonst ist es nicht
möglich nachzuvollziehen, welche Entscheidungen getroffen wurden und somit werden
einige vielleicht im weiteren Verlauf des Projektes beachtet. Gerade beim
Entscheidungsprozess ist es verlockend, schnell mal eine Entscheidung über einen
Kurznachrichtendienst zu fällen, da man sonst nicht mit der Programmierung weiter
kommt. Doch dies kann zur Folge haben, dass teilweise für das Weiterkommen wichtige
Beschlüsse, nicht allen zugänglich sind. Teilweise werden die Entscheidungen
vergessen oder man kann sie nicht mehr unter vielen anderen Nachrichten wiederfinden.
Eine Lösung für dieses Problem stellt zum Beispiel ein zentrales Dokument dar, welches
jeder Zeit für alle Personen zugänglich ist. Hier können Entscheidungen vermerkt und
wiedergefunden werden. Ein bisschen wie in einem Tagebuch für die Entwickler.
Bei der Programmierung des SES hat die Kommunikation durch die häufigen
Treffen am Freitag recht gut funktioniert. Allerdings hatten wir zu viele einzelne
Entscheidungsdokumente. Eine zentrale Dokumentation unseres Fortschritts hat
oft gefehlt und somit waren Informationen über Kurznachrichten, E-Mail und
Dokumente auf dem Server, auf dem wir programmiert haben, verstreut. Es hat
unserem Projekt zwar nicht geschadet, trotzdem hätten wir durch eine bessere
Kommunikation schneller sein und unsere Effizienz steigern können.

Bedarf und Realisierbarkeit (von Nele Schorer)


Bevor man mit der Entwicklung und Programmierung seines Konzepts anfängt, muss
man zwei wichtige Punkte beachten: zum Einen muss man herausfinden, ob ein
genereller Bedarf an einer elektronischen, schulischen Anwesenheitsverwaltung
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
vorhanden ist, damit sich der Aufwand, den man in das Projekt steckt, lohnt. Und zum
Anderen muss man sich Gedanken zur Realisierbarkeit des Projektes machen.

Somit ist es sehr wichtig, einem Teil der Anwender das Konzept und die Idee zu
präsentieren und diese um Meinung und Rückmeldung zu bitten. Dabei sollte man vor
allem verschiedene Typen von Anwendern in Betracht ziehen, damit man ein
umfassendes Meinungsbild und Ideen bekommt. Bei der Auswertung der Umfrage hängt
es dann vom jeweiligen Feedback ab, ob man sein Konzept noch einmal überarbeitet,
es ganz aufgibt oder es wie geplant beibehält.

Bei unserem Projekt „SES“ haben wir drei Lehrern unser ursprüngliches Konzept
vorgelegt1. Dabei haben wir versucht, drei Lehrer mit unterschiedlichen
Arbeitsweisen zu befragen. Unser ursprüngliches Konzept kam, wie wir feststellten,
noch nicht sehr gut bei den drei befragten Personen an. Dadurch haben wir unser
Konzept noch ein mal anhand der Kritik überarbeitet.

Wenn man weiß, dass ein Bedarf vorhanden ist, dann ist es wie oben erwähnt wichtig
zu sehen, ob sich das Projekt realisieren lässt. Denn ansonsten hält man sich während
der Programmierung mit solchen Problemen auf und merkt vielleicht auch erst im
Nachhinein, dass bestimmte Punkte nicht zu realisieren sind. Dafür muss man sich
überlegen, was für das Projekt benötigt wird und was eventuelle Probleme bereiten kann.
Natürlich treten manche Probleme und Fragen auch erst während des Programmierens
auf, wenn man zum Beispiel sein Konzept noch um weitere Ideen ergänzt. Trotzdem ist
es besser, grundlegende Fragen von vornherein zu klären, um sich später komplett auf
die Entwicklung konzentrieren zu können.

Wir haben bei „SES“ schon von Anfang an das Problem des Datenschutzes
gesehen. Denn wir speichern sensible Schülerdaten (wie Name, Klasse) in einer
Datenbank. Deshalb standen wir von Anfang an im Kontakt mit Herrn Solf. Wir
haben dieses Problem nicht von vornherein geklärt und demnach kam zum Ende
der Programmierung das Problem nochmal auf. Doch für unser Projekt war es
schlussendlich kein Hindernis, die Frage des Datenschutzes erst gegen Ende
geklärt zu haben. Denn wir haben trotz allem eine gute Lösung entwickelt (→
Kapitel zwei „Schülerdaten“).
1
ist im Anhang unter „Lehrer-Befragung“

Besondere Lernleistung Nele Schorer, Jan Leufen 5


1. Organisation

Arbeit aufteilen (von Jan Leufen)


Klar ist, dass man sein Projekt möglichst effizient durchführen möchte. Eine große Hilfe
für dieses Vorhabens ist es, das Team richtig aufzuteilen. Doch wie sieht eine gute
Aufteilung aus?
Es ist ganz natürlich, dass jeder im Team seine Stärken und seine Schwächen hat.
Dementsprechend sollte man auch sein Informatikprojekt aufbauen und die Aufgaben
entsprechend verteilen. Wenn sich jemand besonders gut mit Datenbanken und PHP
auskennt, gibt es keinen Grund, warum er nicht genau diese Aufgabe auch bearbeiten
sollte. Andere Aufgaben, wie beispielsweise das Design können dann andere
übernehmen. Diese Aufteilung sollte, wenn möglich, direkt am Anfang des Projektes
geklärt werden. Wenn es Bereiche gibt, in denen sich noch keiner der Teilnehmer
auskennt, ist zu überlegen, welche Person mit ihrem schon vorhandenen Wissen am
besten dazu geeignet ist, sich in die neue Materie einzuarbeiten.
Wenn alle Rollen zugeteilt sind, ist es wichtig auch bei diesen zu bleiben. Es ist nicht gut,
wenn man anderen Personen die Arbeit wegnimmt und selbst macht. Zum Beispiel kann
dies zur Folge haben, dass Probleme nicht immer auf die selbe Weise gelöst werden,
sondern jeder sie auf eine andere Weise löst. Das führt dazu, dass der Code schwer
verständlich und unübersichtlich wird.
Es kann teilweise sehr schwer sein, sich nur auf seinen Bereich zu beschränken, doch
ohne diese Aufteilung ist keine effiziente Programmierung möglich. Sollte es dennoch
Überschneidungen geben, müssen sich die betroffenen Personen gut absprechen.
Jan war bei der Programmierung des SES für die Zugriffe auf die Datenbank
zuständig, des Weiteren für fast alle Funktionen, die PHP und/oder JavaScript
benötigten.
Nele hat die Kommunikation und Planung übernommen. Außerdem hat sie das
Webdesign mit CSS und JavaScript übernommen. Zu guter Letzt haben wir beide
zusammen die Testphase organisiert.
Die Aufteilung hat gut funktioniert. Wir haben in unseren beiden Themenbereichen
viel gelernt und uns neue Technologien wie Ajax oder jQuery beigebracht. Die
Aufteilung der Arbeit war also ein Erfolg.

Einen Plan erstellen (von Nele Schorer)


Nachdem man die Phase der Ideenentwicklung mit den nötigen Absprachen im Großteil
abgeschlossen hat, muss man sich eine grobe Übersicht über die Organisation schaffen
und daraus einen Plan erstellen. Wenn man sich keinen Plan erstellt, dann kann ein
solches Projekt auch zu einem endlosen Projekt werden, weil man sich an Kleinigkeiten
aufhält und immer neue Ideen entwickelt.
Um einen Plan aufzustellen, sollte man als Allererstes seine Ideen und sein Konzept
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
aufteilen, sodass man eine grobe Struktur hat, an der man sich orientieren kann. Man
sollte ein Projekt in vier Phasen einteilen:
1. Entwicklung und Absprache - um die Idee zu entwickeln und nötige
Vorkehrungen zu treffen
2. Programmierung - reines Programmieren der Website
3. Testphase - in der die Anwendung von der Zielgruppe getestet wird und
Feedback eingeholt wird
4. Überarbeitung - eingeholte Kritikpunkte werden überarbeitet
Wenn man sich Deadlines überlegt, wann die einzelnen Phasen abgeschlossen werden
sollen, sollte man vor allem für Phase zwei, der Programmierung, genügend Zeit
einplanen. Denn vor allem bei der Programmierung unterschätzt man die Zeit, die man
benötigt. Schon ein kleiner Fehler im Code kann zu einem stundenlangen Problem
führen. Natürlich darf man seinen Plan auch nicht zu streng sehen, er sollte nämlich nur
eine gewisse Orientierung für das Projekt sein. Mit den eingeplanten Deadlines hat man
folglich immer einen ungefähren Überblick in welcher Phase des Projektes man sich
gerade befindet. Dadurch kommt man auch bestenfalls in keine Zeitnot, sollte man einen
festen Abgabetermin des Projektes haben.
Wir haben bei unserem Projekt „SES“ auch am Anfang einen Plan erstellt. Doch
diesen Plan haben wir schon erstellt, bevor wir die Ideenentwicklung und
Absprache abgeschlossen hatten. Dadurch haben wir ihn während des
Programmierens relativ schnell wieder verworfen. Im Laufe der Programmierung
haben wir ab und zu weitere Deadlines festgelegt. Diese konnten wir größtenteils
nicht einhalten, einerseits aus Zeitmangel und andererseits hatten wir
zwischendurch auch mal weniger Motivation, dazu aber mehr im Kapitel
„Terminfindung“ und „Team-Programmierung“. Erst gegen Ende hin, als wir die
Testphase durchführen wollten und mit der Dokumentation angefangen haben,
haben wir uns wieder einen Plan erstellt, an den wir uns diesmal gehalten haben.
Im Rückblick wäre ein grober Plan von Anfang an hilfreich gewesen.

Termine und Treffen (von Nele Schorer)


Wenn man zu zweit oder in einer Gruppe eine schulischen Anwesenheitsverwaltung
programmieren möchte, muss man sich auch untereinander sehr gut absprechen (→
Kapitel eins „Absprachen“).

Denn um sein Projekt zu planen und zu besprechen, sollte sich die Gruppe auf jeden
Fall persönlich absprechen. Dazu benötigt auch das gemeinsame Programmieren
Absprachen. Um diese Absprachen zu machen, sollte sich die Gruppe mindestens ein-
mal in der Woche treffen und vielleicht in den ersten Phasen des Projektes auch öfter,
um sich gegenseitig zu motivieren und zu unterstützen. Dabei sollte auf jeden Fall der
Fortschritt und die nächsten Schritte besprochen und auch verschriftlicht werden.
Besondere Lernleistung Nele Schorer, Jan Leufen 7
Doch solche Termine für die Absprachen und Treffen zu finden, hat seine
Schwierigkeiten. Es ist von Vorteil, wenn man sich regelmäßig und an einem festen
Termin trifft, zum Beispiel jede Woche montags. Denn dadurch muss man nicht jede
Woche wieder nach einem neuem Termin suchen, sondern hat einen festen Termin. Dies
ist vor allem bei einer größeren Gruppe wichtig, hier ist es nämlich schwer einen für
jeden passenden, regelmäßigen Termin zu finden, auf Grund der unterschiedlichen
Tagesabläufe im Team. Es ist auch ganz klar, dass ein Termin mal ausfällt,
beispielsweise wenn jemand krank ist. Doch als Team sollte man aufpassen, dass dies
nicht zu häufig vorkommt. Denn dadurch verliert man nicht nur Zeit, sondern auch immer
mehr die Motivation, wenn man sich längere Zeit nicht mehr mit dem Projekt beschäftigt.
Eine von der Gruppe geplante und begrenzte Pause ist an machen Stellen aber auch
sehr hilfreich, denn durch so eine Pause kann man wieder neue Ideen schöpfen und
kann die Probleme der Programmierung ganz anders angehen.

Wir haben uns bei SES von Anfang an den Freitag als unseren regelmäßigen
Treffpunkt ausgewählt. Das heißt, jeden Freitag haben wir nach der Schule
zusammen am SES programmiert oder uns um Angelegenheiten gekümmert, die
damit zu tun hatten. Natürlich haben wir uns auch an anderen Tagen mit SES
beschäftigt, doch hauptsächlich jeden Freitag. Wir hatten zu oft auch Phasen in
den zwei Jahren, in denen unsere Motivation nicht so groß war, da wir teilweise
mehrere Stunden an einer Kleinigkeit saßen, und dann zeitweilig auch andere
Sachen wichtiger waren, so dass wir zwischen durch auch mal mehrere Wochen
nicht programmiert haben. Das hat uns insgesamt ziemlich viel Zeit gekostet und
es wäre besser gewesen, hätten wir uns strikter an das Treffen am Freitag gehalten.
Hier hätten wir die fehlende Motivation erkennen müssen und eine geplante und
begrenzte Pause einlegen sollen.
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
2. Datenschutz

Schülerdaten (von Jan Leufen)


Wenn der Anwendungsbereich eines Informatikprojektes im Schulwesen liegt, dann ist
es wichtig die Datenschutzbestimmungen der Schulbehörde zu kennen. Schülerdaten
sind sehr sensible Daten, das bedeutet, sie sind im besonderen Maße zu schützen.
Gerade wenn es, wie im Fall einer Anwesenheitsverwaltung, um Krankheitsdaten geht,
denn diese Daten greifen tief in die Privatsphäre einer Person ein. Zu diesen sensiblen
Informationen gehören zum Beispiel die Anzahl der gefehlten Stunden und der
Krankheitsgrund. An diese Richtlinien muss man sich als Programmierer halten, doch
was ist dabei zu beachten?
Zuerst ist grundsätzlich die Sicherheit der Daten im Netzwerk zu beachten. Die
Schulbehörde stellt hier strenge Regeln auf, die besagen, dass das Netz der Unterrichts-
und der Kabinett-PCs auf keinen Fall Schülerdaten beinhalten darf. Man hat zwei
Möglichkeiten, dieses Problem zu umgehen:
Entweder man fügt ein weiteres Netz, ein sogenanntes Subnetz, zusätzlich zum schon
vorhanden Schülernetz hinzu oder man richtet ein physikalisch getrenntes Netz neben
dem Schulnetz ein.

Subnetz: Hier ist ein Grünes und ein Rotes Subnetz vorhanden. Sie benutzen die
selben Switches, allerdings können die PCs sich nur jeweils in ihrem Netzwerk
verständigen. Daraus folgt, dass nur die Rechner im grünen Netz auf das Internet
zugreifen können.
Der wesentliche Unterschied der beiden Optionen besteht darin, dass ein Subnetz die
schon vorhandene Infrastruktur nutzt, welche für das normale Schulnetz vorhanden ist
(Kabel, Switches, Server, …). Realisiert wird die Trennung über die IP-Adressen
Vergabe des Routers. Für die zweite Option wird eine eigene Infrastruktur neben der
vorhandenen eingerichtet. Je nach Anzahl der benötigten Geräte kann dies sehr
aufwendig sein.
Im Bezug auf die Sicherheit ist das getrennte Netz gegenüber dem Subnetz von Vorteil,
da es von außen unangreifbar ist. Zumindest solange es keine Sicherheitslücken, wie
falsch konfigurierte WLAN Access Points gibt.
Besondere Lernleistung Nele Schorer, Jan Leufen 9
Getrenntes Netz : Hier ist ebenfalls ein grünes und ein rotes Netz vorhanden.
Allerdings sind beide völlig getrennt voneinander, dass heißt, es müssen zwei Router
und jeweils verschiedene Switches vorhanden sein. Auch hier ist nur das grüne Netz
mit dem Internet verbunden.
Wir haben uns bei unserem Projekt für ein physikalisch getrenntes Netz
entschieden, weil es am WDG die einzige Möglichkeit war, das Projekt umzusetzen.
Unser Router bringt die Möglichkeit mit, bis zu drei Subnetze einzurichten, doch
sind diese alle schon für zukünftige Projekte der Schulbehörde reserviert. Das
erste Netz ist das Schulnetz, das zweite wird in Zukunft ein WLAN für die Schüler
beinhalten und das dritte wird voraussichtlich zu einer schuleigenen Cloud Lösung
für Unterrichtsdateien. Da somit kein Netz mehr für das SES bleibt, sind wir
gezwungen, die Alternative eines getrennten Netzes zu verwenden.
Wir haben einen Server, der die Daten speichert und die Website zur Verfügung
stellt und der gleichzeitig den Bildschirm bei den Fächern der Lehrerinnen und
Lehrer bedient. Über einen WLAN Router mit neuster WPA-PSK2 Verschlüsselung
sind dann der Laptop für das Schulbüro und der Rechner im Computerraum des
Lehrerzimmers verbunden.

Benutzerverwaltung (von Jan Leufen)


Eine schulische Anwesenheitsverwaltung wird von verschiedenen Personen genutzt.
Dazu gehören Sekretariat, Lehrer und Lehrerinnen und ein Administrator. Doch nicht alle
sollen alles können. Zum Beispiel, ist der Lehrer-Account nicht berechtigt, neue Benutzer
hinzuzufügen, genauso wie er nicht berechtigt ist, Abmeldungen zu löschen.
Diese Probleme löst man, indem man Benutzergruppen einrichtet.
Sobald sich ein Nutzer einloggt, wird ihm eine ID zugewiesen, mit dieser auch Variablen,
wie seine Benutzergruppe verknüpft sind. Wenn nun eine Seite entdeckt, dass die
gerade angemeldete Benutzergruppe keinen Zugriff auf sie hat, wird der Nutzer wieder
auf die Login Seite geleitet.

SSL Verschlüsselung (von Jan Leufen)


Wenn man sich für die Variante des Subnetzes im schon vorhandenen Schulnetz
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
entscheidet, ist es wichtig, die Verbindungen mit der Website zu verschlüsseln. Sonst
kann man mit einem „Man-in-the-Middle-Angriff“ vom Schulnetz die Daten des
Subnetzes mitlesen. Um das zu verhindern braucht man eine SSL Verschlüsselung.
Hier wird ein „Schlüsselpaar“ generiert, welches durch ein mathematisches Verfahren
(RSA) mithilfe von Primzahlen errechnet wurde. Der eine Schlüssel wird „public
key“ genannt und der andere „private key“. Der Client verschlüsselt mit dem „public key“,
der vom Server frei angeboten wird, seine Nachricht. Das Besondere ist, dass durch
Nutzung der Primzahlen das Entschlüsseln der Nachrichten mithilfe des „public
key“ unmöglich ist. Nur der Server kann mit seinem „private key“ die richtige Nachricht
entschlüsseln.
Der Traffic zwischen Client und Server ist damit nicht entschlüsselbar und die Sicherheit
von Passwörtern und den Schülerdaten ist gesichert:
Wir haben uns in unserem Projekt gegen die SSL Verschlüsselung entschieden,
da es in unserem Netz keine fremden Computer geben kann. Natürlich müssen
die Passwörter geheim gehalten werden.

Passwörter (von Jan Leufen)


Passwörter sind immer wieder Thema, wenn man über die Sicherheit im Internet spricht.
Nicht nur lang und kryptisch müssen sie sein, sie sollten auch sicher in der Datenbank
gespeichert sein. Man möchte schließlich nicht, dass unbefugte Personen Zugriff auf
einen Account bekommen können, indem sie die Passwörter hacken. Doch wie sieht das
optimal gespeicherte Passwort aus?
$2y$12$WUdhqsTkJMSFoYSRn0hc6O6WKn054/mbM.iaCqdlkKJGADLHuZRgq
Das oben Stehende nennt man Hash. Er wird aus drei Dingen generiert:
- Dem eigentlichen Passwort, welches der Nutzer auf der Website eingibt
- Dem Salt, einem Zusatz, der zufällig bei der Eingabe generiert wird, und der in der
Datenbank einfach mit $ gekennzeichnet vor den Hashwert des Passworts gesetzt wird.
($2y$12$)
- Und dem Pepper, einer Kombination aus Zeichen, der bei der Errechnung des
Hashwertes einfach hinter das Passwort gehängt wird.
hash(SALT+Passwort+PEPPER) → $SALT$HASH
Warum der Aufwand, die Passwörter sind doch, wenn sie einfach nur gehasht sind, auch
schon nicht mehr erkennbar?
Die Antwort darauf liegt in den so genannten „rainbow tables“. Sie bestehen aus vor
generierten Hashwerten, von den am meisten benutzten Passwörtern. Wenn man die
Datenbank gehackt hat, kann man die Hashwerte einfach vergleichen und
Übereinstimmungen verraten dann das Passwort. Aus diesem Grund wird das Passwort
mit SALT und PEPPER unkenntlich gemacht. Für jeden Hash in der Datenbank müsste
man eine eigene „rainbow table“ genieren. Außerdem braucht man dafür den PEPPER,

Besondere Lernleistung Nele Schorer, Jan Leufen 11


den man nur hat, wenn man den Webserver auch gehackt hat. Denn der PEPPER wird
hier eingefügt und steht nicht in der Datenbank.
Im SES haben wir mit der CRYPT_BLOWFISH Verschlüsselung gearbeitet.
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
3. Programmierung

Programmierung im Team (von Nele Schorer)


Wenn man im Team zusammen programmiert, gibt es ein paar Voraussetzungen, die
das Team erfüllen sollte, damit die Programmierung erfolgreich ist. Genauer gesagt, gibt
es drei Voraussetzungen:

Die erste Voraussetzung ist, dass sich das Team auf menschlicher Ebene gut versteht,
so dass es keine grundsätzlichen Streitereien gibt, die nichts mit der Programmierung
zu tun haben. Denn wenn man als Team ein Projekt verwirklichen möchte, hat man
viel miteinander zu tun. Da wären Streitereien nur hinderlich. Natürlich wird es
Meinungsverschiedenheiten geben, dies ist aber ganz normal.

Die zweite Voraussetzung ist, dass man Kompromisse eingeht. Damit


Meinungsverschiedenheiten das Projekt nicht zu lange aufhalten, ist es wichtig, nicht
mit der Einstellung in das Projekt zu gehen, nur seine eigene Meinung durchsetzen zu
wollen. Man sollte sich auf die Vorschläge des Teams einlassen können.

Die dritte Voraussetzung ist, dass alle Teammitglieder mit ihren Fähigkeiten auf dem
gleichem Niveau sind. Das bedeutet, dass nicht einer aus dem Team gerade erst mit
dem Programmieren angefangen hat, während die Anderen schon mehrere Jahre
Erfahrungen haben. Denn jeder im Team hat seine Aufgabe und es wäre hinderlich,
wenn nicht alle Teammitglieder in einem ungefähr gleichen Tempo arbeiten könnten.
Das hätte zur Folge, dass das Team nicht gut zusammenarbeiten kann, weil ein Teil
der Programmierung noch nicht fertig ist und sich das ganze Projekt in die Länge zieht
(→ Kapitel eins „Arbeit aufteilen“).

Wenn man die Voraussetzungen mit seinem Team erfüllt, werden die oben genannten
Probleme nicht im starken Ausmaß auftreten und die Programmierung im Team wird
wesentlich leichter fallen. Dennoch hat es sowohl Vorteile als auch Nachteile in einem
Team zu Programmieren, an denen man ermessen muss, ob man das jeweilige Projekt
im Team oder alleine verwirklichen möchte.

Offensichtlich ist, dass man sich, wenn man im Team programmiert, gut gegenseitig
helfen kann und es immer mehr als nur eine Sichtweise auf ein Problem oder auf die
Vorschläge gibt. Das heißt, dass das Konzept durch die unterschiedlichen Meinungen
zu einem besseren entwickelt werden kann und dass man Probleme durch die Hilfe
anderer schneller lösen kann, sodass durch die Behebung eines Problems nicht zu viel
Zeit verloren geht. Hierbei sei gesagt, dass es von Vorteil ist, sollte man ein Problem
gelöst haben, gleich die Lösung festzuhalten. Denn sollte das gleiche Problem später
noch einmal auftauchen, kann es vorkommen, das man die Lösung dieses Problems
wieder vergessen hat.

Besondere Lernleistung Nele Schorer, Jan Leufen 13


Nachdem wir in SES den JQuery Kalender implementiert hatten, traten zahlreiche
Probleme auf und diese zu lösen, nahm viel Zeit in Anspruch. Ein halbes Jahr
später mussten wir erneut den Kalender implementieren und es traten die selben
Anzeigefehler auf, sodass wir wieder nach dem Fehler suchen mussten, weil wir
uns keine Lösung aufgeschrieben hatten.

Wenn man im Team programmiert, hat man nebenbei auch immer noch jemanden mit
dem man sich auch mal anderweitig beschäftigen kann. So kann man sich kurz von
seiner Programmierung lösen, um danach wieder auf neue Gedanken zu kommen.
Dabei muss man allerdings auch aufpassen, dass man sich gegenseitig nicht zu sehr
ablenkt. Denn ansonsten geht dabei eine Menge Zeit verloren und das wäre, wenn dies
zu oft vorkommen würde, nicht sehr produktiv und würde das Projekt nicht weiterbringen.

Jedes Team sollte dafür sorgen, dass sich alle Mitglieder wöchentlich einmal gleichzeitig
zusammensetzen, um zu programmieren und sich gegenseitig auf dem Laufendem zu
halten. Welche Fortschritte hat man erzielt und was sind nun die nächsten Schritte.
Darüber hinaus besteht dadurch auch die Möglichkeit, bereits programmierte Funktionen
dem Team zu demonstrieren.

Beim gemeinsamen Programmieren tut sich das Problem auf, dass mehrere Personen
nicht gleichzeitig an einer Datei arbeiten können. Denn würde die eine Person die
bearbeitete Datei speichern und die zweite Person ihre Version, würden sich die Inhalte
überschneiden und Teile des jeweilig anderen Codes verloren gehen. Um dieses
Problem zu umgehen, kann man Programme, wie „SVN“ oder „GIT“ (siehe Quellen),
benutzen um die Dateien zu verwalten und die vollständige Änderung nachzuverfolgen.

Eine weitere Frage, die man sich stellen muss, wenn man im Team programmiert, ist, ob
jedes Mitglied den programmierten Code des Anderen kennen und verstehen muss. Bei
einem sehr komplexen Projekt ist dies nicht möglich, da es über tausende Seiten
Quellcode gibt. Doch gerade bei einem überschaubaren Projekt wie einer schulischen
Abwesenheits-Verwaltung ist es von Vorteil, wenn jeder zu mindestens im Ansatz weiß,
für was der bestimmte Code da ist und was er macht. Denn teilweise überschneiden sich
verschiedene Funktionen, die unterschiedliche Personen programmiert haben. An
diesen Stellen ist es gut zu wissen, wie die jeweiligen Funktionen arbeiten. Anderenfalls
ist es von jedem Teammitglied hilfreich den Text zu kommentieren, um so den anderen
Teammitgliedern einen guten Überblick zu verschaffen.

Das "SES" Projekt haben wir zu zweit durchgeführt. Wir haben schon zuvor ein
kleineres Informatikprojekt zusammen verwirklicht und verstehen uns auch
menschlich gut. Deshalb hatten wir auch während der Programmierung nur eine
Auseinandersetzung, die wir schnell gelöst haben. Wir hatten zwar öfters
verschiedene Meinungen und Ansichten, wie wir zum Beispiel eine Funktion
gestalten oder darüber, welche Funktionen wirklich notwendig sind. Bei diesen
Meinungsverschiedenheiten konnten wir uns aber immer gut einigen und wir sind
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
beide mit allem zufrieden.

Dass wir zu zweit gearbeitet haben, hat uns sehr geholfen. Wir haben uns
gegenseitig bei Problemen unterstützt und konnten so auch meistens schneller
vorankommen. Zwar hatten wir auch Zeiten, in denen wir uns gegenseitig
abgelenkt haben und uns lieber mit privaten Sachen beschäftigt haben, aber trotz
alledem haben wir uns immer gegenseitig motiviert, um weiter zu kommen. Auch
wenn wir über mehrere Stunden freitags programmiert haben und nicht
vorangekommen sind.

Wir haben uns unseren Code von Anfang an immer gegenseitig gezeigt und auch
erklärt, damit wir jeweils einen groben Überblick hatten. Dies war ganz hilfreich,
wenn man mit dem Code des anderen arbeiten musste, zum Beispiel als das
Design für eine Seite, die der andere programmiert hatte, erstellt werden musste.

Schlussendlich lässt sich also eindeutig festhalten, dass es für uns auf jeden Fall
von Vorteil war zusammen zu arbeiten. Wir haben gut und produktiv zusammen
gearbeitet, konnten so sicherlich Zeit sparen und SES zu einem guten Projekt
werden lassen.

Technologien (von Jan Leufen)


Wenn man ein Projekt wie eine Schulische Anwesenheitskontrolle anfängt zu
programmieren, dann hört es sich, wie bei vielen anderen Projekten auch, am Anfang
relativ einfach und simpel an. Doch je mehr man in die Programmierung eintaucht, desto
mehr Probleme tun sich auf. Somit wundert es nicht wenn man wie wir, vor der
Programmierung am SES noch nie etwas von den jetzt folgenden Technologien gehört
hat. Aber spätestens nach der Fertigstellung ist klar, dass man nie mehr auf diese Dinge
verzichten kann, sollte man an einer schulischen Anwesenheitskontrolle arbeiten.

Ajax (von Jan Leufen)

Wenn man eine Website entwickeln möchte, die für die Benutzung am Telefon geeignet
sein soll, muss man sich darüber Gedanken machen, wie schnell es möglich ist,
Eingaben in die Formulare zu machen. Doch wie kann man die Ladezeiten seiner
Website verbessern?
Wenn man über einen einfachen Link auf eine andere Seite weitergeleitet wird, kann es
zu größeren Pausen kommen, da Ressourcen wie Bilder neu vom Server
heruntergeladen werden. Diese Ladezeiten sind einer schnellen Benutzung nicht
zuträglich.
Des Weiteren muss die Website übersichtlich gestaltet sein, um schnelles Navigieren zu
den gewünschten Funktionen zu ermöglichen (→ Kapitel drei „Benutzerfreundlichkeit“).

Besondere Lernleistung Nele Schorer, Jan Leufen 15


Zu viele verschiedene einzelne Seiten, mit jeweils nur einer Funktion, steigern die
Komplexität und tragen nicht zur Übersichtlichkeit bei. Doch wenn man eine Abfrage aus
einer Datenbank machen möchte, zum Beispiel für eine Suche, braucht es eine neue
Seite, die aufgerufen wird, sobald ein Nutzer etwas in das Suchfeld eingibt.
Es ist gut, wenn sich das Suchfeld auf der selben Seite befindet, auf der später auch das
Ergebnis angezeigt wird, doch die Website wurde ja zum Zeitpunkt der Eingabe schon
fertig aufgebaut, wie ist es dann möglich, auf einer schon geladenen Seite Daten
„nachzuladen“?
Die Lösung auf diese Frage ist die Technologie „Ajax“. Sie ermöglicht, im Hintergrund
der schon angezeigten und fertig aufgebauten Website weitere Codes nachzuladen und
auszuführen. Ajax basiert auf Java Script und wird von jedem gängigen Browser
unterstützt.
Ajax ist die Schnittstelle zwischen der serverseitigen Datenbankverbindung, welche über
die Programmiersprache PHP aufgebaut wird und der HTML/Java Script GUI
(„Grafisches User Interface“) des Anwenders.

Ajax: Im ersten Schritt wird das GUI auf dem Client Computer aufgebaut und die Website
ist in ihrer vollständigen Form zu sehen. Im zweiten Schritt hat der User eine Funktion
benutzt, die Zugriff auf die Datenbank benötigt. Also wird über Ajax der serverseitige
Datenbank Code ausgeführt. In der Datenbank wird jetzt etwas gesucht oder
hinzugefügt. Das Ergebnis wird nun im dritten Schritt als Text wieder übergeben und an
den Client zurückgesendet.
Dahinter steht ein Konzept, welches die Zugriffe auf die Datenbank und das GUI in
unterschiedliche Dateien trennt.
Der User sieht nichts von der Kommunikation mit dem Server. Die Website wird nicht
komplett neu geladen und es ist auch kaum Verzögerung vorhanden, da keine Bilder
oder andere große Dateien wie die HTML Datei neu geladen werden.
Das Ergebnis ist eine schnelle und einfach gestaltete Website.

Im SES haben wir fast auf jeder Seite von Ajax Gebrauch gemacht. Die Seite für
die Entschuldigungen der Schüler beinhaltet nicht nur die Suchfunktion sondern
auch noch das Fenster zum Eintragen der Entschuldigungsdaten. Diese
Kompaktheit gewährleistet eine besonderer Schnelligkeit, welche beim
Telefonieren sehr wichtig ist, da Informationen nur mündlich übertragen werden
und der Gesprächspartner eventuell keine Zeit hat zu warten, bis das Sekretariat
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
die Informationen in die Maske eingetragen hat. Des Weiteren ging es ja darum,
das alte System der Abmeldungs-Zettel zu ersetzen. Auch das ist sehr viel
einfacher geworden, da jetzt Schülernamen explizit gesucht werden können.

Menüleiste (von Jan Leufen)


Die Übersichtlichkeit ist, wie schon öfters im Laufe dieses Leitfadens erwähnt, ein sehr
wichtiger Teil einer schulischen Anwesenheitskontrolle. Nicht nur weil viele Anwender
nicht vertraut sind mit der Benutzung eines Computers, sondern auch um eine möglichst
kurze Beschäftigung mit dem Programm zu ermöglichen, zum Beispiel, wenn man nur
mal eben kurz etwas nachschauen möchte.
Um also schnell von einer Seite auf die Andere navigieren zu können, braucht es eine
Art Menü. Da sich das Menü aus Gründen der Übersichtlichkeit und der
Wiedererkennung immer an der selben Stelle befinden und gleich aussehen muss, bietet
sich eine generelle Implementation an. Ein schlechter, aber dennoch möglicher Weg,
wäre es, die Menüleiste auf jeder Seite neu zu programmieren oder auch einfach nur
den Code zu kopieren und wieder neu einzufügen. Nicht nur, dass sich Fehler so schnell
duplizieren, Änderungen müssen auch auf jeder Seite extra vorgenommen werden.
Eine deutlich bessere Lösung ist die einmalige, aber konfigurierbare Implementation.
Sie hat den Vorteil, dass auf der Seite, auf der die Menüleiste erscheinen soll, nur eine
Datei importiert werden muss und schon wird die Menüleiste angezeigt.
Gedanken kann man sich jetzt noch darüber machen, ob immer alle Unterseiten (Seiten,
wie Password ändern, Hauptmenü oder SES) im Menü angezeigt werden müssen. Bei
einem kleineren Projekt wie der Anwesenheitskontrolle, ist das sicherlich nicht nötig. Hier
kann man auswählen, auf welche Seiten das Menü verweisen soll. Ein Beispiel:
Auf der Seite, auf der die Abwesenheit von Schülern eingetragen wird, gibt es die
Möglichkeit, über die Menüleiste auf folgende Seiten zu wechseln: Hauptmenü und
Schüler hinzufügen. Auf der Seite der Abwesenheitstabelle hingegen geht es nur zurück
ins Hauptmenü, da Lehrer (Diese Gruppe ist die Einzige, welche diese Seite zu Gesicht
bekommt) keine weiteren Seiten haben, auf die sie wechseln können, abgesehen von
„Passwort ändern“.
Das SES ist so komplex, dass es eine Menüleiste braucht, allerdings ist es noch
nicht so groß, dass jede Unterseite alle anderen Seiten verlinken muss. Aus
diesem Grund haben wir uns unter anderem für eine Implementation entschieden,
die es erlaubt, auf jeder Seite individuell einzustellen, welche anderen Seiten
angezeigt werden sollen. Ein Codebeispiel soll das veranschaulichen.
Hier ist die Datei changePassword.php heruntergebrochen auf die Bestandteile der
Menüleiste sowie die Konfigurationsdatei change-password.dat.
------------------------- changePassword.php -------------------------
<!DOCTYPE html>
<html>
<head>

Besondere Lernleistung Nele Schorer, Jan Leufen 17


<?php
$menubarpath = './menubar';
$menutype = 'change-password';
include("./menubar/menubar.php");
?> ...
</head>
<body>
<?php
createMenuBarHere($menubarpath, $menutype);
?> ...
</body>
</html>
------------------------- change-password.dat -------------------------
"Hauptmenü"|../,
"Logout"|../session/logout.php

Im Header der HTML Datei, wird die Menüleiste importiert und alle wichtigen
Variablen für die korrekte Anzeige instanziiert:
$menubarpath gibt den Pfad zu der Menüleistenbibliothek an. (Kann bei jeder
Datei unterschiedlich sein)
$menutype ist der Name der Konfigurationsdatei, welche dann die einzelnen
Einträge der Menüleiste festlegt.
Im Body wird die Menüleiste dann mit createMenuBarHere(…) angezeigt.
In der Konfigurationsdatei wird der Name und der jeweilige Pfad zu jedem Eintrag
in der Menüleiste angegeben. Das Resultat würde ungefähr so aussehen:

Hauptmenü Logout

Suchfunktion (von Nele Schorer)


Hinter einer schulischen Anwesenheitsverwaltung steht eine große Datenbank mit vielen
Daten und vor allem auch vielen Schülern. In dieser Datenbank werden je nach Schul e
mehr als tausend Schüler abgespeichert. Und um an einzelne Schülerdaten
heranzukommen, muss es eine Möglichkeit geben, die Schüler schnell in der Datenbank
zu finden, anstatt jeden Schüler einzeln aus der Menge von tausend Schülern
herauszusuchen. Dafür ist eine gute Suchfunktion sehr wichtig.
Die Suche muss die gesuchten Namen der Schüler schnell und klar anzeigen. Und um
das zu erreichen, ist es von Vorteil, eine Suche zu programmieren, bei welcher schon
während des Schreibens verschiedene Vorschläge und Möglichkeiten angezeigt werden.
Dies passiert mittels Ajax, wobei die Ergebnisse in die bereits geladene Seite
eingeschoben werden (→ Siehe Kapitel 3 „Programmierung“ unter „Ajax“). Die
bekannteste Suche dieser Art ist wahrscheinlich die Google- Suchmaschine, die einem
schon während des Suchens mehrere Möglichkeiten vorschlägt, die mit der Eingabe
zusammenhängen. Eine andere Suchfunktion, bei der man die Suche erst mit
„Enter“ bestätigen muss, bevor Ergebnisse angezeigt werden, ist an dieser Stelle nicht
sehr von Vorteil. Dies wäre eindeutig zu langsam und würde das Neuladen der gesamten
Seite erfordern.
Wir haben uns also ein Beispiel an der Instant-Suche genommen und haben nun
eine Suchfunktion, die noch während der Suche Ergebnisse anzeigt, die die
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
bisherige Sucheingabe beinhalten. Wenn man beispielsweise „el“ eintippt,
werden einem, während man schreibt, die verschiedensten Namen mit
„el“ angezeigt, wie zum Beispiel „Nele“ oder „Helena“. So eine Instant-Suche in
SES einzubinden ist sehr wichtig gewesen, denn das Sekretariat hat mehrmals
darauf hingewiesen, dass es morgens, wenn viele Eltern oder Schüler
gleichzeitig anrufen, es mit dem Eintragen und der Schülersuche schnell gehen
muss. Und da die „LUST“ wesentlich langsamer ist, hat sich die Arbeit durch die
Instant-Suche verbessert.

Kalender – jQuery (von Nele Schorer)


Für eine schulische Anwesenheitsverwaltung benötigt man auf jeden Fall eine Art
Kalender, eine Auswahlmöglichkeit, um ein beliebiges Datum festhalten zu können, da
ansonsten keine angenehme Verwendung der Anwendung möglich ist. Schließlich soll
zum einen auch eingetragen werden können, wie lange bzw. „von wann“ - „bis
wann“ eine bestimmte Person nicht anwesend sein wird. Und zum anderen soll es
darüber hinaus auch die Funktion geben, dass man sich die verschiedenen Daten noch
einmal nachträglich ansehen kann. Diese Funktion ist wichtig, da nicht alle Lehrer jeden
Tag in der Schule sind und somit die Daten auch noch im Nachhinein zu Verfügung
stehen müssen. Ein Kalender ist demnach wichtig, um die Abmeldedaten einzutragen
und auch um Informationen aus dem Abmeldungssystem herauszufinden. Der Kalender
eignet sich dafür optimal, da die Nutzer schnell einen klaren Blick auf den Monat haben
und mit einem Klick mehrere Daten (Wer? Wann? Wie lange?) eintragen können und
nicht einzeln das Datum per Hand eintragen müssen.
Es wird für ein Abwesenheitssystem ein Kalender benötigt, deswegen hat man zwei
Möglichkeiten. Entweder man programmiert selbst einen oder man sucht bereits
vorhandene, programmierte Kalender, die im Internet zu Verfügung stehen. Beides hat
Vor- und Nachteile. Sollte man sich einen eigenen Kalender programmieren, ist dies
zum einen sehr zeitaufwändig und zum anderen auch sehr umständlich, da man sich
erst mal in das Thema einlesen muss, viele neue Probleme auftreten und von anderen
wichtigeren Problemen im Projekt ablenken. Dafür könnte man diesen nach längerer
Arbeit individueller und nach eigenen Vorstellungen gestalten. Außerdem versteht man
die komplette Funktionsweise und kann anschließend bei Problemen, diese viel besser
finden. Dies ist nicht unbedingt der Fall, wenn man einen bereits vorhandenen, nicht
selbst programmierten Kalender auf seiner Website einbindet. Natürlich kann man sich
auch bei dieser Art eines Kalenders den Code ansehen und probieren ihn zu verstehen.
Dies fällt aber wesentlich schwerer, wenn man den Code nicht selber geschrieben hat.
Dafür erspart man sich im besten Falle Zeit und Arbeit, weil man den Kalender nicht von
Grund auf neu programmieren muss, sondern nur Kleinigkeiten verändert.
Wir haben uns für die zweite Variante entschieden, einen bereits vorhandenen
Besondere Lernleistung Nele Schorer, Jan Leufen 19
Kalender auszuwählen und auf unserer Seite einzubinden. Dies erschien uns
wesentlich einfacher und nicht so zeitaufwändig. Und da wir andere Probleme
hatten (Suchfunktion, Ajax..) und auch nicht genug Zeit übrig hatten, entschieden
wir uns für den „Datepicker“ von „jQuery“. „jQuery“ ist eine öffentliche JavaScript
Bibliothek, wo verschiedene Funktionen, wie der Kalender oder ein Selectmenü,
zu Verfügung gestellt werden.
Das Einbinden und Verstehen dieses Kalenders war schwerer als gedacht. Denn
um den Code in SES einzubinden, waren zwei JavaScript, zwei CSS Dateien
und noch weitere kleinere Funktionen notwendig. Es gab dabei große Probleme,
welche uns sehr viel Zeit gekostet haben. Zum Beispiel ließ sich der Kalender
nicht öffnen. Das Kalenderfeld war auf der Seite vorhanden, doch es erschien
kein Kalender, hatte man in dieses Feld gedrückt. Auch zu zweit und mit Herr
Kiehnes Hilfe ist uns erst nach vielen Stunden eine Lösung eingefallen. Wir
standen zweimal vor diesem Problem, da wir uns beim ersten Mal nicht
aufgeschrieben haben, wie wir das Problem gelöst haben. Noch immer verstehen
wir die Implementierung des Kalenders nicht vollständig. Das ist hinderlich, wenn
es Probleme mit dem Kalender gibt. Doch bis jetzt haben wir diese immer lösen
können. Trotz allem war es eine gute Idee, einen schon vorhandenen Kalender
zu nehmen. Denn trotz der langen Fehlersuche haben wir sicherlich Zeit gespart
und der Kalender erfüllt nun gut und zuverlässig seine Aufgabe.

Zeichenkodierung (von Jan Leufen)


Im Jahre 1832 erfand Samuel F. B. Morse das Übertragen von Informationen, vor allem
von Buchstaben, über den elektrischen Strom. Das so genannte Morse Alphabet,
welches er benutzte, wurde nach ihm benannt. Es ist ein System, über das man durch
lange und kurze Abstände zwischen Strom an und Strom aus, Buchstaben übertragen
kann.
Im Laufe der Zeit wurden viele solcher Alphabete erfunden, doch heutzutage benutzen
die meisten Menschen Computer zur Informationsübertragung. Viele dieser verschieden
Kulturen haben über die Zeit verschiedene Alphabete entwickelt. Sie können mit den
lateinischen Schriftzeichen nichts anfangen, da sie andere Schriftzeichen verwenden.
Aus diesem Grund wurden verschiedene Zeichenstandards festgelegt, die fast alle
Schriftzeichen dieser Welt erfassen können:

ISO-8859-1 verschlüsselt alle europäischen Sprachen

UTF-8 die am weiten verbreitete Codierung des Unicode Zeichensatzes

Darüber hinaus gibt es noch einige tausend andere Kodierungen, von denen viele noch
auf die Besonderheiten verschiedener Sprachen angepasst sind. (Deutsch,
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
Schwedisch, ...)
Um sich darüber klar zu werden, welch wichtige Rolle die einzelnen Kodierungen spielen,
sollte man sich erst mal angucken, wie die Kette der Programmiersprachen aussieht,
durch die der Text, welcher zum Beispiel vom Nutzer eingegeben wird, durchläuft. Beim
Speichern eines Namens in die Datenbank sieht die Kette vielleicht so aus:
„Müller“ → HTML → JavaScript → PHP → MySQL → „Müüüller“
Wenn HTML die Zeichen in ISO-8859-1 codiert, JavaScript und PHP in UTF-8 und
MySQL (die Datenbank) latein1_swedish_ci benutzt (Die Programmierer von
PHPMyAdmin kommen aus Schweden), dann wird hier das „ü“ durch völlig falsche
Zeichen ersetzt.
Man sieht, es ist sehr wichtig, auf die korrekte Kodierung der einzelnen
Programmiersprachen zu achten, um ein einheitliches Schriftbild der Website zu
erzeugen.
Beim SES ist es uns gelungen, nach sehr vielen Stunden des Suchens, alle
Probleme zu lösen, die mit Zeichenkodierung zu tun hatten. Besonders die
Datenbank hat gleich mehrere Einstellmöglichkeiten für die Zeichenkodierung. Wir
haben uns für den UTF-8 Standard entschieden, da dieser der am weitesten
verbreitete ist. Es hat sehr lange gedauert überhaupt herauszufinden, wo man
überall UTF-8 einstellen muss, damit man keine falschen Zeichen abspeichert.

Gestaltung mit CSS (von Nele Schorer)

Die Gestaltung einer Website ist ein ganz wichtiges Thema. Denn nur eine
ansprechende Anwendung wird von den Anwendern gerne und regelmäßig genutzt (→
Kapitel drei „Benutzerfreundlichkeit). Früher wurden Websites nur mittels HTML
programmiert, doch mittlerweile ist HTML nur noch für die Strukturierung des Inhalts
zuständig. Mit HTML wird festgelegt, ob ein gewisser Textabschnitt zum Beispiel als
Überschrift fungiert oder wie eine Tabelle strukturiert ist. CSS („Cascading Style Sheets
“) hingegen ist für die Formatierung des Layouts zuständig. Dazu gehört unter anderem
die Farbe, der Abstand oder Ausrichtungen verschiedener Objekte, die man zuvor mittels
HTML definiert hat. Man kann auch den CSS Code nur in die HTML Elemente hinein
schreiben. Dies führt aber dazu, dass der gesamte Code sehr unübersichtlich wird. Denn
alles muss innerhalb einer Datei nicht nur strukturiert, sondern auch noch gestaltet
werden. Während bei der Benutzung von CSS wird die CSS Datei ausgelagert und man
kann auf einen Blick alle Formatierungen erkennen. Die Formatierungen des Layouts
werden also in der extra Datei mit der Endung „.css“ definiert. Man darf allerdings nicht
vergessen, die Datei mit der eigentlichen HTML Datei zu verknüpfen:
<link href="Verzeichnis/Dateiname" type="text/css"
rel="stylesheet">
Eine CSS Datei kann man auch auf mehreren HTML Seiten anwenden, wenn auf diesen
die CSS Datei verlinkt wurde. Seiten mit einem fast identischen Aufbau müssen so nicht
Besondere Lernleistung Nele Schorer, Jan Leufen 21
zweimal gestaltet werden. Darüber hinaus gibt es in CSS mittlerweile durchaus mehr
Möglichkeiten, (da bei HTML auch schon vieles veraltet ist), zum Beispiel Tabellen zu
gestalten. So kann man die exakte Zeilenhöhe bestimmen, denn bei HTML orientiert sich
die Tabelle an einer Gesamtgröße der Tabelle und an den einfügten Tabelleninhalt, um
die Zeilenhöhe zu definieren. Heutzutage wird CSS viel verwendet, da es gerade auf
Grund der Übersichtlichkeit, bei größeren Websites praktischer zu nutzen ist.
Wir haben uns bei unserer Website auch für die Anwendung von CSS
entschieden. Denn wir haben teilweise sehr lange Codes und viele Dateien, und
um dort einen Überblick über das Layout zu behalten, ist es für uns praktischer
gewesen, die Gestaltung des Layouts mittels CSS durchzuführen, anstatt den
CSS Code in die HTML Elemente zu implementieren.
Wir haben die Gestaltung mit extra CSS Dateien nicht konsequent durchgezogen.
So gibt es immer noch Teile im Code, wo zum Beispiel die Höhe einer Tabelle
oder „DIV-Box“ gleich dazu geschrieben wurde. Bei Tabellen, die wesentlich
komplexer waren, wie zum Beispiel die auf der Auswertungsseite, haben wir
immer mit extra CSS Dateien gearbeitet. Das einzige Problem, was wir mit der
Benutzung von CSS hatten, war, dass wir zum Beispiel Tabellen die ID
„Blub“ gegeben haben und man somit in der CSS Datei nicht wusste, welche
Tabelle damit gemeint war. Dies haben wir aber dann probiert zu vermeiden und
uns passendere Platzhalter auszudenken.

Benutzerfreundlichkeit (von Nele Schorer)


Wenn man eine schulische Anwesenheitsverwaltung programmiert, geht man davon aus,
dass diese auch genutzt wird und zwar von Lehrern und dem Sekretariat. Das bedeutet,
man muss bei der Programmierung des Layouts und Designs darauf achten, dass es
benutzerfreundlich ist. Benutzerfreundlichkeit erkennt man daran, dass die Anwendung
zum einen ansprechend aussieht und zum anderen auch leicht zu bedienen ist. Wenn
die Website nicht benutzerfreundlich gestaltet ist, benutzen die Anwender die Website
auch nicht gerne oder gar nicht.
Um eine Website ansprechend zu gestalten, muss man drei Punkte beachten. Als erstes
die Farbgestaltung. Damit der Anwender nicht abgeschreckt wird, ist es wichtig nicht zu
viele und zu grelle Farben zu benutzen. Es sollten zwei Farben für das Grundlayout (z.B.
Hintergrund) genutzt werden und eine weitere Farbe um Akzente zu setzen (z.B.
Rahmen, Unterteilungen). Auf den unterschiedlichen Seiten der Website sollte die
Farbauswahl auch nicht mehr variieren, denn dies kann zu Verwirrung führen.
Der zweite Punkt ist die Textgestaltung. Natürlich soll der Text sich deutlich vom
Hintergrund abheben und gut lesbar sein. Dafür braucht er eine geeignete Schriftfarbe
und auch Schriftart. Die Schriftgröße muss ebenfalls gut ausgewählt sein. Denn sollte
der Text zu groß sein, wird der Anwender „erschlagen“. Sollte der Text aber zu klein sein,
kann der Anwender ihn nicht mehr lesen. Deshalb sollte man abhängig von der Schriftart
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
immer eine passende Größe heraussuchen. Für Überschriften darf die Textgröße auch
mal etwas größer sein. Der Text ist allerdings zwecklos, wenn die äußere Form des
Textes ansprechend, aber der Inhalt des Textes wiederum belanglos ist. Die schulische
Abwesenheitsverwaltung wird von den Anwendern mehrmals am Tag benutzt. Das
bedeutet, sie werden mehrmals am Tag die vorhandenen Texte wie den Begrüßungstext
sehen. Bei so einer Website ist es demnach wichtig den Text möglich kurz zu halten
und den Inhalt auf das Wesentliche zu beschränken.
Der dritte Punkt für eine benutzerfreundliche Website ist die Struktur. Es ist ganz wichtig,
dass bei einer Seite, die regelmäßig benutzt wird, die Struktur klar und sichtbar ist. Das
bedeutet, dass der Anwender sofort sehen kann, für was die Seite da ist und was er wo
auf der Seite machen kann. Folglich bedeutet das, dass die Website einer schulischen
Anwesenheitsverwaltung selbsterklärend und einfach gestaltet sein muss. Um das zu
erreichen, sollte nur das Nötigste auf der Website angezeigt werden. Es darf kein
ausgefallenes Design mit verschiedenen Mustern geben, sondern die Seite sollte ganz
schlicht und nach dem Standard gehalten werden. Es darf zum Beispiel der
Bestätigungs-Button nicht auf einmal rechts sein, wo sonst der Abbruch Button ist.
Bei SES haben wir probiert, das Design möglichst schlicht und einfach zu halten.
Dadurch soll die gesamte Website moderner aussehen. Wir haben uns für die drei
Farben entschieden, in denen auch die neue WDG-Website gestaltet wurde. Diese
Farbwahl mussten wir während der Programmierung einmal ändern, weil das
WDG eine neue Website bekommen hat. Dadurch haben wir die folgende
Farbwahl getroffen:

Vorher:

Man erkennt, das vorher einer der Hauptfarben (dunkelgrün) kräftiger war als die
kleinere Farbe (weiß) die Akzente setzen sollte. Das war nicht gut, demnach ist
das jetzige Layout wesentlich ansprechender für die Anwender.
Die Schriftfarbe haben wir schwarz gelassen, bei einer Schriftgröße von zwölf. Den
Text haben wir so gering wie möglich bei SES gehalten. Denn es ist eine
Anwendung und keine Website, die informieren soll.
Die Struktur der Website ist auch klar, es gibt auf jeder Seite einen Rahmen um
den Inhalt, über dem Rahmen ist das Logo zu sehen. Und in der Mitte, im Rahmen,
befindet sich dann die jeweilige Funktion der Seite. Nur bei der Auswertung war es
aufwendiger, eine übersichtliche Struktur zu programmieren.
Das Problem hier war, dass viele Informationen dicht aufeinander angezeigt

Besondere Lernleistung Nele Schorer, Jan Leufen 23


werden müssen. Das wirkt schnell unübersichtlich. Um dem zu entgehen, haben
wir abwechselnd verschiedene Farben zum Hervorheben der verschiedenen
Klassen genutzt. Dabei haben wir uns an dem Design des Vertretungsplans
orientiert, weil dies schon ein gewohnter Anblick war und sich die Anwender so
nicht noch an eine ganz andere Darstellung gewöhnen muss. An dieser Stelle ist
es allerdings wichtig zu erwähnen, dass wir nicht aus dem Spurcecode des
Vertretungsplans kopiert und abgeschrieben haben, sondern das Layout gänzlich
selbstständig programmiert haben.
Als Schriftart haben wir durchgängig „Arial“ mit einer Schriftgröße von etwa 11
gewählt. Außer einem kurzen Willkommenstext bei der Anmeldung haben wir
längere Texte vermieden, da unsere Website selbsterklärend ist.

Redundanz von Daten (von Jan Leufen)


Bei einer Website, die so komplex ist wie das SES, wird es wichtig, sich um die
Redundanz von Daten Gedanken zu machen. Redundanz bedeutet, das Abspeichern
von den selben Daten doppelt oder mehr. Doch warum stellt Redundanz ein Problem in
der Programmierung da?
Diese Redundanz kann positiv aber auch negativ sein. Ein positives Beispiel ist der RAID
Festplattenverbund des Servers, auf dem das Programm / die Website läuft. Ein RAID
System speichert die Daten in unterschiedlicher Weise so ab, das sie doppelt vorhanden
sind. Sollte eine Festplatte ausfallen, sind die Daten nicht verloren, weil sie auf anderen
Festplatten ebenfalls gesichert wurden. Es gibt sehr viele verschiedene Arten von RAID
Systemen, das einfachste für unser Projekt ist ein RAID 1 System. Hier werden die Daten
einfach auf zwei Festplatten gleichzeitig geschrieben.
Negativ ist Redundanz allerdings dann, wenn Daten, z.B. in einer Datenbank, doppelt
abgespeichert werden. Nicht nur dass dann unnötig Speicher verschwendet wird ( tritt
negativ erst bei sehr großen Datenmengen auf, z.B Onlineshop mit vielen Benutzern),
vor allen Dingen aber muss bei einer Änderung eines Datensatzes an verschiedenen
Stellen dieselbe Information verändert werden. Das erzeugt mehr Latenz und das ganze
Programm läuft langsamer und ist komplizierter zu programmieren. Hier ist es am besten
mit Referenzen zu arbeiten, welche die einzelnen Datensätze mit einander verknüpfen.
Ein gutes Beispiel dafür sind die zu speichernden Abmeldungen im SES.
Zu einer Abmeldung muss natürlich auch der Schüler gespeichert werden, welcher
mit dieser Entschuldigung verbunden ist. Man muss jetzt zusätzlich den Vornamen,
den Nachnamen und die Klasse abspeichern. Allerdings braucht man diese
Informationen auch schon beim Erstellen der Entschuldigung. Also sind diese
Daten schon in der Datenbank vorhanden.
Die Konsequenz daraus wäre, dass Vorname, Nachname und Klasse doppelt in
der Datenbank vorhanden wären. Aus diesem Grund speichert man zu den Daten
der Entschuldigung nur eine Referenz zu dem Datensatz des Schülers. Man kann
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
sich das wie einen Pfeil vorstellen, der auf den entsprechenden Schüler zeigt.
Sollte sich der Nachname des Schülers ändern, muss man den Pfeil nicht
verändern, sondern nur den einen Datensatz des Schülers.

Besondere Lernleistung Nele Schorer, Jan Leufen 25


4. Zukunft und Wartung (von Nele Schorer)
Ein Informatikprojekt kann man beinahe endlos weiterführen, schließlich kann man
immer wieder Kleinigkeiten ändern oder neue Funktionen hinzu programmieren. Das
bedeutet, dass man vielleicht sein Projekt irgendwann nicht mehr betreuen kann oder
möchte. Dann übergibt man das Projekt an andere, die sich mit der Wartung und der
Weiterentwicklung der Anwendung beschäftigen. Damit diese keine Schwierigkeiten mit
der Anwendung kriegen und diese leichter weiter betreuen können, ist es wichtig ein
paar Vorkehrungen zu treffen.
Damit die Wartung auch in der Zukunft keine Probleme darstellt, ist es wichtig
festzuhalten, was wann gewartet werden muss. Denn dies ist von Anwendung zu
Anwendung unterschiedlich. Darüber hinaus schreibt man im besten Fall auch noch eine
Anleitung, wie man dabei optimal vorgeht, damit, falls etwas unklar ist, es doch jeder
hinbekommt. Es ist dabei auch hilfreich, noch eine Zeitlang nach der Übergabe der
Verantwortung des Projektes erreichbar zu sein, damit, falls Probleme auftreten, die mit
Hilfe der Entwickler gelöst werden können.
Bei SES ist es besonders wichtig, jährlich die Datenbank auszutauschen. Das
bedeutet, die Datenbank mit den Schülerdaten zu aktualisieren. Denn ansonsten
würde man die neuen Schüler nicht mit in die Datenbank aufnehmen und die
Schüler blieben für immer in der gleichen Klasse. Dadurch würde die gesamte
Anwendung nicht mehr funktionieren.
Damit das Projekt weiterentwickelt werden kann, ist es vom Vorteil, wenn derjenige, der
die Anwendung übernimmt, den programmierten Code seiner Vorgänger versteht.
Dadurch kann er besser und schneller in die Programmierung einsteigen. Das können
die Vorgänger sicher stellen, in dem sie in den programmierten Code Kommentare, für
was dieser Codeabschnitt überhaupt gedacht ist und was dieser tut, einfügen. Und zum
anderen ist es auch von Vorteil, wenn die benutzten Variablen eine passende
Bezeichnung haben. Denn dies hilft ebenfalls, den Code besser zu verstehen und
nachzuvollziehen. Dazu kann man auch separat noch eigene Ideen für die Anwendung
festhalten, die man selbst zeitlich nicht mehr umsetzen konnte.
Nachdem wir die Programmierung von SES größtenteils abgeschlossen hatten,
haben wir uns noch einmal zusammengesetzt und den gesamten Code
kommentiert und die Variablen umbenannt. Dies haben wir während der
Programmierung nicht gemacht. Damit man diese Arbeit am Ende nicht mehr hat,
sollte man dies schon während der Programmierung durchführen.
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
5. Testphase

Planung und Durchführung (von Nele Schorer)


Im ersten Kapitel Organisation wurde unter "Bedarf und Realisierbarkeit" beschrieben,
dass man, bevor das Konzept in die Tat umgesetzt werden soll, sehen muss, ob eine
Nachfrage nach der Anwendung vorhanden ist. Wenn diese vorhanden ist und man sich
einige Zeit mit der Programmierung dieser Anwendung beschäftigt hat, kann man sich
überlegen, eine Testphase durchzuführen. Das bedeutet, die Software ist auf einem
funktionierenden Stand und erfüllt ihren Zweck ohne größere Probleme.
Eine Testphase ist insoweit sinnvoll, dass die Anwender sehen können, inwieweit die
Anwendung wirklich eine Verbesserung darstellt, welche Fehler auftreten und was noch
verändert werden könnte. Doch bevor man sich für eine Testphase entscheidet, ist es
auch wichtig, sich zu überlegen, wann genau man diese Testphase macht und in
welchem Rahmen sie stattfinden soll.
Zuerst muss man sich überlegen, ob die Testphase ganz am Ende, der Programmierung,
durchgeführt werden soll, oder eher dann, wenn die Anwendung zwar noch nicht
komplett fertig programmiert wurde und noch einzelne Funktionen fehlen, aber schon
ihre Hauptaufgabe erfüllt. Danach muss man sich dafür entscheiden, ob die Testphase
nur im kleinem Rahmen durchgeführt werden soll, bei der nur ein Teil der Anwender die
Anwendung intensiv testet oder ob die Testphase für kurze Zeit komplett für jeden in den
alltäglichen Gebrauch mit eingebunden wird. Je kleiner der Rahmen der Testphase,
desto geringer ist die Wahrscheinlichkeit, dass alle Fehler und Probleme gefunden
werden. Je mehr Anwender von der Testphase betroffen sind, desto mehr Feedback und
Anregungen kann es geben. Dabei muss man aber auch bedenken, dass es nicht überall
möglich ist, eine so große Testphase durchzuführen.
Man muss, abhängig von diesen zwei Punkten, entscheiden, wie lang die Testphase
dauert. Hierbei muss man sicherstellen, dass die Anwender genügend Zeit bekommen,
um sich über die Testphase und auch die Anwendung selbst zu informieren. Eine
Testphase, in der keiner der Anwender weiß, dass es eine Testphase gibt, ist
kontraproduktiv.
Wir haben uns für eine Testphase entschieden, nachdem wir fast die gesamte
Anwendung fertig programmiert hatten, damit die Lehrer einen umfassende
Einblick in die Anwendung bekommen konnten. Wir haben entschieden, dass
unsere Testphase in einem Zeitraum von einer Wochen für jeden zu Verfügung
stehen sollte. Einfach, weil es sich eher anbot, als nur einzelne Lehrer zu suchen,
die die Testphase begleiten. Es entstand dadurch, dass wir die Testphase relativ
kurzfristig geplant hatten, das Problem, dass die Lehrer nicht alle Informationen
hatten, sodass viele in der ersten Woche der Testphase noch nicht ganz
verstanden hatten, dass eine Testphase läuft. Deshalb haben wir den Zeitraum auf
Besondere Lernleistung Nele Schorer, Jan Leufen 27
zwei Wochen verlängert.

Auswertung der Testphase (von Jan Leufen)


Es ist wichtig, den Lehrern die Möglichkeit zu geben, während der Testphase Feedback
zu geben. Das gibt nicht nur den Lehren das Gefühl, gefragt und eingebunden zu werden.
Es hilft auch den Programmieren ihr System zu verbessern und Bugs zu finden. Am
einfachsten realisiert man das durch Feedback Zettel2, die man den Lehrern in die
Fächer legt. Leider ist es oft so, dass man die Lehrer explizit auffordern muss, einen
Zettel auszufüllen, da ja während der Testphase der normale und oft zeitaufwändige
Alltag der Schule weiterläuft. Die Testphase kann also leicht im Alltag untergehen. Also
sollte man nicht davor zurückschrecken, Lehrer auch direkt anzusprechen und Feedback
einzufordern.
Wenn Lehrer Dinge falsch verstanden haben oder Fragen auftreten, sollte man diese
unbedingt beantworten, da sonst die Gefahr besteht, dass Unmut unter den potenziellen
späteren Nutzern entsteht.
Wir haben in unserer Testphase ebenfalls Feedback eingeholt. Es gab ein paar
Lehrer, die unsere Beschreibung falsch verstanden haben. Sie dachten, dass das
SES die Entschuldigungen ersetzt, doch eigentlich ersetzt es nur die Abmeldungen
des Sekretariats. Alles in allem kann man sagen, das Feedback war deutlich positiv.
Wir wurden sehr für die Übersichtlichkeit und die dauerhafte Sichtbarkeit gelobt.
Das SES wurde als deutliche Verbesserung zum bisherigen System gesehen.
Auch das Sekretariat hat uns sehr gelobt, gerade im Bezug auf die Schnelligkeit.
Wenn die Mitarbeiterinnen im Sekretariat einen Namen nicht ganz verstanden
hatten und eine Nachfrage nicht möglich war, zum Beispiel bei Anrufen auf dem
Anrufbeantworter, dann mussten sie umständlich in der LUST (Dem
Registrierungssystem für Schüler der Schulbehörde) nach diesem Schüler suchen.
Die „LUST“ Datenbank ist allerdings sehr langsam. Außerdem ist einigen
Lehrkräften die unzuverlässige Anrufpraxis der Schüler aufgefallen. Wir wurden
darauf hingewiesen, dass nicht alle Schüler, die tatsächlich fehlen, sich auch
abgemeldet hätten. Hier erfüllt unser System die Kontrollfunktion der Anwesenheit
deutlich besser als die Abmeldungs-Zettel. Ebenfalls wurde eine Summenfunktion
gewünscht, die am Ende des Schuljahres eine Zusammenfassung der
Fehlstunden eines Schülers ausgibt. Wir haben schätzungsweise die Hälfte aller
2
Lehrerinnen und Lehrer befragt und sind mit dem Ergebnis sehr zufrieden. Die
Feedbackbögen sind im Anhang zu finden.
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
6. Reflexion

Reflexion von Jan Leufen


Das Schul-Entschuldigungs-System ist das größte Projekt, an dem ich bis jetzt
gearbeitet habe. Es ist nicht nur das, welches am längsten gedauert hat, sondern ist
auch das, bei dem ich das Meiste gelernt habe.
Die Web-Entwicklung ist ein großes und vor allem ein sehr schnelllebiges
Programmiergebiet, dementsprechend lange hat es gedauert, bis ich mich in das Thema
hineingearbeitet hatte.
Eine große Hilfe war, dass ich schon mit Herrn Schmidt vor dem SES eine Karte für den
NATEX Wettbewerb programmiert hatte. Allerdings muss man sagen, dass sich im Laufe
des Projektes ganz andere Probleme und Herausforderungen aufgetan haben, als bei
der NATEX Website.
Die Gruppenarbeit mit Nele funktioniert sehr gut. Klar gab es Differenzen und mal auch
eine größere Auseinandersetzung. Aber wir haben uns insgesamt immer mehr
unterstützt, als dass wir uns im Wege standen. Ich finde, das macht so ein Projekt aus
und es bestimmt am Ende auch, ob man erfolgreich ist oder nicht. Wenn man gut
miteinander arbeitet und auch menschlich gut miteinander auskommt, wie in unserem
Fall, dann hat man Spaß am Projekt zu arbeiten und kommt gut voran.
Ein weiterer wichtiger Punkt ist die Arbeitsaufteilung. Mir hat es sehr gefallen, wie wir
das Projekt in Themengebiete aufgeteilt haben und jeweils an unterschiedlichen Sachen
gearbeitet haben. Ich hatte nicht das Gefühl, ich würde wesentlich mehr oder weniger
machen als Nele, und aus diesem Grund kann ich auch sagen, dass es unser Projekt
war, welches wir gemeinsam erfolgreich durchgeführt haben.
Die Absprachen zwischen uns hätten öfters besser funktionieren können, da wir uns
etwas zu selten genau abgesprochen haben. Allerdings habe ich nicht den Eindruck,
dass es unserem Projekt sehr geschadet hat.
Negativ ist für mich die Tatsache, dass uns die Schule nicht immer bei unserem
Vorhaben unterstützt hat. Wir haben des öfteren mit Herrn Solf geredet. Doch ich muss
sagen, dass ich die Gespräche mit ihm nicht immer konstruktiv fand. Ich habe das Gefühl,
er steht nicht ganz hinter dem Gedanken, Schüler an unserer Schule mit in die
Entwicklung zu integrieren. Das ist eine verpasste Gelegenheit. Denn gerade von so
einem Projekt wie dem SES lebt die Schule und schließt die Lücke zwischen Lehrern
und Schülern, da beide Seiten aktiv an der Entwicklung der Schule beteiligt sind.
Auf der anderen Seite stehen die vielen Lehrer, die uns in der Testphase sehr gutes
Feedback gegeben haben. Es hat mich sehr motiviert und jetzt fühlt es sich so an, als
hätte sich das fast zwei Jahre Programmieren gelohnt.
Der Ablauf des Projektes war am Anfang eher schleppend, da das Projekt noch zu groß
gefasst war und wir keine gute Kritik bekommen hatten. Doch als wir uns dann
entschieden hatten, aus dem SES eine BLL zu machen, hat mir das wieder neue
Besondere Lernleistung Nele Schorer, Jan Leufen 29
Motivation gegeben.
Ich habe leider auch dieses Mal, wie bei dem NATEX Wettbewerb, vieles etwas zu spät
angefangen. Dementsprechend stressig waren auch die letzten Monate. Allerdings bin
ich stolz auf unsere vielen Pläne, die wir über die Zeit entwickelt haben. Es hilft, wenn
man sich zwischendurch To-Do-Listen macht. Sie geben mir das Gefühl
voranzukommen.
Alles im Allem bin ich sehr froh, dass ich dieses Projekt durchgeführt habe und ich mich
dadurch so sehr weiterentwickeln konnte. Ich bin sehr zufrieden mit dem, was ich
während dieser fast zwei Jahre geschafft habe.

Reflexion von Nele Schorer


Unser SES Projekt hat sich über knapp zwei Jahre erstreckt. Und in diesen zwei Jahren
habe ich im Bereich Webdesign und Teamarbeit viel gelernt. Es ist ein enormer
Unterschied zwischen, bloß im Informatikunterricht ein paar Code Zeilen zu schreiben,
um ein Roboter bei Greenfoot vorwärts zu bewegen, und ein Projekt zu verwirklichen,
welches man im Team von Anfang an entwickelt und durchführt.

Am Anfang als wir das Konzept von SES entwickelt haben, konnte ich mir nicht vorstellen,
dass es so viel Zeit in Anspruch nimmt, dieses auch umzusetzen. Ich habe den Umfang
auf jeden Fall sehr unterschätzt und erst während der Programmierung immer mehr und
mehr realisiert, dass selbst ein im Grunde kleineres Projekt wie SES viel Zeit und Arbeit
in Anspruch nimmt.

Trotz des Umfanges hat dieses Projekt sehr viel Spaß gemacht, da man immer wieder
Fortschritte erzielt hat und das Gefühl hatte, etwas Sinnvolles zu tun, eine sinnvolle
Anwendung zu programmieren, welche später vielleicht auch genutzt werden würde.
Dieser Gedanke hat mich sehr motiviert. Es gab selbstverständlich auch Phasen, in
denen ich nicht motiviert war und ich das wöchentliche Programmieren mit Jan abgesagt
habe, um mich beispielsweise mit Freunden zu treffen. Grundsätzlich war es nicht
schlecht, zwischendurch mal eine Pause zu machen, doch wenn ich jetzt zurückblicke,
würde ich sagen, dass es besser gewesen wäre, hätten wir den Zeitraum einer Pause
begrenzt. Denn so verging auch schon mal ein Monat, ohne dass wir programmiert
haben. Und diese Zeit hätten wir vor allem am Ende gut gebrauchen können.

Unsere Testphase haben wir zu kurzfristig durchgeführt. Denn uns wurde so langsam
die Zeit knapp. An dieser Stelle wäre eine bessere Kommunikation von Seiten Herr Solf
wünschenswert gewesen. Herr Solf sollte ein E-Mail an die Lehrer schicken, in der ihnen
erklärt wird, was das SES ist. Da er das nicht getan hat, haben der Großteil der Lehrer
am Anfang nicht einmal gewusst, dass es eine Testphase gab. Dazu sei aber gesagt,
dass wir die E-Mail, die Herr Solf verschicken sollte, ihm auch erst relativ spät haben zu
kommen lassen. Da hätten wir uns besser organisieren und vereinbaren müssen.
Allerdings fand ich es besonders schön, als wir während und nach der Testphase viel
gutes und positives Feedback bekommen haben. Das hat die lange Arbeit an SES noch
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.
lohnender gemacht als ohnehin schon.

Ansonsten fand ich auch unsere Teamarbeit sehr gelungen. Ich kann mit Jan gut
konzentriert arbeiten, aber zwischendurch auch mal ein bisschen herumalbern. Vor
allem gegen Ende des Projektes hatten wir kleinere Meinungsverschiedenheiten, wie wir
etwas angehen oder durchführen wollen. Ich denke, solche Auseinandersetzungen
gehören dazu und sind nach zwei Jahren des Programmierens auch völlig vertretbar. Im
Übrigen haben wir diese Auseinandersetzungen auch immer nach kurzer Zeit wieder
geklärt.

Wir haben das Projekt gut durchgeführt und viel dabei gelernt. Ich habe vor allem den
Umgang mit CSS, Gestaltung von Tabellen sowie das Erstellen eines übersichtlichen
und trotzdem strukturierten Layout bei einer großen Menge an Daten oder Funktionen
gelernt. Dazu hat es zu zweit sehr viel Spaß gemacht und mir informativ aber auch
menschlich viel gebracht.

Ich versichere, dass die Präsentation von mir selbstständig erarbeitet wurde und
ich keine anderen als die angegebenen Hilfsmittel benutzt habe. Diejenigen Teile
der Präsentation, die anderen Werken im Wortlaut oder dem Sinn nach
entnommen wurden, sind als solche kenntlich gemacht.

Jan Leufen Nele Schorer

Besondere Lernleistung Nele Schorer, Jan Leufen 31


Anhang

Quellen
Titel Weblink Datum des
letzten
Besuches
„RSA Verfahren“ https://www.mathematik.de/ger/information/wasist 17.02.16
mathematik/rsa/rsa.html
Schulgesetz http://www.hamburg.de/contentblob/64474/data/b 17.02.16
Hamburg bs-gs-neues-schulgesetz.pdf
„Subnetze“ http://www.searchnetworking.de/definition/Subnet 17.02.16
z-Subnet
Geschichte der http://www.typografie.info/3/page/artikel.htm/_/wi 14.02.16
Zeichenkodierung ssen/zeichenkodierung-teil1
Zeichenkodierung https://de.wikipedia.org/wiki/Zeichenkodierung#C 14.02.16
im Computer omputer_und_Datenaustausch
Zeichen in MySQL http://www.gerd- 14.02.16
riesselmann.net/softwareentwicklung/php-und-
utf-8-eine-anleitung-teil-1-mysql/
CSS-Gestaltung http://www.stichpunkt.de/css/ 18.02.16
CSS und HTML http://praxistipps.chip.de/html-und-css-das-sind- 18.02.16
Unterschiede die-unterschiede_9814
CSS Vorteile http://www.inf.fu- 18.02.16
berlin.de/users/mbudde/css_kurs/vorteile.html
Kalender: https://jqueryui.com/datepicker/#date-range 17.02.16
„Datepicker“
Gestaltung der http://www.web- 18.02.16
Tabellen toolbox.net/webtoolbox/tabellen/tabellen-
zellenhoehe.htm
Spoiler – Ausklapp http://www.computerbase.de/forum/showthread.p 15.02.16
Button hp?t=940657
Spoiler – Ausklapp http://board.gulli.com/thread/802367-spoiler- 15.02.16
Button code/
Spoiler – Ausklapp http://forum.chip.de/html-css-javascript/spoiler- 15.02.16
Button html-1381745.html
Pfeil Grafik – http://de.fireemblem.wikia.com/wiki/Fire_Emblem 15.02.16
Ausklapp Button _Wiki
Gestaltung der https://wiki.selfhtml.org/wiki/HTML/Tabellen/Gest 20.02.16
Tabellen altung_einer_Tabelle
Gestaltung der http://www3.physnet.uni- 20.02.16
Tabellen hamburg.de/physnet/selfhtml81/html/tabellen/ges
taltung.htm
Gestaltung der http://www.a-coding- 20.02.16
Tabellen project.de/178/tabelleneigenschaften/

32
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.

CSS Gestaltung https://wiki.selfhtml.org/wiki/Startseite 20.02.16


Datepiker http://stackoverflow.com/questions/4812784/jque 06.02.16
Kalender und Ajax ry-datepicker-wont-work-on-a-ajax-added-html-
element
Datepiker http://stackoverflow.com/questions/20453879/jqu 06.02.16
Kalender und Ajax ery-datepicker-not-working-after-ajax-call
Datepiker http://stackoverflow.com/questions/16772876/dat 06.02.16
Kalender und Ajax epicker-not-working-on-ajax-loaded-content
Datepiker http://www.blogrammierer.de/jquery-ui- 06.02.16
Kalender und Ajax datepicker-startdatum-richtig-setzen-mindate/
Instant-Suche http://www.a-coding-project.de/eigene-instant- 12.02.16
suche-mit-google-ajax-search-api/
Instant-Suche https://msdn.microsoft.com/de- 12.02.16
de/library/ms187787.aspx
Instant-Suche http://www.webdesign- 12.02.16
podcast.de/2011/03/21/ajax-suche-fuer-
wordpress-nach-dem-vorbild-von-google-instant-
search-tutorial/
Git-Software http://www.heise.de/download/git.html 20.02.16

Git Homepage https://git-scm.com/ 20.02.16

RAID System http://www.pcwelt.de/ratgeber/Was-ist-ein-RAID- 12.02.16


System-NAS-Server-445517.html
Redundanz in http://www.datenbanken- 12.02.16
Datenbanken verstehen.de/datenbanken/datenmodellierung/no
rmalisierung/redundanz-datenbank/

33
Befragung der Lehrer
Sehr geehrte ….,

Wie mit Ihnen abgesprochen, geben wir Ihnen eine erste Projekt Vorstellung unser
Idee für unser Schule-Entschuldigungs-System (SES). Wir würden uns freuen, wenn
Sie es lesen und uns eine Rückmeldung mit Fragen, Kritik und Anregungen geben
würden.
Diese können Sie gerne an die folgende E-mail Adresse schicken: N.Schorer@gmx.de
oder in Nele Schorer‘s Fach legen.

Vielen Dank schonmal im Vorraus,

34
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.

Feedback von Frau Wünsche

35
36
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.

Feedback von Herr Kudling

37
38
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.

39
Frau Rosanowski

40
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.

41
Feedback der Lehrer

42
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.

43
44
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.

45
46
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.

47
48
Leitfaden zum erfolgreichen Programmieren eines schulischen Abmeldungssystems.

49
50