Scratch-Eingabemethoden: Die Tanzmatte

Schüler auf Tanz-Eingabematte

Habe ich tatsächlich noch nie über das Ding geschrieben? Ich habe es mir vor einem guten Jahr gekauft, für dreißig Euro oder so. Das stank erst einmal sehr nach Plastik, ging aber bald vorbei; dann habe ich noch die Verbindung Kabel-Tanzmatte mit etwas Sugru (=Klebeknetmasse) verstärkt, und jetzt habe ich eine Tanzmatte. Man steckt sie via USB ein, sie funktioniert dann wie ein Gamepad mit acht Tasten.

Ich habe damit ein rudimentäres Spiel entwickelt:

Digitales Whiteboard mit Scratch-Programm

Der Legostein bewegt sich – vorerst durch Tasten gesteuert – auf jeweils eine der acht möglichen Positionen; die Sandale wird durch die Tanzmatte gesteuert und kann ebenfalls auf die acht Positionen gebracht werden. Trifft Sandale auf Legostein, ertönt ein Geräusch und der Punktezähler geht hinauf.

Gespielt wird das dann so:

Schüler auf Tanz-Eingabematte

Aufgabe für die Schülerinnen und Schüler: Das Programm verbessern, insbesondere den Legostein nicht mehr durch Tasten, sondern durch ein Programm wandern lassen. Dann probierten die ersten, bei ihrem eigenen Spiel möglichst viele Punkte zu erreichen. Fazit: Es ist leider gar nicht so leicht, das mit den Füßen hinzukriegen, selbst wenn man den Rhythmus eigentlich kennt. Nächstes Mal lieber noch länger warten zwischen den Schritten.

(Fußnote: Die Programmierumgebung Scratch nimmt – zumindest in dieser arg alten Version, die wir in der Schule verwenden – keine Eingaben von einem Joystick oder Gamepad entgegen. Deshalb starte ich vorher ein anderes kleines Programm, das bei Gamepad-Eingaben Tastendrucke auslöst.)

ILTB 2018 – Basteln mit sozialen Netzwerken

Tasche mit MNU-Logo, Kressesamen als Verlagswerbung

So mag ich meine überregionalen Fortbildungen: Einmal ohne Umsteigen mit der U-Bahn von zu Hause aus, mit der Jahreskarte vom Münchner Verkehrsnetz. Diesmal war es der Informatiklehrertag Bayern 2018, der letztes Jahr in Passau war und nächstes Jahr Bayreuth stattfinden wird.

Dieses Jahr fiel der ILTB auf die Osterferien. Denn gleichzeitig fand die – größere – Tagung des MNU statt, eines Verbandes aller mathematisch-naturwissenschaftlichen Fächer, und in die wurde der ILTB integriert. Manche Lehrer und Lehrerinnen mag der Termin abgeschreckt haben, und ich hätte auch meine Urlaubspläne nicht geändert – aber diese Ostern bleibe ich in München, und so passte mir das gut, und viele andere Informatiklehrer und -lehrerinnen waren auch da. Aber klar, wer Kinder hat und mit denen in den Ferien Urlaub macht, der kann zu den Ferienterminen nicht kommen.

Tasche mit MNU-Logo, Kressesamen als Verlagswerbung

Vortrag

Der Tag begann mit einem Vortrag von Prof. Daniel Cremers vom Lehrstuhl für Computer Vision & Artificial Intelligence an der TUM. Das Thema: Wie 3D-Modelle der realen Umwelt für den Computer entstehen. Da gibt es wohl zwei Möglichkeiten: Man scannt die Umwelt mit einem Laser ein. Das ist wohl genau, aber teuer, und eignet sich nur für eine unbewegte Umwelt. Die andere Möglichkeit, die von Cremers verfolgt wird, besteht darin, aus Foto- und Videoaufnahmen ein 3D-Modell zu erstellen. Das ist erst einmal gar nicht so einfach, weil diese Bilder ja nur ein 2D-Abbild darstellen. Aber wie schon bei der Kinect zu sehen, kann man aus mehreren zweidimensionalen Bildern schon rekonstruieren, wie weit ein Bildpunklt von der Kamera entfernt war.

Und so kann man jetzt mit ein oder zwei Kameras zu Fuß oder mit dem Auto oder mit einem Quadcopter eine Strecke entlanggehen, -fahren oder fliegen, und hat danach ein brauchbares 3D-Modell. Wenn man eine Szene filmt, etwa für einen Film, hat man danach ein animiertes 3D-Modell der Szene, farbig, und kann dann eine virtuelle, auch bewegte, Kamera an Stellen platzieren, an denen nie eine echte Kamera war.

Workshop: Socialbotnet

Mit den beiden Workshops, die ich besuchte, hatte ich Glück; sie waren gut und behandelten Themen, die mich interessierten. Im ersten stellte Benjamin Knorr seine Zulassungsarbeit vor, an der er gerade arbeitet: Socialbotnet. Das ist eine Art Twitter im Kleinformat, das man als Lehrer als Server laufen lässt. Man kann sich über den Browser registrieren, an- und abmelden, sein Profil bearbeiten und vor allem Mininachrichten veröffentlichen und die Nachrichten anderer Nutzer liken.

Screenshot Webseite socialbotnet

Das ist aber eigentlich nur die Bedingung für das eigentliche Projekt: Die Schüler und Schülerinnen schreiben Programme (zum Beispiel in Java, unter BlueJ), die sich die aktuellen Mininachrichten vom Server geben lassen, sie eventuell auswerten und auf sie mit eigenen Kommentaren oder Likes reagieren. So etwas nennt man gerne Bot. Man kann zum Beispiel einen Bot schreiben, der sich regelmäßig alle neuen Nachrichten geben lässt und auf diejenigen, die mit „Ich bin ja kein“ beginnen, eine Antwort schreibt: „Bist du doch!“

So etwas Ähnliches habe ich auch mal für Twitter programmiert, denn die echten sozialen Netzwerke bieten genau die gleiche Möglichkeit, programmgesteuert Nachrichten zu lesen und zu verfassen und mit anderen Nachrichten zu interagieren. Das kann gut gemacht sein; ich folge bei Twitter etwa dem MythologyBot, der regelmäßig die Kategorisierung verschiedener mythologischer Motive aus dem Thompson-Index twittert. Noch surrealer ist der MagicRealismBot, der bedachtsam generierte, oft fesselnd abstruse Kurznachrichten – oder Geschichtenvorschläge? – präsentiert.

Aber natürlich kann man auch Bots erstellen, die so tun, als wären sie echte Menschen, und die gezielt auf ausgewählte Nachrichten reagieren – ob sie Falschnachrichten verbreiten oder nur Stimmung machen, sie können zur Manipulation eingesetzt werden, indem sie eine große Zahl an Menschen vorgaukeln, wo keine sind, und gezielt auf bestimmte Nutzergruppen zugeschnitten sind. Wie groß die Gefahr durch diese Bots wirklich sind und ob die Falschnachrichten eher durch tatsächliche Menschen verbreitet werden: anderes Thema.

Technischer Einschub

Ein Programm kommuniziert mit so einem Server im Internet folgendermaßen: Der Server muss erst einmal so eine Möglichkeit zur Verfügung stellen, das heißt dann API (Application Programming Interface). Wenn man zum Beispiel den Server über folgende http(s)-Anfrage aufruft, eine sogenannte GET-Anfrage, manuell oder über ein Programm:

http://localhost:30003/api/posts?limit=5 bzw. auf Benjamins Beispielserver
https://social-bot-net.herokuapp.com/api/posts?limit=5

dann erhält man eine Antwort, nämlich die letzten 5 Beiträge, die im Browser etwas unübersichtlich dargestellt werden, für den Computer aber gut lesbar sind. Häufig sind GET-Anfragen, um Informationen zu erfragen, und POST-Anfragen, um Informationen zu senden. Die genaue Form dieser API variiert von Server zu Server, und auch die Art der zurückgegebenen Daten, beliebte Formate dazu heißen XML oder JSON. Diese maschinenfreundlich formatierte Server-Antwort kann man dann mit dem Programm auswerten.

Habe ich das Programm zum Laufen gekriegt? Ja. Aber wenn man, wie ich, nicht genau weiß, was man tut, ist das gar nicht so einfach. Man muss die Software Git und die Software Maven auf dem Rechner installiert haben. Dann kann man das von der Kommandozeile aus mit zwei Zeilen Code machen. Oder man hat die Entwicklungsumgebung Eclipse installiert, die Git und Maven bereits enthält. Mit Git kopiert man das Projekt aus dem Internet auf den eigenen Rechner (das geht, weil Benjamin wie viele andere auch ihren Code auf diese Weise zu Verfügung stellt). Aber lauffähig ist das Programm dann noch nicht.

Denn ein größeres oder auch kleineres Softwareprojekt entsteht heutzutage nicht mehr dadurch, dass sich ein Team oder auch nur einer hinsetzt und von vorne bis hinten alles programmiert. Vielmehr greift man auf Teilprojekte zurückt, die bereits von anderen erstellt wurden, und baut auf diesen auf. Es muss ja nicht jeder das Rad neu erfinden. Also besteht ein Projekt aus 90% Code von anderen, fremden, Leuten, zu denen 10% eigener Code kommen. Wenn ich den Code meines Projekts jetzt online stelle (und nicht nur das fertige, ausführbare Progamm), damit andere damit arbeiten können, gibt es zwei Möglichkeiten:

  • Ich stelle meine 10% online, und die 90% Fremdcode ebenso. Das macht Arbeit.
  • Ich stelle meine 10% Code online, und vermerke, welche 90% fremde Packackes nötig sind, damit mein Projekt funktioniert. Wer mein Projekt nutzen will, besorgt sich einfach diese 90% von anderswo her. Vielleicht hat er oder sie ja eh schon Teile davon.
  • Es wäre ziemlich umständlich, sich von Hand diese fehlenden Programmteile herunterzuladen. Also gibt es wieder Software, die das für einen tut, so dass ich zu den 10% heruntergeladenem Code sagen kann: Besorge mir bitte die 90% fehlenden Code. Ein solches System, das natürlich noch viel mehr kann, heißt Maven, und das wurde bei diesem Projekt benutzt.

Fazit für den Einsatz in der Schule:

  • Tolle Idee, gutes Design. Inhaltlich sehr interessant für die Schule, zur Zeit 10. oder 12. Klasse.
  • Wenn das Produkt ganz und gar fertig ist, hätte ich gerne das vollständige Programm als Download, nicht unbedingt den Code selber, sondern vor allem die ausführbaren Dateien. Das gibt es noch nicht.
  • Ich habe das Projekt auch nur unter Eclipse zum Laufen gekriegt und nicht von der Kommandozeile aus, das macht den Einsatz in der Schule einen Tick schwerer, aber geht schon. Irgendwann kriege ich das auch mit der Kommandozeile hin.
  • Die Änderungen an der Datenbank noch nicht gespeichert, sondern bei jedem Neustart wird der – allerdings veränderbare – Ausgangszustand wiederhergestellt. Wäre anders schöner, ist aber kein großes Problem.
  • Lieber wäre mir Software in PHP, die ich auch auf meinem gemieteten Server und damit im Internet laufen lassen könnte (auf dem ich keine Java-Programme installieren kann), aber für den Computerraum geht es auch so – vorausgesetzt die Windows-Firewall blockiert das nicht, wie an meiner Schule.

Workshop: InstaHub

Im zweiten Workshop stellte Julian Dorn sein Projekt InstaHub.org vor. (Für das ähnliche Vorgängerprojekt hat Julian 2017 den Preis der GI – Gesellschaft für Informatik – erhalten.) InstaHub ist ebenfalls ein soziales Netzwerk, angelehnt an Instagram. Man arbeitet aber nur im Browser damit, es gibt keine API, um von außen darauf zuzugreifen. Auf der Webseite kann man sich registrieren, an- und abmelden, ein Profil ausfüllen, und Bilder veröffentlichen und verschlagworten – und die Bilder der anderen Benutzer anschauen und mit einem Like-Sternchen versehen. Es geht aber gar nicht darum, dass man das macht; das Netzwerk ist von Anfang an bereits mit 200 Nutzern gefüllt und mit hunderten von Bildern.

Screenshot InstaHub

Vielmehr ist jede Schülerin der (alleinige) Administrator des eigenen InstaHub-Systems. Jeder Schüler kriegt also sein eigenes Netzwerk, das unabhängig von den anderen funktioniert. Als ein solcher Administrator hat man Zugang zur Rückseite des Netzwerks, sozusagen, und zwar insbesondere auf die Datenbank, in der (fast) alle Daten von InstaHub verwaltet werden. Die Datenbank ist vom im Web verbreiteten Typ MySQL, und man kann in der Datenbanksprache SQL – Stoff der 9. Jahrgangsstufe Informatik in Bayern – Anfragen stellen, also etwa:

select name from users where city = 'München' and gender = 'male'

Nach und nach können die Schüler und Schülerinnen weitere vorgegebene Tabellen anlegen (mit Bildern, Kommentaren) und automatisch befüllen und damit komplexere Anfragen über mehrere Tabellen durchzuführen. Außerdem können sie als Administratoren die Inhalte der Datenbank bearbeiten – Nutzer löschen, ihr Passwort ändern oder einsehen (allerdings in gehashter Form, also nicht im Klartext gespeichert), Beiträge der Nutzer ändern, was man als Admin halt so kann, aber nicht sollte.

Habe ich das Programm zum Laufen gekriegt? Ja und nein, wie oben. Mit Git das Projekt aus dem Repository geklont, dann die 90% fehlenden Programmteile hinzugeladen – diesmal nicht mit Maven, sondern mit dem PHP-Äquivalent Composer. Nach Beseitigung meiner Tippfehler problemlos – im Nachhinein ist das alles leicht, wenn man erst einmal weiß, was das ist, was man gerade tut. Allerdings ist das Programm für den Einsatz auf einem echten Webserver gedacht, mit vollem Zugriff auf das benutzte MySQL-Datenbanksystem. Das schließt leider aus, dass das Programm auf meinem billigen gehosteten Server läuft, denn auf die MySQL-Datenbank dort habe ich keinen vollen Zugriff, sondern habe nur 1 Benutzer auf 1 Datenbank, und kann nicht automatisiert weitere Benutzer und weitere Datenbanken erstellen.

Also lasse ich das Programm nicht auf einem echten Server im Web laufen, sondern lokal auf dem Windows-Rechner zu Hause. Dazu muss man einen MySQL-Server installieren, und einen Webserver, und die Sprache PHP, in der viele Programme fürs Web geschrieben sind. So etwas gibt es glücklicherweise vorkonfiguriert unter dem Stichwort XAMPP. Nur gibt es dann immer noch zwei Probleme: Erstens habe ich mit XAMPP vorerst keine Domain oder Subdomain; die Webseite ist vielmehr unter der Adresse http://localhost oder http://127.0.0.1 erreichbar. Aber damit sind keine Subdomains möglich, und die verlangt InstaHub – jeder Schüler kriegt sein eigenes kleines Netzwerk unter einer eigenen Subdomain, also etwa fuhse15.instahub.grg. Aber auch das ist unter Windows möglich, dazu muss man in einer kleinen Textdatei im Windows-Ordner ergänzen, dass Browseranfragen an instahub.grg („GRG“ ist der Name meiner Schule) umgeleitet werden sollen nach 127.0.0.1. Dann kann ich auch tatsächlich einfach http://instahub.grg in den Browser eingeben, obwohl es diese Adresse im Web gar nicht gibt, und lande bei 127.0.0.1, also letztlich dem Webserver unter XAMPP. Leider bringt mir das für die Schule nichts: Zum einen kann ich da nicht in die Windows-Systemdateien eingreifen, zum anderen müsste ich jede mögliche Subdomain von Hand in diese Textdatei eintragen.

Leichter zu lösen ist das zweite Problem, dass der öffentlich zugängliche InstaHub-Ordner logisch auf der obersten Webserver-Ebene und nicht in einem Unnterverzeichnis liegen muss, wie es tatsächlich der Fall ist. Das lässt sich aber durch eine Konfigurierung des XAMPP-System anpassen. Und dieses XAMPP-System kann ich auch in der Schule laufen lassen.

Also werde ich in den sauren Apfel beißen und mir einen ordentlichen Webserver mieten müssen. Denn ausprobieren will ich InstaHub (das dann natürlich InstaMeineSchule heißen würde) schon.

Fazit für den Einsatz in der Schule:

  • Zur Didaktik wieder nichts, weil mir da viel einfällt.
  • Sehr schön: das Design. Mir selber würde es reichen, wenn es auf einer strukturellen Ebene Instagram und dergleichen entspricht, aber angenommen werden solche Projekte von vielen Schülern und Schülerinnen nur dann, wenn sie auch gut aussehen.
  • Lieber wäre mir, wenn eine einzelne Datenbank ausreichen würde. Aber das wäre sehr unpraktisch, umständlich, fehleranfällig und von der Leistung her ungünstig, okay, okay.
  • Installation: Auf einem echten Webserver sicher leichter zu installieren, aber unter Windows kann man – leider nicht für den Schulbetrieb – das ganze schon einmal ausprobieren. Julians Installationsanleitung ist verständlich und man kommt damit auch als verhältnismäßiger Laie zurecht.
  • Man kann auch Julians Server dazu benutzen, muss sich dazu nur bei ihm als Lehrer melden, dann gibt er einem Lehrerrechte auf seiner instahub-Installation, und als Lehrerin wiederum kann man die sich zugeordneten Schüler und Schülerinnen und deren Datenbanken verwalten.
  • Trotzdem erfordert das Eingewöhnungszeit, aber dann kann man schöne Sachen damit machen.

Wieder was gelernt, bei der Fortbildung, und vor allem danach, beim Ausprobieren. Fachliche Fehler sind nicht ausgeschlossen, ich habe viel zusammengefasst und möglicherweise falsch.

Typographie in Deutsch und Informatik (nur so als Einstieg)

Schriftarten der Klasse 6a

Informatik in meiner 6. Klasse findet nicht immer statt; nachmittags sind oft Konferenzen. Immerhin habe ich die Klasse parallel in Deutsch, so dass ich wenigstens die Namen der Schüler und Schülerinnen kenne. Im Deutschunterricht lasse ich sie am Rechner schreiben, im Informatikunterricht nehme ich als Beispiele Texte aus dem Deutschunterricht.

Gestern ging es um die Klasse ABSATZ bei Textverarbeitungssystemn und deren Attribute; davor wiederholten wir die lange zurückliegende Klasse ZEICHEN und deren Attribute – darunter zum Beispiel die gewählte Schriftart. Und dass solche Schriften entworfen werden und 10.000 Euro kosten (habe ich mal so geraten, hängt sicher von vielen Dingen ab) und dass es allein schon mal deswegen rücksichts- und geschmacklos ist, so einen sorgfältig gestalteten Zeichensatz durch automatische Unterstreichung zu verhunzen. Denn ja, liebe Kinder, Unterstreichung als Mittel der Hervorhebung ist legitim bei alten Schreibmaschinen; wenn man nicht auf einer solchen arbeitet, nutzt man stattdessen andere Möglichkeiten – der Text kann fett sein oder kursiv oder in einer anderen Schriftart und -größe (aber vielleicht auch nicht alles davon auf einmal). Auf Fortbildung neulich so ein Medienmensch, der iPads für seine Schüler forderte, aber munter die Unterlängen seiner Zeichen beim Unterstreichen durchsäbelte – wer keinen Sinn für Form hat, dem traue ich auch beim Inhalt nicht.

Und dann ging es um Times New Roman und Comic Sans, und was da jeweils das Problem ist oder nicht ist – genug, am nächsten Tag präsentierte ich im Deutschunterricht den Schülern und Schülerinnen ein Gedicht, das wir ein bisschen besprachen, bevor ich dann ihre Meinung zum verwendeten Zeichensatz einholte. Den hatte ich nämlich selbst entworfen, basierend auf meiner Handschrift.

Darauf teilte ich in der Klasse eine Tabelle aus, so dass jeder sich selber eine Schrift zusammenbasteln konnte. Und in einer halben Stunde im Lehrerzimmer hatte ich aus dem ersten Dutzend Entwürfen jeweils TrueType-Zeichensätze gemacht, die jetzt zum Beispiel unter Windows wie andere reguläre Zeichensätze verwendet werden können:

Schriftarten der Klasse 6a

Das sind die Schriftarten aus der Klasse, dazu meine und die eines Kollegen, der an der Theke im Lehrerzimmer auch rasch mitspielte. Dass manche Schriftarten sich ähnlich sind, liegt am Entstehungsprozess, dazu später mehr. Der Sinn… Wertschätzung von Schriftarten, Reflexion der eigenen Handschrift, Spaß am Gestalten. Dazu informatisch: Vektorgrafiken, Umgang mit Informatiksystemen. Denn der fertige Zeichensatz lässt sich noch bearbeiten; an einzelnen oder allen Zeichen kann man feilen.

Das Grundwissen dazu:

  • So ein Zeichensatz besteht aus einer Sammlung von Vektorgrafiken. Jedes Zeichen ist eine kleine Vektorgrafik, die mit einem Programm erstellt werden kann. FontForge ist so ein Propgramm, mit dem man unter anderem TrueType-Dateien einlesen und verändern kann. Open Source, gibt’s auch in portable.
  • Man kann handschriftliche Zeichnungen digitalisieren und in eine Vektorgrafik umformen lassen. Inkscape ist ein Programm, mit dem man das machen kann, auch Open Source.
  • Für vieles, was man manuell selber machen kann, gibt es Webseiten, die das für einen erledigen.

Unter http://www.myscriptfont.com/ ist so eine Seite. [Nachtrag: Die Seite gibt es nicht mehr, sondern stattdessen einen Nachfolger, für den man sich registrieren muss. Schade! Ich müsste mal schauen, ob es das noch anderswo gibt.] Man druckt eine Vorlage aus (einfacher gleich als png herunterladen und nicht als pdf, weil die pdf-Datei im Letter-Format ist), füllt sie mit schwarzem Filzstift aus. Füller geht nicht so gut, Kugelschreiber und Bleistift gar nicht, denke ich. Doppelt vorsichtig sein bei den Unterlängen, gerade beim g lieber noch zusätzlich Platz lassen. Dann scannt man die Vorlage ein, mit einem echten Scanner, nicht mit dem Handy. Bei Füller muss man unbedingt noch mit der Gammakorrektur kräftig verdunkeln. Die Bilddateien lädt man bei der Seite hoch, und schon hat man seine TTF-Datei.

Mit den richtigen Werkzeugen geht das wirklich im Handumdrehen: Die Schüler-Blätter per automatischem Einzelblatteinzug im Kopiergerät der Schule einscannen und auf USB-Stick speichern. (Das können Kopiergeräte heute.) Allerdings speichert das Kopiergerät das dann alles in einer einzigen pdf-Datei, also braucht man ein Programm, mit dem man aus pdf-Dateien Grafiken (png oder jpg) erstellen kann. Weil ich das oft brauche, habe ich das ohnehin auf meinem kleinen Privatrechner, den ich in der Schule immer dabei habe. Gammakorrektur braucht am längsten, und wenn es mehr gewesen wären, hätte ich den Batch-Modus bei IrfanView genutzt; ist eh auch am Rechner. Morgen kriegen die Schüler und Schülerinnen ihre Fonts, die anderen wollten noch zu Hause an den Vorlagen arbeiten. Danach schauen wir uns die Fonts in FontForge an. Es macht wirklich Spaß, mit Informatiksystemen umgehen zu können.

Mit einem Dienstrechner wäre das alles übrigens nicht gegangen. Deswegen ist es unsinnig, wenn in NRW gerade der Datenschutz dahingehend interpretiert wird, dass Lehrer keine Schülerdaten auf Privat-, sondern nur auf Dienstrechnern verarbeiten dürfen.

– Für meine Zulassungsarbeit in Mittelhochdeutsch im letzten Jahrtausend habe ich übrigens bereits Zeichensätze angepasst. Da ging es um die Analyse einer frühneuhochdeutschen Handschrift hinsichtlich der Schreibung und des mutmaßlichen Lautstands bei Lautveränderungen, und da brauchte ich viele spezielle diakritische Zeichen. Klar hätte ich die alle unter „å“ zusammenfassen können, aber so war es viel lustiger.

Nachtrag: So sieht ein Zeichen aus, wenn man es nachträglich bearbeiten will.

Zeichen "e" in Software FontForge

In der sächsischen Schweiz

Landschaft:: Ausblick nach Böhmen

Eigentlich wollte ich über das Pflichtfach Informatik schreiben, aber das habe ich schon vor Jahren getan und es hat sich nicht viel geändert: Vier Bundesländer haben es in der einen oder anderen Form (neu: auch Österreich und Schweiz), die anderen eiern noch herum. Was gegen das Pflichtfach Informatik spricht: Es kostet Geld. Was gegen ein Pflichtfach Informatik vorgebracht wird: Das braucht doch keiner; Medienkunde ist aber auch wichtig; die Inhalte kann man auch ohne ein Fach vermitteln; Fächer an sich sind überholt. Das erste ist falsch, das dritte auch, das zweite nicht (aber irrelevant), das vierte ist interessant – und wenn sich abzeichnet, dass ein Bundesland auf Fächer sinnvoll verzichten will, dann fein; ich sehe das aber auf absehbare noch nicht kommen. Der Mensch ist schlecht in Prognosen, aber so schnellt rollt die Revolution hier nicht heran.

Ich kam auf den Gedanken, weil ich letzte Woche bei einem Informatikdidaktiker-Treffen in der sächsischen Schweiz war. Das war sehr interessant. Es war kalt und der Handy-Empfang war nicht gut, aber dafür waren vierzig Informatiker und Informatikerinnen auf einem Haufen und arbeiteten in Gruppen und tauschten sich aus. Produktiv, und lauter gescheite Leute.

Alle Züge hin und zurück waren übrigens pünktlich, selbst die ICEs. (WLAN ging auch.) Zwischen Leipzig und Dresden las ich bei Twitter, dass ich in Leipzig auf dem Bahnhof als Twitterer erkannt worden war – wo natürlich nicht damit zu rechnen war, dass ich da sein würde. Da war ich verblüfft, selber bin ich sehr schlecht mit Gesichtern. Mein Avatarbild sieht wohl wirklich so aus wie ich, und dann taucht mein Foto ab und zu auch in anderen Blogs auf. Hat mich jedenfalls sehr gefreut.

Blick nach Böhmen:

Landschaft: Ausblick nach Böhmen

(„Der Wanderer über dem Nebelmeer“ von Caspar David Friedrich entstand hier, aus verschiedenen Bergen zusammengebastelt. Der in der Mitte ganz hinten ist ein Kandidat für einen davon, ich weiß aber nicht mehr, ob es der Rosenberg doer der Kaltenberg ist.)

Vom Objektdiagramm zum Klassendiagramm

Diagramm Superhelden-Beziehungen

Diagramm Superhelden-Beziehungen

(Quelle: Webhostingbuzz)

Erstelle aus diesem Objektdiagramm das entsprechende Klassendiagramm.
Einsatz: heute in 9. Klasse, Thema Datenbanken, Datenbankentwurf, Beziehungen zwischen Objekten beziehungsweise Klassen.

Neuen Fachausdruck gelernt: „lore“ (englisch). Bei mir heißt das ja noch „canon“. Ich konnte das Diagramm sachgerecht kommentieren.

Erzeuger-Verbraucher-Videos

Kurzer Rückblick vorweg: Anstrengender Dezember; schönes Wichteln mit der 10. Klasse (Geschenke gab’s erst dann, wenn man gesagt hat, was man Gutes oder Schönes getan hat, auf das man stolz sein kann, wobei Noten nicht zählen – gar nicht so einfach für manche Leute, mich eingeschlossen); besonders gefreut hat mich auch ein gebastelter Stern aus meiner 6. Klasse. Danach Familienfeiern allüberall, viel gegessen. Geschenke machen kann ich nicht, oder mache ich mir nicht genug Mühe damit.


Wieder mal ein paar Videos erstellt, diesmal für die 12. Klasse Informatik, Synchronisierung von Threads in Java. Ein Threads ist ein Programm, das gleichzeitig neben anderen solchen Programmen laufen kann, was sinnvoll ist, weil damit vieles schneller geht. Manchmal müssen die Threads sich aber noch absprechen.

Ich bin noch auf der Suche nach dem geeigneten Werkzeug zum Erstellen solcher Videos. Open Source soll es sein. Zuerst habe ich wieder Pröäsentationssoftware genommen und abgefilmt, aber das gefällt mir nicht. Am liebsten wäre mir ein Programm, mit dem ich wie auf einem Schreibtisch Bildchen hin- und herschieben kann – das habe ich nur bei Smartboard-Software gefunden, und hier habe ich die offene Variante OpenBoard benutzt. Was mir noch fehlt, ist die Möglichkeit, mit einfachen Skripten zu bestimmen, was etwa bei einem Doppelklick auf ein Objekt geschehen soll – ersetzen der Grafik durch eine andere, vergrößérn, verkleinern, solche Sachen. Aber an sich mag ich das, so fast schon analog Objekte zu bewegen und das dann abzufilmen.

Der Inhalt ist nicht verfügbar.
Bitte erlaube Cookies, indem du auf Übernehmen im Banner klickst.

Alle Videos:

Synchronisation mit Monitoren 1 (OpenBoard)
Synchronisation mit Monitoren 2 (OpenBoard)

Synchronisation mit Monitoren 1 (Impress)
Synchronisation mit Monitoren 2 (Impress)

Informatikunterricht in Klasse 6

Heute sehr gerne Informatik in der 6. Klasse gegeben. Das ist nicht immer so.

Wenn man gerade damit angeben will, dann hat Bayern in der 6. und 7. Jahrgangsstufe ein Pflichtfach Informatik (und darüber hinaus im naturwissenschaftlich-technologischen Zweig in 9 und 10, ab der aktuellen Reform auch in den anderen Zweigen). Tatsächlich gibt es in 6 und 7 aber das Fach Natur und Technik, mit jeweils einer Stunde Informatik darin, losgelöst von Biologie oder Physik, die jeweils den größeren Anteil des Fachs ausmachen. De facto ist das also ein einstündiges Fach Informatik, das lediglich aus kosmetischen Gründen nicht so heißt.

Wenn man die Unterstufenklasse einmal pro Woche für eine Dreiviertelstunde sieht, bringt das kaum etwas. Einstündige Fächer sind Käse. Weil an meiner Schule so viel wie möglich in Doppelstunden unterrichtet wird, kommt es oft vor, dass auch Sechstklassinformatik als Doppelstunde stattfindet, nachmittags, aber nur alle 14 Tage. Das ist noch größerer Käse – Nachmittagsunterricht fällt regelmäßig aus – Sitzungen, Abiturprüfungen, Abiturnachprüfungen.

Auch dieses Jahr gibt es viel doppelstündige vierzehntägige Sechstklassinformatik, aber ich habe meine Klasse gleichzeitig auch im Deutschunterricht, und das macht einen enormen Unterschied. Ich kenne die Schülerinnen und Schüler; sie kennen mich; da können wir alle völlig anders arbeiten. Dann, und nur dann, geht auch in einer Wochenstunde viel.

Außerdem halte ich mich dieses Jahr nur lose an den Lehrplan – die Erfahrung zeigt, dass bei dem 14-Tage-Modus der Lehrplan nicht erfüllt werden kann, was mir quasi die Lizenz zum kreativen Umgang damit gibt. Ziel der 6. Klasse ist Objektorientierung (Attribute, Attribtuwerte, Methoden, Klasse) anhand von Vektorgraphik-, Textverarbeitungs- und Präsentationssoftware. Den theoretischen Einstieg und die Vektorgraphik (LibreOffice Draw) habe ich mir diesmal völlig geschenkt, und gleich mit einem Programm angefangen, bei dem man richtig Code schreiben muss (EOS), und da schreiben die Sechstklässlerinnen jetzt:

rumpf:KREIS
rumpf.mittelpunktSetzen(0,-60)
rumpf.radiusSetzen(60)

und sie zeichnen damit Autos und Schneemänner und Häuser. Das ist ein sehr abrupter Einstieg, aber ich habe nun mal nicht mehr Zeit, und ich kenne die Klasse und weiß, was geht. Wenn die Puntkschreibweise für Methodenaufrufe so wichtig ist, dann doch gleich. Inzwischen spielen die ersten Jungs codecombat.com, wo man mit hero.modeDown() und Python-Syntax Fanatsyfiguren in einem Dungeon bewegt. (Nicht zu verwechseln mit codefights.com, das spiele ich gerade, sofern ich Zeit dazu habe. Macht süchtig. Kleine fiese Programmieraufgaben in der Sprache deiner Wahl, und man kriegt Punkte fürs Weitermachen.)
Das macht alles so viel mehr Spaß als Deutschunterricht, obwohl das da schon auch gut läuft, und ich bin so froh, dass ich da richtig Informatik unterrrichte und nicht einfach nur Digitales. Es ist toll zu sehen, wie die Schüler und Schülerinnen immer mehr Sicherheit im Umgang mit Informatiksystemen gewinnen.

Am liebsten würde ich jetzt mit 3D-Grafik in Python weitermachen, oder mit ersten Kontrollstrukturen. Aber dann halte ich mich doch an den Lehrplan und springe von der Punktschreibweise und den Methodenaufrufen direkt zur Textverarbeitung. Es gibt da zwei Tools, ponto (für Python) und Tolg (Java), beide schon betagt und zumindest in Computerräumen kaum zum Laufen zu kriegen, mit denen man über Punktschreibweise oder Programmcode die Absätze und Zeichen eines Textes bei Open/Libre Office direkt manipulieren kann, also etwa:

from ponto3 import Dokument
dok1 = Dokument()
absatz1 = dok1.erzeugeAbsatz("Hallo Welt")
absatz1.setzeEinzugLinks(2000)
absatz2 = dok1.erzeugeAbsatz("Das ist der zweite Absatz")

Das zeige ich aber nur kurz als Überleitung.

— Ich bin nach den Informatikstunden ganz erschöpft. weil ich da so viel hineinpacke, aber die saugen das auch alle auf. (Ganz anders vor zwei Jahren, einstündig, gleiche Bedingungen – nur dass ich da eben nicht Deutsch- oder auch nur irgend ein anderer Lehrer war.)

Eine kleine Programmieraufgabe…

Benutzeroberfläche Inselspiel

…die sich als aufwändiger und lehrreicher herausgestellt hat, als ich dachte.

Es begann damit, dass ein Kollege mir von dem Computerspiel erzählte, das ihn gerade beschäftigte: Als Schiffbrüchiger auf einer Insel sammelt man unter anderem Gegenstände ein und erntet Pflanzen, jagt Tiere und arbeitet mit Werkzeugen. Zum Beispiel kann man mit einem Messer und einer Kokosnuss man Trinkwasser erzeugen (wobei die Kokosnuss verbraucht wird), und mit einem Schwein und einem Messer erzeugt man Haut und Fleisch, und aus der Haut kann man Leder machen, und aus dem Leder Riemen, und so weiter.

Ha, dachte ich mir, das ist nett, das sieht objektorientiert aus, das könnte ich doch auch mal mit Schülern machen. Erster Gedanke:

Klassendiagramm

Das Messer kriegt folgende Methoden:

  1. eine Methode anwendenAuf(Kokosnuss)
  2. eine Methode anwendenAuf(Schwein)
  3. eine Methode anwendenAuf(Spielobjekt)
    (eventuell verzichtbar, da ererbt, aber siehe weiter unten)

Diese drei Methoden heißen zwar alle gleich, sind aber trotzdem verschiedene Methoden und machen verschiedene Sachen – dieses Konzept heißt overloading. – Ein anderes Konzept ist das des overriding, wenn eine Unterklasse die gleichnamige Methode der Oberklasse überschreibt. Das ist der Fall, wenn Methode (3) die ererbte gleichnamige Methode überschreibt. Siehe weiter unten. – Wenn man die Methode anwendenAuf mit einem Kokosnuss-Objekt als Parameter aufruft, wird Methode (1) ausgewählt und ausgeführt, wenn man sie mit einem Schwein-Objekt aufruft, wird (2) ausgeführt, wenn man sie mit irgendeinem anderen Spielobjekt-Objekt als Parameter aufruft, wird die Methode (3) ausgeführt.

Dann würde jede Schülerin, jeder Schüler eine eigene Klasse erzeugen (Messer, Kokosnuss, Hammer, Feuerstein, Zange….) und würde für jede interessante Interaktion mit einem anderen Objekttyp eine eigene anwendenAuf-Methode schreiben – und die Catch-all-Methode für die restlichen Objekttypen übernehmen. Das fände ich ordentlich.

Das funktioniert auch wie gedacht, aber leider nur erst einmal, und dann doch nicht: In der Regel wird man eine Liste oder ein Array von Spielobjekten haben, und der Spieler wählt eins davon aus und wendet sein Messer darauf an. Und dann wird automatisch und stets die Methode (3) aufgerufen, auch wenn sich hinter dem Spielobjekt eine Kokosnuss verbirgt. Will heißen, wenn ich folgenden Code ausführe:

Spielobjekt o = new Kokosnuss();
Spielobjekt k = new Kokosnuss();
Spielobjekt m = new Messer();
m.anwendenAuf(o);
m.anwendenAuf(k);

Dann wird bei m.anwendenAuf(o) die Methode (3) aufgerufen, und nur bei m.anwendenAuf(k) wird die Methode (1). Denn wenn die ausführbaren Java-Klassen erzeugt werden, also beim Compilieren, also Übersetzen des Quellcodes, dann gilt: Die Kokosnuss o ist vom Typ Spielobjekt, basta. Das heißt static binding. Bei diesem Überstzen wird dann festgelegt, dass bei m.anwendenAuf(o) eben die Methode (3) ausgeführt wird. Und das geschieht dann auch, wenn das Programm tatsächlich ausgeführt wird.

Zwar hat beim Ausführen des Programms das Objekt o dann den Typ Kokosnuss, wie man herausfinden kann durch einen Aufruf von System.out.println( o.getClass() ). Aber das bringt nichts mehr, da ist die Wahl bereits getroffen. Etwas anders ist es bei ererbten und überschriebenen Methoden. Hier noch einmal die Zeilen von oben:

Spielobjekt o = new Kokosnuss();
Spielobjekt m = new Messer();
m.anwendenAuf(o);

In der letzten Zeile wird immer noch die Methode (3) anwendenAuf(Spielobjekt) aufgerufen. Aber es ist die Methode, die in der Klasse Messer definiert ist, und nicht die gleichnamige in der übergeordneten Klasse Spielobjekt. Das ist das overriding von vorhin, und dabei wird erst zur Laufzeit entschieden, also wenn das Programm tatsächlich läuft, welche der beiden Methoden aufgerufen wird. Die Maschine schaut zur Laufzeit, von welchem Typ m wirklich ist (nämlich Messer, und nicht Spielobjekt), und wählt dann die entsprechende Methode. Das heißt dann dynamic binding.

Kurz gesagt:

  1. Wenn ein Objekt eine ererbte Methode mit einer eigenen überschreibt, wird stets letztere ausgeführt. In der Unterklasse entscheidet man also selber, ob die ererbte Methode benutzt werden soll oder ob es stattdessen eine eigene Methode geben wird.
  2. Wenn ein Objekt allerdings als Parameter einer Methode übergeben wird, hat die Klasse, die diese Methode zur Verfügung stellt, keine Auswahlmöglichkeit und kann den Objekttyp des Parameters nicht als Auswahlkriterium heranziehen. Der wird vorher festgelegt auf das, was da steht, egal welche Klasse wirklich dahinter steckt.

Fazit: Die Klasse Messer braucht nur eine einzige Methode anwendenAuf(Spielobjekt). Man muss das ganze so machen:

void anwendenAuf(Spielobjekt o) {
  if (o instanceof Kokosnuss) {
    // ...
  }
  else if (o instanceof Schwein) {
    // ...
  }
  else {
    // ...
  }
}

Ich finde das ein bisschen weniger übersichtlich, als für jedes Objekt eine eigene Methode zu haben. Außerdem stört mich der instanceof-Operator. Mit dem kann man herausfinden, ob ein Objekt zu einer bestimmten Klasse (oder: Oberklasse davon) gehört. Er hat aber einen schlechten Ruf, weil er oft ein Anzeichen dafür ist, dass man nicht wirklich objektorientiert programmiert, weil sich seine Verwendung oft ersetzen lässt durch ordentliche Vererbung und überschriebene Methoden. Hier gibt es aber keine andere Lösung. Zugegeben: Man kann für Spielobjekt-Klassen ein eigenes Typ-Attribut einführen und es sich mit getTyp() geben lassen, und das als Entscheidungskriterium hernehmen. Dann hat jedes Kokosnussobjekt ein Attribut String typ = "kokosnuss", was mir aber auch nicht gefällt. Aber immerhin käme ich so um das Erklären von instanceof herum.

So oder so habe ich ein Problem. Nehmen wir an, ich habe Patronen, mit einem Attribut int anzahl, und Pistolen mit einem Attribut boolean geladen. Es könnte auch ein Zauberstab mit Ladungen sein, oder Goldmünzen:

class Patrone extends Spielobjekt {
 
  void anwendenAuf(Spielobjekt o) {
    if (o instanceof Pistole) {
      if (((Pistole) o).geladen == true) {
        // nichts, Pistole ist bereits geladen
      }
      else {
        ((Pistole) o).geladen = true; // Pistole ist jetzt geladen
        anzahl = anzahl-1;  // der Patronenhaufen wird um 1 reduziert
        if (anzahl == 0 ) { 
          entfernenAusInventar(this); // Patronenhaufen wird evtl. geloescht
        }
      }
    }
  }
 
}

Wenn ich in anwendenAuf auf das übergebene Objekt zugreifen möchte, muss ich einen Cast machen, also das Objekt manuell einer Unterklasse zuweisen. Das kann zu einem Fehler während des Ausführens führen, wenn das Objekt gar nicht zu dieser manuell zugewiesenen Klasse gehört. Wenn es gar nicht zu dieser manuell zugewiesenen Klasse gehören kann, wird bereits beim Compilieren/Übersetzen ein Fehler gemeldet. Dieses Casten ist für Schüler auch nicht leicht nachzuvollziehen, und auch eher schlechter Stil, wenn es denn anders geht. Aber: Es geht wohl nicht.

Später sieht das dann so aus:

Benutzeroberfläche Inselspiel
Wenn man zuerst auf das Schwert und dann auf eine Kuh klickt, verschwindet die Kuh aus dem Inventar und drei Rindfleisch tauchen auf.

Hmmm… wenn man eine Methode anwendenAuf (Spielobjekt []) einführt, kann man auch das Durchlaufen von Arrays üben. Mal sehen, wie ich das einbauen kann.

Fußnote:

Eine verlockende Sackgasse ist folgender Gedanke, mit dem der ursprüngliche Plan, verschiedene anwendenAuf-Methoden zu haben, doch noch verwirklicht werden könnte, wenn es den ginge.

Class c = o.getClass(); // wird zur Laufzeit bestimmt
c oNeu = (c) o; // müsste beim Compilieren überprüft werden können
anwendenAuf(c)

Man lässt sich von dem Spielobjekt o die Klasse geben, und castet dann o auf seine tatsächliche Klasse. Aber das geht nun einmal nicht, compiliert nicht einmal. Kurz: Ich kann nicht auf eine Klassentyp casten, der in einer Variablen gespeichert ist, weil dann bei der Compilierung nicht überprüft werden kann, ob das überhaupt ein grundsätzlich möglicher Cast wäre. Denn in einer Variablen kann ja alles stecken. Das weiß man erst zur Laufzeit.

Weitere Designfragen:

(1) Diese Regeln, was geschehen soll, wenn man das Messer auf die Kokosnuss anwendet – wo sollen die hin? Man kann es machen wie oben beschrieben, dann ist jede Klasse zuständig für sich selber. Wenn eine neue Klasse (etwa: Hühnchen) eingeführt werden soll, muss man in allen Klassen, deren Objekte etwas mit den Objekten der neuen Klasse anfangen können sollen, den Code ändern. Das ist umständlich. Stattdessen könnte man eine einzige Klasse haben, die alle möglichen Kombinationen von anwendenAuf(Spielobjekt o1, Spielobjekt o2) behandelt. Großer Vorteil: Führe ich neue Klassen ein, muss ich nur in einer Klasse Code ändern. Nachteil: Diese Methode wird ziemlich groß, da die Kombinationsmöglichkeiten mit der Anzahl der Klassen schnell steigen, auch wenn, zugegeben, nur die potentiell möglichen Kombinationen implmenetiert werden müssen. Bei 5 Typen gibt es maximal 25 Kombinationen, bei 10 Typen schon 100, das wächst geradezu… nein, nicht exponentiell, noch lange nicht, aber polynomiell/quadratisch. Und vor allem kann ich es dann nicht mehr so machen, dass jede Schülerin und jeder Schüler ihre eigenen Anwendungsregeln in eigenen Klassen erstellen.

(2) Richtig viel Arbeit kann ich mir machen, wenn ich Verb-Objekte einführe, also etwa eine Klasse Schneiden, die enthält, was geschieht, wenn ich ein Objekt des Interface-Typs „KannSchneiden“ auf ein Objekt des Interface-Typs „KannGeschnittenWerden“ anwende. So ähnlich ist das zwar bei Sprachen für Textadventures, aber so gründlich will ich gar nicht sein.

(3) Wenn ich vorher weiß, welche Unterklassen von Spielobjekt es geben soll, dann kann ich in die Spielobjekt-Oberklasse 30 leere, gegebenenfalls zu überschreibende Methoden platziere: anwendenAuf(Kokosnuss k) {}, anwendenAuf(Palme p) {} und so weiter. Dazu kommt dann eine zentrale Methode:

void anwendenAuf(Spielobjekt o) { 
  if (o instanceof Messer) anwendenAuf( (Kokosnuss) o); 
  else if (o instanceof Messer) anwendenAuf( (Palme) o); 
}

Diese Methode verteilt die Aufrufe dann auf die glechnamigen Methoden mit den korrekten Argumenten. Dann greift wieder das overriding und damit dynamic binding. Dann kann ich wieder meine ursprüngliche Idee umsetzen – separate Methoden für jeden Spielobjekttyp. Allerdings muss ich halt jedesmal den Code in dieser einen Klasse anpassen, wenn eine neue Unterklasse von Spielobjekt eingeführt wird.

(4) Keine Lösung habe ich bisher für das Folgende: Wenn ich ein Messer auf eine Kokosnuss anwende, geschieht dann das gleiche, wie wenn ich eine Kokosnuss auf ein Messer anwende? Wenn ich die Patronen anwende auf die Pistole, soll das gleiche passieren wie bei der Anwendung der Pistole auf die Patronen? Wenn nein, kein Problem, dann passt alles. Wenn ja… die Messerklasse entscheidet nur, wenn das Messer angewendet wird. In welcher Klasse soll stehen, was geschieht, wenn ich die Kokosnuss anwende? Wenn das in Kokosnuss ist, führt das zu Code-Dopplung, und wo sonst? Hier fällt mir nur ein, doch Lösung (1) zu wählen.

Links, die zeigen, dass viele Leute schon vor dem gleichen Problem standen:

(Und die Linksammlung erklärt, warum es nervig ist, wenn der Webfilter der Schule stackoverflow.com sperrt.)

Der Java-Klassendiagramm-Implementierungs-Aufgaben-Generator

Benutzeroberfläche Programm

Nachtrag: aktualisierte Fassung des Programms ist am Ende des Beitrags

Das mit dem Verstehen ist ja schön und gut, aber bei Sprachen – Programmiersprachen wie anderen – reicht es nicht, wenn man die grammatischen Kategorien kennt, man muss die Sprache auch anwenden können. In Bayern lernen die Schüler in Informatik in der 10. Klasse Gymnasium (im naturwissenschaftlich-technologischen Zweig) die Grundprinzipien es objektorientierten Modellierens und Programmierens. Mit den Prinzipien haben sie auch wenig Schwierigkeiten; Klassendiagramme kriegen sie einigermaßen hin – aber das Umsetzen der Diagramme in Programmcode macht vielen mehr Probleme.

Also habe ich mir vorgenommen, im nächsten Durchgang mehr zu pauken. Eine Doppelstunde nur Klassendiagramme implementieren. Und dann nochmal, wenn es nötig ist. Das kriegt man nämlich nur durch Übung rein. – Ob ich das dann wirklich so mache, hängt natürlich von der konkreten Klasse ab. Aber ich habe mir schon etwas vorbereitet, und zwar den Java-Klassendiagramm-Implementierungs-Aufgaben-Generator. So sieht er aus:

Benutzeroberfläche Programm

Wenn man auf den weißen Knopf kriegt, erzeugt und speichert das Programm zwei Textdateien. Die eine ist ein Klassendiagramm für eine zufällig erstellte Klasse, mit 1 zufällig ausgewählten Attribut, einem Standardkonstruktor und je einer getter- und setter-Methode für das Attribut:

|--------------------
| Raumschiff
|--------------------
| alter: int
|--------------------
| Raumschiff()
| getAlter(): int
| setAlter(int): void
|--------------------

Wenn man sparsam mit den Leerzeilen ist, kann man das in sechs kurzen Zeilen programmieren. Wenn die Schülerin das getan hat, importiert sie die zweite Datei, die das Programm erzeugt hat, in ihr Projekt. Diese Datei enthält den Code für eine weitere Java-Klasse, und zwar eine Testklasse, die überprüft, ob die Klasse auch semantisch richtig implementiert worden ist, also ob die Methoden auch das tun, was sie sollen, und ob das Attribut da ist, und ob die Datentypen und die Schreibung exakt mit dem Klassendiagramm übereinstimmen. Die Testklasse sieht so aus, auch wenn die Schülerin sich den Code nie anschauen muss:

import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
 
public class RaumschiffTest {
 
  Raumschiff testObject;
 
  public RaumschiffTest() {
  }
 
  @Before
  public void setUp() {
    testObject = new Raumschiff();
  }
 
  @After
  public void tearDown() {
    testObject=null;
  }
 
  @Test
  public void attributeUeberpruefen() {
    testObject.alter = 8;
  }
 
  @Test
  public void setAlterTest() {
    testObject.setAlter(40);
    assertEquals(40, testObject.alter);
    testObject.setAlter(11);
    assertEquals(11, testObject.alter);
    testObject.setAlter(31);
    assertEquals(31, testObject.alter);
  }
 
  @Test
  public void getAlterTest() {
    testObject.alter = -5;
    assertEquals(-5, testObject.getAlter());
    testObject.alter = 64;
    assertEquals(64, testObject.getAlter());
    testObject.alter = -17;
    assertEquals(-17, testObject.getAlter());
  }
 
}

Mit einem Mausklick startet man den Test, und herauskommt eine Anzeige, welche Tests bestanden wurde:

Java-Testergebnis

Dazu muss die von der Schülerin erstellte Klasse erst existieren, und war grammatisch fehlerfrei. Die Tests überprüfen nur, ob das Programm auch das tut, was es soll, nicht ob es überhaupt läuft – das sagt einem schon der Compiler eine Stufe zuvor.

Man kann sich auch Klassen mit zwei, drei oder vier Attributen erzeugen lassen. Wenn die Attribute nicht als private markiert sind, werden die Attribute überprüft und die getter/setter-Methoden anhand dieser Attribute überprüft – ansonsten wird die getter-Methode anhand der setter-Methode auf Richtigkeit getestet, und umgekehrt. Man auch auswählen, dass ein zweiter Konstruktor mit zu den Attributen passenden Argumenten erzeugt werden soll. Außerdem kann man noch ankreuzen, ob die neuen Objekte der Klasse bestimmte Startwerte für die Attribute haben sollen, die dann im Konstruktor festgelegt werden. Dann heißt es unter dem Klassendiagramm:

Der Wert des Attributs 'alter' soll am Anfang sein: 32

Die Werte für die Attribute werden ebenfalls zufällig ausgewählt. Attribute können vorerst nur vom Typ String, boolean, char, double, int sein. Die Testklasse wird jeweils unter Berücksichtigung all dieser Entscheidungen erstellt.

Das könnte man jetzt ausweiten und die Schüler selber Klassenbezeichner und Attribute auswählen lassen. Oder mit Referenzattributen arbeiten, dass also – für den Anfang – zwei Klassendiagramme erstellt werden, wobei das eine ein Referenz auf das zweite enthält.

Wen es stört, dass das so eine Art Liegestützen für Java sind, also eher sinnlose, wiederholende Übungen, der kann sich vielleicht daran erfreuen, dass die Schüler so an den Umgang mit Testklassen und Testverfahren herangeführt werden.

  • Download des .jar-Archivs. Vorsicht: Erzeugt im selben Verzeichnis die Textdateien im Format <Klasse>Test.java und <Klasse>Diagramm.txt und überschreibt vorhandene Dateien mit gleichem Namen ohne Rückfrage.
    • Erste Bugs gefunden, verbesserte Version von 2017-08-06, 19:50 Uhr
    • Neue Version vom 2017-08-07, 09:00 Uhr, etwas aufgeräumt im Code und assertEquals bei double verbessert
    • Neue Version vom 2017-08-31: Code aufgeräumt, die Varianten bei privaten Attributen etwas eingeschränkt, und jetzt kann man auch noch optional eine zufällige Methode schreiben lassen, die kein Getter oder Setter ist. Im Moment sind das aber nur istGerade, verdoppeln, hoch3 und betrag, das wäre aber leicht zu erweitern. Hintergrund: Jetzt gibt es doch für jeden Pseudo-Datentyp eine eigene Klasse (und damit Postleitzahlen im Bereich 10000-99999 statt mit beliebigen int-Werten), und für jede Pseudo-Methode ebenfalls (die für ihren eigenen Testcode verantwortlich ist).
    • Neue Version vom 2017-09-02. Nach außen unverändert, aber viel innen umbenannt und neu gebastelt, unter anderem zusätzliche Pseudo-Methoden.
    • Neue Version vom 2018-10-21. Postleitzahlen funktionieren jetzt als String.

Computer: Kurze Umfrage in der Unterstufe

Diagramm zu Computer-Affinität

Diagramm zu Computer-Affinität

In Zukunft möchte ich das am Anfang und am Ende jeden Jahres machen: Wie fit fühlen sich die Schülerinnen und Schüler im Umgang mit dem Computer; wie fit wollen sie sich eigentlich damit fühlen?

Rot sind die Jungen, schwarz die Mädchen, übrigens. Nicht alle SuS waren da; inbesondere zwei sehr computeraffine Schülerinnen fehlten. Wer’s nicht lesen kann: Die horizontale Achse gibt an, wie gut man mit dem Computer ist, die vertikale, wie viel einem überhaupt daran liegt. Es fällt auf, dass die Jungs im Quadranten recht oben sind, die Mädchen nicht. Kümmern müssen wir uns vor allem um die Mädchen im Quadranten links oben, die würden nämlich gerne mehr können.

Dass sich Jungen zumindest in Mathematik über- und Mädchen unterschätzen, da gibt es Studien; für Informatik mag das ähnlich gelten.