Der Titel des Spiel ist ein Wortspiel mit “Ski” und der Programmiersprache “C”. Als Spiel ist es recht simpel: jeder Spieler kriegt eine oder zwei Figuren und bewegt sie nach Würfelwürfen den Kurs entlang, bis alle im Ziel sind. Der Kurs besteht aus Kästchen mit jeweils einem Element der Programmiersprache C darin (und damit auch Java sehr ähnlich).
Vor jedem Zug schaut man sich das Feld an, auf dem man steht, und wenn dort “x+2;” steht, würfelt man und zählt 2 dazu, und so viele Felder zieht man dann weiter – ebenso für x+3; und x++; und so weiter.
Es gibt besondere Felder, etwa “if (x==1)” oder “switch(x)”. Diese Felder eröffnen alternative Skipisten abseits der blauen main()-Piste – man würfelt und schaut, ob die Bedingung erfüllt ist und wechselt abhängig davon zu einem anderen Pfad.

Zu kaufen gibt es das hier. Als Spiel ist das vermutlich nicht allzu spannend, die Besprechung bei boardgame geek klingt eher mäßig. Ich habe auch noch keine Mitspieler gefunden. Aber Informatiker müssen das doch einmal ausprobieren. Wenn sich also mal in München ein paar zum Spielen treffen möchten, ich wäre dabei. (Interesse? Interesse?)
Auf das Spiel bin ich gekommen durch eine Seite mit Spielen für Informatiker. Da gibt es noch andere kuriose Spiele.

Ich hätte auch noch Ideen für Verbesserungen oder für weitere Spiele.

• Als Erstes stört mich der Umgang mit dem x. Das sollte nicht jedesmal neu erwürfelt werden, sondern fest bleiben und für alle Spieler gleich bleiben, bis es irgendwann geändert wird. Dazu legt man einen Bereich am Spielfeldrand fest, mit “x” beschriftet, auf dem man einen oder mehrere Würfel ablegt, deren Augenzahl dem aktuellen Wert von x entspricht.
• Überhaupt: Bereiche am Spielfeldrand, die für Variablen stehen. Ein Bereich für x, y, z, mit Würfeln, die den aktuellen Wert angeben. Und einen weiteren Bereich, nummeriert von 1-6, der sechs Speicherzellen darstellt, in denen alles mögliche drin sein kann. (Weitere Würfel, oder eher kurze Wörter aus Buchstabenwürfeln?) Dann muss man sich nur noch einig sein, ob x den Zahlenwert angibt (etwa 1), oder auf den Inhalt der Speicherzelle (etwa mit der Nummer 1) verweist.
• (Grundgedanke, zu erweitern: Den Zustand eines Objekts mit eienr Anzahl von Variablen-Würfeln auf dem Spielfeld angeben.)
• Dann wäre es mir lieb, wenn die Spieler nicht auf demselben Kurs fahren würden, sondern auf verschiedenen Kursen – entweder mehrfach den gleichen, oder auch auf echt unterschiedlichen Kursen. Das wären dann, sagen wir, eigene Spielpläne, die man parallel nebeneinander legen könnte. Die Spieler wechseln sich auch nicht einfach ab, sondern ein Spinner (eine Drehscheibe, scheduler genannt) entscheidet, wer jeweils als Nächstes drankommt. Damit kommt man dem parallelen Arbeiten von Threads, sagen wir, näher.
• Nächste Stufe: es gibt bestimmte Streckenteile, die doch von allen Strecken genutzt werden. Damit kann man das Erzeuger-Verbraucher-Problem modellieren.

Andere Spiele, die ich im Blog vorgestellt habe und für die ich auch nie Mitspieler finde:

• Eleusis
• WFF ‘n Proof
• (Und nur kurz in einem Kommentar erwähnt: Queries & Theories.)

Quelle: Herr Rau aus dem Lehrerzimmer 2012. | Permalink | 3 Kommentare

Dabei sollen die Schüler aber nicht primär den Umgang mit solchen Tabellenkalkulationsprogrammen lernen, sondern das – allgemeinbildendere – Prinzip von Datenverarbeitung als Eingabe-Verarbeitung-Ausgabe. Es geht etwas rein ins System, das System macht irgendwas damit, und es kommt etwas heraus. Klingt einfach, ist aber oft zu übersehen. So funktionieren auch Funktionen, wie man sie aus der Mathematik kennt: eine Zahl geht rein, oder auch mehrere, und eine – häufig davon verschiedene – Zahl kommt heraus. Tabellenkalkulationsprogramme sind voll von solchen Funktionen:

• summe(zahl1; zahl2) – zwei Zahlen gehen rein, eine kommt heraus, zum Beispiel gibt summe(4;5) als Ausgabe 9
• wenn(bedingung; dann; sonst) – drei Sachen gehen rein, eine kommt heraus, zum Beispiel bei wenn(b1>12; “ja”; “nein”)
• zählenwenn(bereich; zahl) – viele Sachen gehen rein, eine kommt heraus, zum Beispiel gibt mir zählenwenn(b1:b30;6) die Anzahl der 6er im angegebenen Bereich
• abrunden(zahl1; zahl2) – zwei Zahlen gehen rein, eine kommt heraus, zum Beispiel gibt abrunden(3,14159;2) als Ausgabe 3,14
• code(text) – ein Text geht rein, eine Zahl kommt heraus, nämlich die ASCII-Codierungsnummer des ersten Buchstabens des Eingabetextes

Bei diesen Funktionen ist aber wichtig, dass ich die richtigen Datentypen als Eingabe wähle. summe(4;5) geht, weil beide Eingabewerte Zahlen sind und das bei summe so sein muss. summe("Hallo";"Peter") geht nicht, weil die Eingabewerte Text sind und nicht Zahlen.

Es gibt bei den gängigen Tabellenkalkulationsprogrammen – Wortungetüm, auf Englisch kürzer: spreadsheet – übrigens nur zwei Datentypen: Text und Zahl. Alles, was man in eine Zelle eingibt, läuft letztlich auf das eine oder andere hinaus. Eine Zahl, etwa die Zahl 2, kann ich darstellen als Währung, dann gibt es automatisch Nachkommastellen und ein Eurozeichen: 2,00 €; oder als Prozentwert, dann wird die Zahl 2 eben als 200,00% dargestellt. Ich kann sie aber auch, und das ist weniger bekannt, als Datum darstellen, dann steht da: 1.1.1900, oder als Boolescher Wahrheitswert, dann steht da WAHR. Aber im Grund bleibt das immer die unveränderte Zahl 2. Ich kann also auch damit rechnen: eine Zelle, in der das Datum 1.1.1900 steht, multipliziert mit einer Zelle, in der das Datum 2.1.1900 steht, ergibt den 5.1.1900, natürlich. Nicht dass das viel Sinn macht.
Das Allgemeinbildende daran ist: 1. Daten bleiben gleich, auch wenn man sie verschieden darstellt. 2. Daten bedeuten erst dann etwas, wenn man sie interpretiert – ob eine 2 eine 2 ist oder WAHR oder der 1.1.1900 oder 48 Stunden oder Mitternacht, das ist Definitions- und Interpretationssache.

Funktionen kann man auch verknüpfen:

• abrunden(3,14159;2) gibt 3,14, und
• summe(abrunden(3,14159;2);2) gibt 5,14, und
• produkt(summe(abrunden(3,14159;2);2);2) gibt 10,28

und beliebig so weiter. Darstellen kann man das grafisch in Datenflussdiagramm. Das fällt nicht allen Schülern leicht.
In so einem Diagramm steht ein eckiger Kasten für einen ein- oder ausgegebenen Wert, also eine Zahl oder einen Text. Die Funktionen werden durch Ellipsen dargestellt, aus der 1 Pfeil hinausgeht (zu einem Ausgabekasten oder zur Weiterverarbeitung in einen Eingang einer weiteren Funktion) und im Prinzip beliebig viele Pfeile hineingehen – sagen wir, 1-3, der Einfachheit halber.

Zum Üben heute habe ich heute meine Neuntklässler ins Schulhaus geschickt, solche Diagramme anlegen.

• Arbeitsmaterial dazu: Papier im Format DIN A5, Stifte, Handy.
• Anlegen des Materials: auf jedes Blatt kommt entweder ein Kasten, der mit “Text” oder “Zahl” markiert ist. Oder es kommt ein Ellipse darauf, aus der unten jeweils ein Pfeil heraus und oben 1-3 Pfeile hinein gehen. Jeder Pfeil wird ebenfalls mit “Text” oder “Zahl” markiert.
• Von diesen Blättern eine ganze Menge verschiedene anlegen.
• Dann kann man diese Blätter zusammenpuzzlen. Die einzigen Legeregeln: 1. Pfeile dürfen nie in der Luft hängen, sondern müssen immer irgendetwas verbinden, und 2. man darf nur “Text” mit “Text” und “Zahl” mit “Zahl” verbinden.
• Auftrag: im Schulhaus in Gruppen ein schönes großes Puzzles zusammenlegen, und überlegen, welche Funktionen die Ellipsen darstellen könnten. Fotografieren.

Wenn man sich daran hält, kommen immer syntaktisch korrekte Diagramme heraus, die man fehlerfrei in der Tabellenkalkulation umsetzen kann. (Hat natürlich nicht bei allen geklappt.) In eckigen Kästen darf dabei immer nur eine Zahl oder ein Text stehen, sonst nichts, und schon gar nichts Zusammengesetztes wie “Maxis Alter = 12″ – dazu neigen meine Schüler nämlich.

Datenflussdiagramme sind eigentlich für mehr gedacht als die Beschreibung von Funktionen, und auch die Angabe der Datentypen (“Text”, “Zahl”) ist nicht üblich. Aber ich wollte das explizit als Vorbereitung auf die zehnte Klasse. Dort bereiten nämlich Datentypen und die Java-Syntax von Funktionen den Schülern Schwierigkeiten, und überhaupt der Gedanke, dass in Funktionen etwas hinein- und etwas aus ihnen herauskommt. Vielleicht beginne ich die nächste 10. Klasse überhaupt nicht objektorientiert, sondern mache unmittelbar mit Funktionen und Datentypen weiter.

Zu Hause ist mir dann die Idee gekommen, ob man nicht ein Kartenspiel aus diesem Diagrammpuzzle machen kann. Ich habe mal ein paar Blankospielkarten genommen – so etwas sollte jeder Lehrer zu Hause haben, ist sehr inspirierendes Spielzeug – und darauf herumgekritzelt:

(Um, denkt dabei noch jemand außer mir an Illuminati! von Steve Jackson Games?)

Grün steht dabei für einen Datentyp (sagen wir: Zahl), rot für einen anderen (Text). Rechtecke gibt es in grün und rot. Auf der Rückseite der Ellipsen/Funktionen-Karten ist noch einmal die gleiche Ellipse abgebildet, jetzt aber mit dem Namen einer Funktion, die zu deren Ein- und Ausgabepfeilen passt. Auf der Rückseite der obersten Ellipsenkarte könnte etwa summe stehen oder auch aufrunden oder das logische und, und vielleicht eine kurze Erklärung der Arbeitsweise dieser Funktion. (Oder sollte man doch mit mehr Datentypen arbeiten: Ganzzahl, Kommazahl, Text, Wahrheitswert?)

Fehlen nur noch Spielregeln. Ideen, noch völlig ungetestet:

• Jeder Spieler legt reihum eine passende Karte an, bis einer keine Karten mehr hat. Ein neues Diagramm darf erst angefangen werden, wenn das alte keine offenen Pfeile mehr hat.
• Optional: Wenn das Diagramm fertig ist, werden die Ellipsenkarten umgedreht und auf jedes Zahl-Kästchen ohne Pfeil darauf (also jeden Eingabewert) kommt ein Würfel, frisch gewürfelt. Dann das Ergebnis ausrechnen und vergleichen. Wie man das bei Text machen könnte, weiß ich noch nicht.
• Oder Romme-artig: man kann immer nur ganze und komplette Diagramme auf einmal auslegen, die aus mindestens drei Karten bestehen müssen. Mehr Karten bringen deutlich mehr Punkte, so dass es sich eventuell lohnt, noch nicht gleich alle kleinen Diagramme abzulegen.
• Optional: Man kann bei ausgelegten Diagrammen anderer Spieler anlegen.
• Anderes System: Sieben Karten kommen vom Stapel aufgedeckt in die Mitte. Welcher Spieler sagt als Erstes, wie viele davon man maximal in ein korrektes Diagramm einbauen kann?
• Anderes System: Sieben Karten kommen vom Stapel aufgedeckt in die Mitte. Reihum wählt jeder eine davon und legt sie ans gemeinsam erstellte Diagramm an. Der Spieler, der eine Karte so anlegt, dass der folgende das Diagramm komplettieren kann, verliert.

Das wäre doch mal etwas für eine Informatiker-Fortbildung. Ich hätte auch noch Ideen für andere Spiele.

Quelle: Herr Rau aus dem Lehrerzimmer 2012. | Permalink | 3 Kommentare

Also besser: Cory Doctorow, Lockdown – the coming war on general-purpose computing. (Der Link führt zu einer leicht gestrafften englischen Textfassung eines Vortrags, den es auch als Videoaufnahme und als deren deutsche Übersetzung gibt. Links dazu bei Netzpolitik, wo ich auf den Vortrag aufmerksam gemacht wurde.)

Die These des Vortrags (und ja, der Vortrag ist nicht antithetisch; es ist nur in der Schule, wo wir antithetisches Argumentieren so in der Vordergrund rücken) ist die: der aktuelle Kampf um DRM (Digital-Rights-Management) und Software-Rechte (was darf ich mit meiner gekauften Musikdatei alles machen?) ist nur der Anfang; die nächste Frage wird sein: Was werde ich mit meinem Computer machen dürfen?

In den 1920er Jahren ging es in der Mathematik darum, was man überhaupt alles berechnen kann, und wie man das formalisieren kann. (Vorsicht, bin Laie und kenne mich da wenig aus. Das ist aber spannender, als es vielleicht klingt.) So ab 1930 herum überlegte sich Alan Turing dazu das Konzept der universellen Rechenmaschine oder Turing-Maschine. Das wäre eine Maschine, die anders als bisherige Rechenmaschinen nicht nur bestimmte Arten von Berechnungen ausführen kann, sondern alle. Eine Turing-Maschine kann alles berechnen, was man überhaupt berechnen kann.
Das ist das theoretische Standbein des modernen Computers. Computer sind genauso mächtig wie Turing-Maschinen (aber auch nicht mächtiger, weil es mächtiger nicht geht). Das praktische Standbein des modernen Computers kommt aus der Ingenieurswissenschaft: Konrad Zuse baute sich die Z1 und später die Z3, den ersten programmierbaren Universalrechner, der eben alles berechnen konnte, was sich berechnen ließ.

Heute ist das selbstverständlich, dass ein Computer eine Maschine ist, die praktisch alles kann. Deshalb kann ich auf meinem uralten iPod ja auch Doom installieren und spielen. Computer sollen und müssen auch ständig neue Sachen berechnen, an die man vorher nie gedacht hatte. Man installiert ständig neue Software, und laufende Programme verändern sich selber, und das Betriebssystem kriegt ein Update.

Zurück zu Doctorow:

Er beschreibt erst einmal sehr schön die Entwicklung des Versuchs, Software vor dem Kopieren zu schützen: zuerst war die Software verschlüsselt. Dazu musste man verhindern, dass jemand an den Schlüssel kommt. Dann musste man vebieten, dass dieser Schlüssel weitergegeben wurde. Dann musste man verbieten, dass man anderen sagte, wie man an solche Schlüssel kam. Und so immer weiter: verbieten, verbieten, verbieten. Man darf Verschlüsselungssoftware nicht analysieren, man darf verschlüsselte Software (also auch Musik) nicht illegal entschlüsseln, man darf anderen nicht sagen, wie das geht.

Nur dass das nicht funktioniert. Wer will, kann alles kopieren, basta.

Das sei aber nur der Anfang, so Doctorow. Im Moment möchte eigentlich vor allem die Film-, Computerspiel- und Musikindustrie, dass ich mit meinem universellen Computer nicht alles machen darf, was ich mit meinem universellen Computer machen kann. (Und der Staat erlässt Gesetze, die das bewirken sollen.) Bald werden andere Industrien dazu kommen.

Und sie alle werden sich wünschen, dass bestimmte Programme nicht laufen dürfen auf den Computern. Das geht aber nicht, weil diese Rechner nun mal universell sind. Das einzige, was man machen kann: man kann dem Benutzer verbieten, seinen Rechner als universelles Werkzeug zu benutzen. Man kann verbieten, andere Betriebssysteme aufzuspielen, man kann verbieten, sich anzuschauen, welche Prozesse gerade laufen, also was der Computer im Moment alles tut. Damit erteilt man dem Rechner aber die Lizenz, zu machen, was er will – also was seine Hersteller wollen, unkontrollierbar durch den Benutzer.

Wenn ich einen neues Handy kaufe, habe ich in der Regel keine vollen Rechte auf dem System. Das heißt, ich kann auch nicht kontrollieren, was das Ding eigentlich tut. (Also, ich kann das sowieso nicht, weil ich mich damit nicht auskenne. Aber es reicht ja, dass es andere gibt, die dazu in der Lage sind.) Noch ist es allerdings erlaubt und relativ einfach möglich, sich diese Rechte zu besorgen. Dann kann man theoretisch kontrollieren, was das Ding tut – insbesondere, was es vielleicht ohne Wissen des Benutzers tut.

Und das, so Doctorow, ist der nächste Schritt nach dem DRM. Noch kann und darf man sich Root-Rechte auf seinem Kindle und seinem iPad verschaffen. Gilt das auch für meinen zukünftigen 3D-Drucker? Für mein elektronisches Schulbuch, Türschloss, Hörgerät, Lesebrille, und was noch alles auf uns zukommt?

Quelle: Herr Rau aus dem Lehrerzimmer 2012. | Permalink | 15 Kommentare

Für Deutsch bin ich auch auf so einer Liste, aber da ist viel weniger los. Keine kritische Masse, schätze ich. Oder sind die Englischlehrer kommunikativer – oder internetfreundlicher? Da könnte etwas dran sein.

Es gibt jetzt auch für Informatik eine neue Mailingliste, unter:
http://www.schule.bayern.de/service/mailinglisten
kann man sich anmelden. (Die Liste auswählen, die “Informatik” im Namen hat.)

Bin gespannt, wie internetaffin Informatiklehrer sind. Es gibt schon eine Mailingliste (ZUM-Informatik), auf der ich auch bin, wo aber nicht viel los ist. Haben Informatiklehrer weniger Austauschbedarf oder gibt es einfach nicht genug solche Lehrer? Ich habe ja ein bisschen den Verdacht, dass Mathe-Physik-Lehrer, und aus dieser Richtung kommen die meisten Informatiklehrer noch, weniger interessiert am Austausch an sich sind. Dafür haben die an meiner Schule die engste Zusammenarbeit untereinander.

Nachtrag: Die Adresse der Englisch-Mailingliste ist: http://groups.yahoo.com/group/enpaed/

Quelle: Herr Rau aus dem Lehrerzimmer 2012. | Permalink | 1 Kommentar

(Fußnote: Transparent heißt überall anders soviel wie: “Durchsichtig, so dass man ins Innere blicken und die Zusammenhänge verstehen kann.” In der Informatik heißt transparent allerdings: “Durchsichtig, so dass man hindurchschaut und nichts sieht, also quasi unsichtbar und vor leicht zu verwirrenden Augen verborgen.”)

Man kann mit Processing neue Bilder zeichnen oder bestehende Bilder bearbeiten. Das kann man statisch machen oder dynamisch: dann werden daraus bewegte Bilder, entweder automatisch oder durch den Benutzer mit Maus oder Tastatur gesteuert. So kann man auch ganze Simulationen entwerfen, wenn man möchte. Man kann sich auch eine Methode schreiben, um die ausgegebenen Bilder zu speichern, die sieht so aus:

void mousePressed() {
  save("bild.jpg");
}


Viel einfacher geht es wirklich nicht.

Ich wollte aber Filter schreiben, so wie man sie aus Bildbearbeitungsprogrammen kennt. Hier sind ein paar davon. Die Vorgehensweise ist meist die: Man lädt erst einmal das Originalbild in den Speicher und legt eine – noch leere – Zeichenfläche im gleichen Format an. Dann schaut man sich der Reihe nach jeden Pixel des Ursprungsbildes an, merkt sich dessen Farbe (bzw. den Rot-, Grün-, Blauanteil davon), verändert diese Farbe, und schreibt an dieselbe Position auf der Zeichenfläche einen Pixel mit der neuen Farbe.

1. Hier ein einfaches Weichzeichnen, das erste Bild ist das Original:

Man ändert dabei jede Farbe so, dass man sich von einem Pixel und allen seinen umliegenden Nachbarpixeln (im ersten Beispiel nur die direkt umliegenden, im zweiten auch die in etwas weiterem Abstand) die Durchschnittsfarbe ausrechnet und diese dem Pixel zuweist. Das macht man mit allen Pixeln so und heraus kommt eine Weichzeichnung.

2. Hier eine Gammakorrektur. Die dient zu einer differenzierten Aufhellung oder Abdunklung von Bildern. Dabei wird nicht jeder Pixel im gleichen Maß heller oder dunkler gemacht, sondern es werden zum Beispiel die dunklen Pixel mehr aufgehellt als die (ja eh schon hellen) helleren. Im ersten Bild mit gamma=0.5, im zweiten gamma = 1.5:

Hier sind einem die Nachbarn egal. Man wendet einfach auf den Rot-, Grün-, Blauteil jedes Pixels die überraschend einfache Funktion an:

farbeneu = (farbealt/255)gamma * 255

Die Zahl 255 kommt daher, weil es für jede Farbton 255 Möglichkeiten gibt. Der Wert des ursprünglichen Blauanteils (von 0-255) wird durch 255 geteilt, womit man diesen Anteil auf eine Zahl zwischen 0 und 1 normalisiert hat. Das wird dann mit dem Gammawert potenziert (bzw. je nach Definition auch dessen Kehrwert) und dann mit dem letzten Faktor wieder auf den ursprünglichen Raum (zwischen 0 und 255) gestreckt.

3. Gemischte weitere Filter:

Der erste ist ein einfaches Schärfen: Man schaut sich wieder die Rot-, Grün- Blauwerte eines Pixels und seiner Nachbarn an und errechnet daraus wieder einen Durchschnitt. Allerdings werden vor der Berechnung die Nachbarn und der Pixel selber noch gewichtet: die Werte der 8 unmittelbaren Nachbarn werden zum Beispiel jeweils um 1 reduziert, die des zentralen Pixels um 9 erhöht – die Durchschnittswerte bleiben also gleich (das Bild wird insgesamt nicht heller oder dunkler), aber mit Betonung des Zentrums.

Der zweite zeichnet einfach an jede n-te Stelle des Bildes einen Kreis mit Durchmesser n von der Farbe des Pixels, der sich im Originalbild an dieser Stelle befindet.

Der dritte ist ein Mosaik. Man könnte zwar, ähnlich wie bei den Ellipsen, an jede n-te Stelle des Bildes ein Quadrat zeichnen, aber so wollte ich das nicht machen. Jeder Pixel sollte extra gezeichnet werden. Ich machte mir dazu folgende Skizze:

Der erste Pixel in der Reihe (in der 0-Spalte) sei zum Beispiel rot. Die beiden Pixel rechts daneben sollten dessen Farbe annehmen. Die Pixel in den Spalten 3-7 sollten die Farbe des Pixels in Spalte 5 annehmen, und so weiter. (Für die y-Koordinate analog, das habe ich bald gemerkt.)

Weil ich in Mathe nicht gut bin, zeichnete ich mir eine Tabelle auf: links die Position des Pixels, rechts die Position des Pixels, dessen Farbe angenommen werden sollte. f(linkeSpalte) = rechteSpalte. Der Rest ist einfach nur Rechnen. Mathekönner sehen das durch Überlegen, ich habe halt so lange herumgepfuscht, bis ich die entsprechende Funktion hatte. Die musste ich dann noch etwas verallgemeinern, damit sie nicht nur für die Rechnung mit den Mosaiksteinchen von Seitenlänge 5, sondern für beliebige Seitenlängen gilt. Sieht dann so aus:

xZentrumspixel = (x+size/2)/size*size bzw.
yZentrumspixel = (y+size/2)/size*size,

wobei size die Seitenlänge des Mosaiksteins ist. Und nein, das /size und *size kann man nicht einfach kürzen, da x eine Ganzzahl und die Divison in diesem Fall eine Ganzzahldivision ist – es wird immer abgerundet, der Rest verworfen.

Processing gibt’s für alle gängigen Betriebssystem, läuft unter Windows auch ohne Installationsrechte. Tutorials gibt es dort auch ein paar.

Anhang: So sieht ein vollständiger Sketch in Processing aus. Java-Code, ohne Klassendefinitionen, besteht aus 1 Attribut und den Methoden setup() und draw() und der Berechnungsmethode für das Mosaik, mosaik().

PImage img; //Platz fuer das im Speicher gehaltene Bild

//einmaliges Aufrufen am Anfang
void setup() {
  img = loadImage("test.jpg"); //Laden des Bildes
  size(img.width, img.height); //Groesse der Zeichenflaeche
}

//das eigentliche Zeichnen
void draw() {
  //Pixel-Feld zur Verfuegung stellen
  loadPixels();
  //Zaehlschleife fuer alle Pixel mit x- und y-Koordinate
  for (int x = 0; x < img.width; x++) {
    for (int y = 0; y < img.height; y++ ) {
      //Berechnen der neuen Farbe - hier koennte man auch andere Methoden aufrufen
      color c = mosaik(x, y, 9);
      //Umrechnen der Koordinaten in Index des eindimensionalen Pixel-Felds
      int loc = x + y*img.width;
      //Aendern des Pixels im Pixel-Feld
      pixels[loc] = c;
    }
  }
  //Zeichnen aller Pixel
  updatePixels();
}

//Methode zur Farbberechnung beim Mosaik
color mosaik(int x, int y, int groesse) {
  //Koordinaten des Zentrums ermitteln
  int xZentrum = (x+groesse/2)/groesse*groesse;
  int yZentrum = (y+groesse/2)/groesse*groesse;

  //Umrechnen der Koordinaten in Index des eindimensionalen Pixel-Felds
  int loc = xZentrum + yZentrum*img.width;

  //sicher stellen, dass Bildgrenzen nicht ueberschritten werden
 loc = constrain(loc, 0, img.pixels.length-1);

  //Rot-, Gruen-, Blauanteile des Zentrumspixels speichern
  float rtotal = red(img.pixels[loc]);
  float gtotal = green(img.pixels[loc]);
  float btotal = blue(img.pixels[loc]);           

  // Rueckgabe der neuen Farbe
  return color(rtotal, gtotal, btotal);
}

Quelle: Herr Rau aus dem Lehrerzimmer 2012. | Permalink | 4 Kommentare

In der 10. Klasse entwirft und programmiert man einfache Zustandsautomaten. Die sehen auf dem Papier gerne mal so aus:

Der Automat (hier ein Fahrstuhl) kann sich in verschiedenen Zuständen befinden. Er beginnt im Zustand Erdgeschoss (deshalb zeigt da ein Pfeil hin). Es gibt noch zwei weitere Zustände, Keller und 1. Stock. Der Automat kann seinen Zustand ändern, das sind die Pfeile zwischen den Zuständen. Wenn der Automat im Zustand “Erdgeschoss” ist und die Aktion “Pfeil nach oben drücken” eintritt, dann springt der Automat in den Zustand “1. Stock”.

Es geht aber auch noch komplizierter:

In diesem Automaten geht es um ein Marsmännchen, das im Zustand Mars (Nr. 4) beginnt. Je nach Aktion (j für Jupiter, p für Pluto, w für Weltall und so weiter) springt das Marsmännchen in einen neuen Zustand, wenn dieser Zustandsübergang laut Diagramm möglich ist.
Allerdings gibt es noch zwei Feinheiten:
1. Für manche Zustandsübergänge gibt es eine Bedingung, die erfüllt sein muss. Diese Bedingungen sind in rot angegeben. Das Marsmännchen hat nämlich eine gewisse Sprungkraft, am Anfang 10. Vom Mars zum Jupiter springen kann es nur, wenn (neben der auslösenden Aktion j) seine Kraft mindestens 1 beträgt, sonst wird nichts daraus.
2. Und zuletzt gibt es manchmal, in dunkelgrün angegeben, noch weitere Aktionen, die neben dem Zustandsübergang ausgelöst werden. Im Fall vom Sprung von Mars zu Jupiter steht da etwa, dass sich die Kraft um 1 verringert, beim Sprung vom Weltall (Nr. 7) zum Mars (Nr. 4) sind es sogar 5 Punkte. Manche Reisen sind allerdings umsonst. Auftanken kann man nur auf dem Mond, wenn man den erreicht, wir die Kraft wieder auf 10 gesetzt. Wenn man irgendwo auf einem Planeten festsitzt und nicht genug Kraft hat um wegzukommen, ja, dann hat man Pech gehabt.

Einfacher ist das, wenn man es ausprobiert (Java-Applet, läuft also nicht überall):

Möglich sind die Eingaben: j, p, w (für Weltall), e, n (für Neumond), m und s – aber natürlich führen nicht alle immer zu einem Zustandsübergang.

Programmiert und gezeichnet haben den Marsmännchen-Automaten (abgesehen von der Ausgabe in einem Fenster, dazu später mehr) zwei Schülerinnen aus der 10. Klasse. Entstanden sind aber auch noch andere Automaten:

Weitere Automaten:

• Wasser
• Hund
• Alltag
• Poker
• Boxer
• Blume

Programmiert haben die Schüler dabei nur den Automaten, und da vor allem die Zustandsübergangsmethode. Um die grafische Ausgabe habe ich mich gekümmert, und zwar so (siehe Eintrag zu MVC):

(Das ist kein Klassendiagramm, sondern die BlueJ-Oberfläche, gibt aber einen Eindruck der Verhältnisse wieder.)

• Das Marsmännchen (oder was auch immer) hat eine Methode aktionEmpfangen(char). Je nach empfangener Aktion, abgekürzt durch einen einzelnen Buchstaben, ändert es seinen Zustand und teilt das daraufhin der Welt mit. Das Marsmännchen erbt nämlich vom Automaten auch die Sende-Fähigkeit.
• Das Sekretariat (das auch ein Empfänger ist) empfängt die Nachricht über den neuen Zustand und wählt, dem Zustand entsprechend, eine neue Grafik aus, die dargestellt werden soll. Das ist die einzige Klasse, in der Schüler etwas schreiben müssen: die Namen der Grafiken.
• Die Hauptarbeit der Darstellung übernimmt das Fenster. Der Fensterboss ist nur dazu da, damit man ein- und dasselbe Programm sowohl als Applet (also in einer Webseite) wie auch als eigenes Programm ausführen kann. Das Fenster stellt Textfelder und Knöpfe zur Verfügung. Wenn ein Knopf gedrückt wird, die Information und eventuell der Inhalt des Textfelds an die Steuerung.
• Die Steuerung wertet die Eingabe aus. Standardmäßig werden nur Eingaben angenommen, die 1 Zeichen lang sind; alles andere führt zu einer Rückmeldung, dass etwas nicht stimmt. Dieses eine Zeichen wird dann an den Automaten, also das Marsmännchen, weitergeleitet, das daraufhin eventuell seinen Zustand ändert – und immer so weiter. (Man könnte die Steuerung auch zu einem echten Übersetzer machen: dann müsste der Benutzer ganze Wörter eintippen, also etwa “Gehe zum Jupiter”, und die Steuerung würde das in ein ‘j’ übersetzen und das an den Automaten schicken.

Auf Interfaces (und Beobachtermuster) und Zustandsmodellierung mit eigenen Klassen habe ich verzichtet. Es reicht, wenn die Schüler in der 10. ein bisschen hineinschnuppern. Herunterladen kann man das BlueJ-Projekt hier, es ist aber sehr spärlich kommentiert, und im Fall des Fensters auch sehr schlampig. GUIs interessieren mich wenig.
Wenn es nur um einfache Automaten ginge, könnte man den Schülern auch eine Benutzeroberfläche schreiben, wo sie nur ihre Bildernamen speichern und die Übergänge mit Mausklicks auswählen müssen, aber es geht ja auch darum, Programmierung zu üben.
Zustandsautomaten kann man immer mal brauchen. Aus einem Kommentar beim Kollegen embee habe den Hinweis auf die Rolle von Zustandsautomaten bei Comptuerspielen.

Wichtig war mir ansonsten auch, dass die Schüler ihr Produkt in einem kleinen Video vorstellen, auch wenn ich die nicht alle hier veröffentlichen darf.

Quelle: Herr Rau aus dem Lehrerzimmer 2011. | Permalink | 5 Kommentare

Eine gängige Theorie der Herkunft wird gleich zu Anfang verworfen:

Wie die Kinder entstehen, das wüssten die Schüler ja bereits:

Wie sie auf die Welt kommen, hoffentlich auch:

(Tatsächlich habe ich andere Bilder genommen. Je nachdem, was die Schüler der Klasse so vertragen.)

In der Informatik geht es aber nicht um kleine Kinder, sondern – beim objektorientierten Programmieren – um Objekte. Die kennen die Schüler schon. Sie kennen vor allem schon Klassen. Klassen sind die Vorlagen für später entstehende Objekte, so wie das DNA-Molekül (in seinen verschiedenen Formen) die Vorlage für spätere (verschiedene) Kinder ist.

Und demnach entspricht ein Objekt dann auch dem tatsächlich existierenden Kind:

Und die Frage für Schüler ist nun: Was entspricht beim objektorientierten Programmieren dem Geburtsvorgang? Wie kommt man von der Vorlage zum Objekt?

Die Antwort heißt: mit dem Konstruktor, und um dessen Einführung ging es in der Stunde. Irgendwann mündet das dann in Übungsphase und Hefteintrag, für Java:

(Herunterladen der Präsentation, falls jemand das brauchen kann – andere Bilder kann man natürlich auch nehmen.)

Und das alles natürlich nur, weil diese weißen Laborkittel so kleidsam sind.

Quelle: Herr Rau aus dem Lehrerzimmer 2011. | Permalink | 4 Kommentare

Das ist das einzige Bild, das ich gemacht habe, noch ganz am Anfang, etliche Leute stehen noch bei der Anmeldung:

Was soll ich dazu sagen… an der Organisation war ich mit beteiligt, wenn auch nur als Juniorpartner, weil ich die Leute und Organisationen und Strukturen alle noch nicht kenne. Aber ich habe mitgekriegt, was es für eine Heidenarbeit ist, so etwas auf die Beine zu stellen. So lange ich das noch einigermaßen im Kopf habe, muss ich mir eine Checkliste aller zu erledigenden Punkte anlegen – falls ich je in die Situation kommen sollte, so etwas auszurichten. Eventmanagement wäre jedenfalls nichts für mich. Vieles hat geklappt, manches leider nicht, habe ich gehört, gerade mit der Technik. Das tut mir leid. Aber das wichtigste war für mich, Leute wiederzusehen. Eine Studentin, die vor eineinhalb Jahren bei mir im Praktikum war, eine Lehrerin, die vor dreieinhalb Jahren als Studentin mit anderen Lehrern bei mir zum Essen war, ein ehemaliger Kollege, der jetzt anderswo in der Schulleitung sitzt, zwei Leute aus meinem eigenen Informatik-Studiumsgang, und andere, die ich nur von Fortbildungen kenne. Sich so ein-, zweimal im Jahr zu sehen und über Schule und Unterricht zu plaudern, das ist schön. Auch wenn ich noch gar nicht viele Informatiklehrer kenne.

Es gab einen Hauptvortrag und danach Zeit für drei Workshops/Vorträge mit jeweils Kaffee- und Mittagspause dazwischen, verteilt auf sieben Schienen. Den Hauptvortrag hielt Michael Weigend von der Universität Münster: “Visualisierungen zur Veranschaulichung von Konzepten der Informatik”. Für mich behalten habe ich daraus:

• Informatikdidaktik arbeitet viel mit Metaphern.
• Metaphern helfen, Konzepte zu verstehen.
• Metaphern können auch Missverständnisse entstehen lassen oder erkennen helfen.
• Beispiele für Metaphern: die Schublade für eine Variable; die Weiche für eine Entscheidung; der Toaster für eine Funktion (eine Sache geht rein in die black box, etwas anderes kommt nach einiger Zeit heraus); und sehr schön: die Spielkarte für eine Boolesche Variable.
• Ein Bild zur Verdeutlichung dessen, dass Variablen Behälter für verschiedene Datentypen sind. Das Bild hat Michael Weigend in seiner Präsentation gezeigt, ich habe es hier mal für mich und meinen Unterricht übernommen und frech nachgebaut:
  
  (Zur Erklärung: Variablen kann man als Behälter sehen, so wie Schubladen. In den Schubladen ist etwas drin, das kann man herausnehmen und durch etwas anderes ersetzen. So ist das bei den Variablen auch. In vielen Programmiersprachen muss man festlegen, zu welchem Datentyp der Behälter gehört, also welche Art Sachen hineinpassen und welche nicht. In eine Variable vom Typ int passen in Java nur ganze Zahlen, in eine vom Typ char nur einzelne Zeichen. Also werde ich die Schüler Behälter sammeln lassen, die jeweils für bestimmte Inhalte gedacht sind.)

Ich war in zwei Vorträgen/Workshops und habe einen geleitet/gegeben. Mit, hm, mittlerem Erfolg. Ich arbeite ja auch viel mit Metaphern und habe Videoclips dazu erstellt. Die habe ich gezeigt (und die von anderen auch, unter anderem zwei Schülervideos, die ich nicht veröffentlichen darf) und erklärt, mit welcher Software man so etwas erstellen kann und warum man das sollte. Gut im Verkaufen bin ich allerdings nicht. Ein Lehrer war da und hat einen eigenen kleinen Robot-Karol-Clip gezeigt, der sehr witzig war – aber viel Zeit kostet. Deshalb denke ich, die Schüler sollten Videos erstellen. Mein Systembetreuer hat mir versprochen, für dieses Schuljahr das kostenlose Camstudio auf den Schülerrechnern zu installieren, mit dem man auf einfache Weise den laufenden Bildschirm oder Teile davon abfilmen kann.

Damit und mit einem einfachen Headset-Mikrofon kann man zum Beispiel die Programmierprojekte vorstellen, die in der Q11 entstehen sollen:

– Getwittert wurde auf dem ILTB ebenso wenig wie auf der INFOS. Ich behaupte mal, Informatiklehrer machen noch weniger Social Media als andere Lehrer. Also nichts mit Web 2.0 oder so. Informatiklehrer haben auch keine lustigen Nerd-T-Shirts. Ich selber habe auch nur ein einziges Informatikshirt, mit einem öffnenen body-tag vorn und einem schließenden hinten. Aber das bräuchte ich inzwischen eine Nummer größer… Völlig anderes Publikum als auf der re:publica jedenfalls. Immerhin, so wurde mir versichert, Informatiker an Unis hätten solche T-Shirts. Aber auch die nutzten kein Web 2.0 – liegt das vielleicht daran, dass alles, was man nicht selbst geschrieben hat, verpönt ist? Aber das kann ein Vorurteil sein. Ich kenne ja gar keine Informatiker.

Quelle: Herr Rau aus dem Lehrerzimmer 2011. | Permalink | 4 Kommentare

Ein Höhepunkt war sicher der Vortrag von Stefanie Scherzinger über Methoden der Software-Entwicklung, vor allem Agile Softwareentwicklung (Wikipedia), wie sie sie auch selber bei Google anwendet.

Für das Programmierprojekt in der Q11 (meine Beispiele) braucht man tatsächlich irgendeine Art von Entwicklungsmethode. Bei uns war es einfach ein großes schwarzes Brett in Form eines GoogleDoc-Dokuments, auf das jeder Teilnehmer Lese- und Schreibzugriff hat.
Aber die Formulierungen dort waren sehr allgemein: “Datenbank episch perfektionieren: episch angefangen” stand da oder “Bilder colorieren: episch erledigt”, mit dem Namen des aktuellen Bearbeiters.

Eine Möglichkeit der Verbesserung wäre, beim nächsten Mal das Projekt gleich bei Google Code zu hosten. Der Vorteil: Man kann Aufgaben erstellen, kann sie Leuten zuweisen oder diese sich sie nehmen lassen, kann vor allem den Programmcode in verschiedenen Versionen zentral dort sammeln. Nachteil: Ist vielleicht etwas abschreckend für ein kleines Schulprojekt. Außerdem muss das Projekt open source sein – damit habe ich kein Problem, aber vielleicht die Schüler bzw. eigentlich sogar deren Erziehungsberechtigte.

Eine andere äußerst schöne Projektplanungssoftware ist Trello, hier bei Lifehacker kurz beschrieben. Das ist nicht dazu gedacht, Softwareversionen zu verwalten, aber Projekte kann man damit intuitiv und einfach planen:

Man legt ein Projekt an (“board”), zu jedem Projekt können Teammitglieder senkrechte Listen hinzufügen, in meinem Beispiel: Ideen, Aufgaben, Aufgaben in Arbeit, Erledigtes. Jeder Liste kann man Karteikärtchen anfügen, die einen Titel haben, aber dazu noch Abstimmungen, Links, Dateianhänge und Checklisten enthalten können. Den Aufgaben können Teammitglieder zugeordnet sein, man kann Karteikärtchen auf andere Listen verschieben. Alles sehr einfach und übersichtlich. (Nur eine Terminverwaltung ist nicht dabei. Ist vielleicht okay, man kann ja Listen anlegen mit dem Titel “Zu erledigen bis + Datum”.)
Nachteil: eine Anmeldung ist erforderlich. Das hätte ich gerne auf einem eigenen Server laufen.

Ansonsten noch gefunden (via Felix Schaumburg): “Lehrer spähen Schüler im Internet aus”, und zwar indem die Lehrer einer Schule sich unter Pseudonym bei SchülerVZ, Facebook und einem regionalen Chat anmelden. Skandal.

Also, reden muss man schon mal darüber, ob das erlaubt ist. Aber eine Nummer kleiner geht auch. Wo habe ich neulich gelesen, dass ein Gesetzesentwurf vorbereitet wird, der es Firmen verbietet, bei Vorstellungsgesprächen dem Kandidaten in einem sozialen Netzwerk (gemeint: Facebook, aber natürlich überhaupt nicht abgrenzbar, dieser Begriff) nachzuforschen? Kann fast nur Deutschland gewesen sein.

Ähnlich die Argumentation der Sächsischen Zeitung:

Zudem dringen die Lehrer in die Online-Privatsphäre der Jugendlichen ein: Viele Schüler laden persönliche Fotos hoch, lästern über Lehrer und Klassenkameraden, verwenden sogar Schimpfwörter

Der Knackpunkt ist der Begriff “Online-Privatspäre”. Ich habe schon mal darüber geschrieben: Schüler teilen die Welt in “schulisch” und “privat” – alles, was nicht schulisch ist, ist privat. Außerschulische Menschen teilen die Welt in “öffentlich” und “privat”. Es müsste klar sein, dass Internet in der Regel heißt: öffentlich. Wer Informationen privat halten möchte, kann das auch bei Facebook tun – muss sich aber selber darum kümmern.

Andererseits ist allen klar, dass eine Firma keinen Privatdetektiv damit beauftragen darf, bei einer Kandidatin herauszufinden, ob sie eventuell schwanger ist. Und mal schnell bei Facebook geschaut, ob da eine Schwangerschaft öffentlich gemacht wurde? Hm. Ich sehe das Problem. Deshalb stand in dem Gesetzesvorschlag – wo war das gleich wieder, zefix – ja auch, dass nur auf Erlaubnis des Angestellten auf bestimmten Webseiten nach ihm gesucht werden dürfte. Viele Leute wollen ja explizit, dass ihr Web-Profil gefunden wird.

Unrealistisch ist so ein Gesetz allemal.

Zurück zu den Lehrern: Ich würde mich wehren gegen eine Dienstanweisung, meinen Schülern bei Facebook hinterherzuschnüffeln. (Geplant: Frankreich.) In meiner Eigenverantwortung als Pädagoge: will ich bei Facebook machen dürfen, was a) nicht allzu verboten ist, b) nicht gegen meine pädagogischen Aufgaben verstößt und c) mir sinnvoll erscheint. Theoretisch muss ja jeder bei Facebook mit seinem echten Namen arbeiten. Aber schon sehr theoretisch.

Quelle: Herr Rau aus dem Lehrerzimmer 2011. | Permalink | 8 Kommentare

Inzwischen ist aus einem kurzen Eintrag ein langer geworden, und er erklärt nicht mehr das, was er am Anfang sollte. Ich sollte ihn wirklich kürzen und neu strukturieren. Der Unterschied zwischen Profi und Amateur: ich werd’s einfach nicht tun. Trotzdem, für Informatik – Repräsentation von Information – wäre das schon praktisch.

1. Einführung

Wenn man am Computer etwas schreibt – im Textverarbeitungsprogramm oder im Blog – ist ein “a” nie nur ein “a”. Man drückt zwar die entsprechende Taste auf der Tastatur und ein “a” erscheint. Wenn man das dann speichert, wird ein “a” gespeichert. Sollte man meinen, aber das ist nicht so. Das hat jeder schon mal gemerkt, dem es die Umlaute beim Speichern verhagelt hat, oder der eine Mail kriegt, in der solche Sätze auftauchen:

ich w�rde es begr��en, wenn du mir nicht so etwas schreiben w�rdest

oder in der einem

Viele Grüße

gewünscht werden. (Sieht man auch immer wieder mal bei Track- oder Pingbacks in Blogs.)

Wer ist da schuld, was ist da passiert, wie kann man das vermeiden?

Einen ausgezeichneten Überblick zu diesem Thema gibt “The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!)”. Ich habe mich für diesen Artikel sehr bei ihm bedient – dort steht das alles noch viel ausführlicher und interessanter.

Hier eine Kurzfassung und ein paar wichtige Begriffe.

2. ASCII

Zeichen werden wie alles im Computer durch Zahlen repräsentiert. Ein früher Standard dazu hieß ASCII (Wikipedia). Nach diesem Kodierungssystem werden für jedes Zeichen 7 bit reserviert, was einen Vorrat von 128 möglichen Zeichen ermöglicht. Die Zeichen mit den Nummern 0 bis 31 sind Sonderfälle, sogenannte nicht druckbare Zeichen, aber von Nummer 32 bis 126 sehen die Zeichen vertraut aus:

 !"#$%&'()*+,-./0123456789:;<=>?   (Nr. 32-63)
@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_   (Nr. 64-95)
`abcdefghijklmnopqrstuvwxyz{|}~    (Nr. 96-126)

Das Zeichen mit der Nummer 32 ist das Leerzeichen, das große A hat die Nummer 65, die Tilde ist die Nummer 126. (Die Nummer 127, das letzte der 128 ASCII-Zeichen, ist wieder ein Sonderfall.)

Gespeichert wird ein Wort, zum Beispiel “Abel”, als Folge der ASCII-Zeichen-Nummern: 65-98-101-108.

Allerdings fehlen bei diesem System europäische Sonderzeichen – Buchstaben mit Umlauten und Akzenten und noch exotischeres Zeug. Zur Lösung gab es zwei Möglichkeiten: Entweder man schafft einen eigenen europäischen ASCII-Dialekt, bei dem die Nummer 93 eben nicht für “]” steht, sondern für “Ü”. Dann können auch Deutsche wunderbar schreiben, müssen dafür aber auf eckige Klammern verzichten. Außerdem müssen sich Sender und Empfänger von Texten (und jedes Textverarbeitungsprogramm für sich) darüber verständigen, ob ein Dokument oder auch nur ein Wort in amerikanischem oder europäischem ASCII zu lesen sein soll. Sonst liest der Amerikaner versehentlich “]bel” statt “Übel”, wenn er eine europäische Datei oder Mail öffnet. Gespeichert wird das Wort ja als Folge der ASCII-Nummern der einzelnen Zeichen, also “93-98-101-108″, und ob das jetzt “]bel” oder “Übel” heißen soll, das kann der Computer nicht so einfach wissen, wenn man ihm es nicht sagt. Und ein Franzose oder Däne braucht wieder einen eigenen ASCII-Dialekt.

3. ISO 8859-1

Die andere Lösung war die, für jedes Zeichen 8 bit zu reservieren statt 7. Damit hat man immerhin einen Vorrat von 256 Zeichen zur Verfügung, muss also nicht zugunsten eines “Ü” auf ein “]” verzichten und kann beides benutzen. Die ersten 128 Zeichen blieben dabei parallel zu ASCII. Das ist praktisch, weil die in 7-bit-ASCII gespeicherten Dateien dann genauso gut von einem 8-bit-System gelesen werden können, ohne dass man irgendetwas umstellen muss.

Allerdings gibt es auch wieder verschiedene 8-bit-Varianten. MS-DOS hatte sein eigenes System, Windows wieder ein anderes. (Deshalb sehen die Umlaute in unter MS-DOS erzeugten Dateien falsch aus, wenn man die Dateien als übliche Windowsdateien betrachtet.)

Verbreitet ist heute ISO 8859-1 (“Latin 1″, Wikipedia). Da sind weiterhin für jedes Zeichen 8 bit reserviert; es gibt also 256 Zeichen, die ersten 128 entsprechen dabei ASCII – das ist praktisch. Man wird also weiterhin “65-98-101-108″ als “Abel” lesen. Zu den anderen Zeichen gehören europäische Umlaute, Zeichen mit Akzent, skandinavischen Zeichen, und andere. Aber auch nicht alle: das Euro-Zeichen gehört nicht dazu. Aber auch da gibt es Aushilfen (etwa ISO 8859-15), so dass ISO 8859-1 ausreicht für (laut Wikipedia):

Afrikaans, Albanisch, Baskisch, Dänisch, Deutsch, Englisch, Färöisch, Finnisch, Französisch, Irisches Gälisch, Isländisch, Italienisch, Katalanisch, Niederländisch, Norwegisch, Portugiesisch, Rätoromanisch, Schottisches Gälisch, Schwedisch, Spanisch, Swahili und Wallonisch.

Kyrillisch geht mit ISO 8859-5, Mitteleuropäisch (darunter Ungarisch, Tschechisch, Polnisch) mit ISO 8859-2.

Viele polnische Seiten sind also, vermuten wir erst einmal, in ISO 8859-2 kodiert. Da ist das Zeichen Nummer 163 das hier: “Ł”. (Wird die gespeicherte Seite als ISO 8859-1 interpretiert, würde an derselben Stelle das Zeichen mit der ISO-Nummer 163 aber so dargestellt werden: “£”.)
Man kann das schnell mal ausprobieren: in jedem Browser kann man von Hand die Kodierung einstellen, in Firefox unter “Ansicht/Zeichenkodierung”. Da kann man dieselbe Seite mal so betrachten, als sie in ISO 8859-2 geschrieben, mal als sei sie ISO 8859-1. (Beispiel: polnische Seite in ISO 8859-2 kodiert.)

Exkurs:

Aber woher weiß der Browser denn am Anfang, wie er die Seite darstellen soll. Ob der Seitenersteller ein “Ł” oder ein “£” darstellen will? Die Kurzfassung: im schlimmsten Fall rät er, aber normalerweise steht im Kopf einer sauber geschriebenen HTML-Seite, welche Kodierung der Browser zur Darstellung nehmen soll, etwa so:

<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">

(Bis zu dieser Stelle weiß der Browser aber noch nicht, wie die Seite kodiert ist, muss also stillschweigend davon ausgehen, dass er wenigsten diese Stelle schon mal richtig dekodiert hat. Interessante Frage, das.)

Quizfrage

Wie habe ich es denn geschafft, sowohl das Zeichen “Ł” als auch ein “£” auf dieselbe Seite zu kriegen? Beide Zeichen sind doch die Nummer 163? Das geht mit reinem ISO 8859-1 tatsächlich nicht, und mit reinem ISO 8859-2 ebensowenig. Eine Lösung bietet HTML: da gibt es die Möglichkeit, Zeichen direkt auszuwählen:

• Ł wird in HTML immer so dargestellt: Ł
• £ wird in HTML immer so dargestellt: £
• Ä wird in HTML immer so dargestellt: Ä
• ö wird in HTML immer so dargestellt: ö

Das funktioniert immer und unabhängig von der Kodierung, jedenfalls solange das & und die folgenden Zeichen richtig erkannt werden, die deshalb alle aus dem gemeinsamen Zeichenvorrat kommen. Für viele Sonderzeichen gibt es in HTML solche festen Zeichen, hier eine Liste davon.

Das ist aber nicht die einzige Lösung für dieses Problem.

4. Unicode

Meine eigene Seite ist jetzt aber gar nicht mal in ISO 8859-1 kodiert, und die meisten polnischen Seiten, die ich gefunden habe, sind ebensowenig in ISO 8859-2 kodiert, sondern in wieder etwas anderem: UTF-8.

Um das zu erklären, muss ich etwas zu Unicode sagen. Unicode geht die Sache mit den Zeichen von einer anderen Seite aus an: jedes Zeichen auf der Welt kriegt eine eindeutige Unicode-Nummer, einen sogenannten code point. Das sind zur Zeit laut Wikipedia über 109.000 Zeichen aus 93 Alphabeten, einschließlich Linear B, Phönizisch und I-Ging-Hexagramme. Die Zeichen des Voynich-Manuskripts und Tengwar (Tolkiens Elbenschrift) sind aber noch dabei; für letzteres läuft gerade ein Aufnahmeantrag.
Hier kann man sie sich alle anschauen. Platz ist im Unicode-System für mehr als eine Million Zeichen.

Das ist natürlich eine sprachwissenschaftlich und politisch nicht uninteressante Sache: was ist ein Buchstabe, was gehört zu einem Alphabet? Unicode wird deshalb auch kritisiert (Wikipedia deutsch, mehr bei englisch). Trotzdem ist das mit dem Unicode eine praktische Sache: jeder Buchstabe kriegt eine platonische Entsprechung als code point.

Der Buchstabe A des lateinischen Alphabets hat zum Beispiel den code point U+0041. Die Zahl ist dabei im Hexadezimalsystem zu lesen, 0041 entspricht im Dezimalsystem der Zahl 65. Wie schon damals im ASCII-Code… denn ja, die code points der lateinischen Buchstaben ohne diakritische Zeichen entsprechen den alten ASCII-Nummern.

Das Zeichen U+03B2 sieht bei mir im Browser so aus: β, das Zeichen U+00DF so: ß. In manchen Schriftarten mögen die Zeichen sehr ähnlich sein, aber die Codierung macht klar: das eine ist ein beta, das andere ein sz/scharfes s. Wenn für das Unicode-Zeichen in meinem Browser kein Zeichensatz vorgesehen ist, sieht man stattdessen so etwas Komisches wie hier bei U+10900, dem ersten Buchstaben des phönizischen Alphabets: 𐤀. Zur Darstellung müsste ich mir dann wohl mal einen passenden Zeichensatz herunterladen.

(Fußnote: Zeichensätze auch für exotischere Unicode-Codepoints findet man leicht. Code2000 bzw. desssen Nachfolger – Wikipedia dazu – werden wohl nicht mehr weiter aktualisiert, versuchen aber, möglichst viele Zeichen darzustellen.)

UTF-8

Unicode ist allerdings erst mal nur ein Verzeichnis aller Zeichen und eine eindeutige Zuweisung eines code points. Wie man das dann speichert, ist wieder eine andere Frage, unsere alte Frage von oben, nur dass ich halt nicht “A” einer Zahl zuordnen muss (z.B. A=>65), sondern “U+0041″ (z.B. U+0041=>65).

Da gibt es UTF-32, bei dem für jedes Zeichen 32 bit (4 Byte) reserviert werden. Damit kann man für jedes Zeichen aus einem Pool von 2³² Buchstaben auswählen, also 4 294 967 296. Das reicht für alle Unicode-Zeichen, aber 32 bit pro Zeichen sind eine ganze Menge Platzverschwendung. Viel verbreiteter ist dagegen UTF-8: da sind die häufigsten Zeichen mit 8 bit kodiert – wir ahnen es schon, das sind unsere alten Freunde aus dem 7-bit-ASCII-Zeichensatz, nämlich die Unicode-Zeichen 0-127. Die weniger häufigen Zeichen sind dann im 16-bit-Bereich kodiert, darunter die Umlaute. Und die selteneren Zeichen sind bei UTF-8 mit bis zu vier Byte kodiert. Das heißt, dass ein Dokument aus hundert seltenen Zeichen viermal so viel Speicherplatz benötigen kann wie eines aus häufigen Zeichen. Selten jedenfalls aus amerikanischer Sicht.

(Fußnote: Hier sieht man die verschiedenen Kodierungsmöglichkeiten etwa von U+10900.)

5. MySQL-Datenbank von ISO auf UTF-8 umstellen, und wie ich überhaupt auf diesen Kram komme

Das Blogsystem Wordpress speichert die Beiträge nicht als Datei auf einer Festplatte ab, sondern in einer Datenbank. Aber auch dazu muss man wissen, welche Kodierung zum Speichern verwendet wird – damit man die gleiche Kodierung zum Lesen verwenden kann. Wenn ich ein Dokument in ISO 8859-1 in der Datenbank speichere und danach beim Herauslesen als UTF-8 interpretiere, kriege ich Schwierigkeiten bei den Umlauten und Sonderzeichen, andersrum natürlich ebenso.

Standardmäßig war früher bei Wordpress-Installationen ISO 8859-1 als Kodierung für die Datenbank eingestellt. Das heißt, wenn ich ein “A” getippt habe, wurde das letztendlich als 65 gespeichert (hexadezimal: 41), wenn ich ein “ö” getippt habe, dann wurde das letztendlich als 246 gespeichert (hexadezimal: F6). Wenn ich den in der Datenbank gespeicherten Eintrag dann wieder lese, wird die 65 als “A” interpretiert (in ISO, aber auch in UTF-8 und in ASCII), die 246 wird als “ö” interpretiert – aber eben nur in ISO, nicht in UTF-8, wo ein “ö” durch 50070 repräsentiert wird (hexadezimal: c396) und 246 überhaupt nicht definiert ist. Dann werden stattdessen kleine Rauten mit Fragezeichen darin angezeigt.

(MySQL-Experten mögen mir die grobe Vereinfachung verzeihen.)

Inzwischen ist die Standard-Kodierung bei Wordpress-Installationen UTF-8. Und das hat bei meinem ISO-Wordpress zu Problemen geführt. Ich weiß auch nicht, woran das liegt – aber immer wieder mal ist ein Blogbeitrag beim Speichern falsch kodiert worden. Alle Umlaute hat’s mir verhagelt. Das war sehr lästig. Auf dieser Tabelle sieht man links das geschriebene Zeichen (ISO), rechts das, was gespeichert wurde (nämlich fälschlicherweise als UTF). Ich tippte ein “ü”, das nach ISO-Kodierung letztendlich als (hexadezimal) fc gespeichert werden müsste, tatsächlich wurde es aber nach UTF-Kodierung letzendlich als (hexadezimal) c3bc gespeichert – und aus diesen zwei Byte werden, wenn man das dann als ISO liest, eben à und ¼.

Also wollte ich meine Datenbank von ISO auf UTF-8 umstellen. Das ist aber gar nicht so einfach. Es gibt eine Reihe von Plugins dazu. Ich habe einige davon ausprobiert; sie funktionieren alle nicht. Das steht auch so bei Wordpress selber, wo diese Seite eine Anleitung dazu gibt, wie man die Kodierung der Datenbank umstellt:

https://codex.wordpress.org/Converting_Database_Character_Sets

Und die Seite ist gespickt mit: “Tu’s nicht” und “Es ist schwierig”, und das ist tatsächlich auch knifflig. Sehr umständlich. Manche Spalten mancher Tabellen müssen in ein exotischeres Format kopiert werden, und von diesem wieder zurück ins andere Format kopiert werden. Aber nicht alle, und nicht alle gleich. Ich würde die Finger davon lassen.

Es geht nämlich auch einfacher, jedenfalls für schlichte Wordpressbenutzer wie mich.

Deshalb hier meine schlichte Lösung für das Konvertieren einer Datenbank von ISO 8859-1 nach UTF-8:

1. Eine zweite, leere Datenbank anlegen. In die kommt später die UTF-8-Version, die Original-DB lassen wir unangetastet.
2. Die Originaldatenbank als SQL-Dump herunterladen.
3. Der SQL-Dump ist eine – möglicherweise lange – Textdatei im ISO-Format. Das war ja unser Problem. Diese ISO-Datei mit einem geeigneten Textverarbeitungsprogramm öffnen und als Unicode-Datei speichern.
   – Das geht bei Windows einfach mit WordPad: “Speichern unter”, Format “Unicode-Textdokument”. Das wird dann übrigens wohl eine UTF-16-Datei, mit zwei Byte pro Zeichen. Vielleicht geht das auch mit Word oder Writer oder Notepad++. Eine Schwierigkeit ist allerdings, dass man nicht unbedingt sieht, was da wirklich im Text steht, da ein ü sinnvollerweise immer als ü gezeigt wird, egal ob es tatsächlich so aussieht: ü (UTF) oder so: ü (ISO). Wobei “tatsächlich” natürlich das falsche Wort ist.
4. In der neu entstandenen Datei sollten jetzt alle Umlaute so komisch aussehen, nämlich durch zwei andere Zeichen repräsentiert – wenn ich die Datei nicht als Unicode-Datei betrachte.
5. Diesen neuen SQL-Dump jetzt in die frische Datenbank hochladen. Zuvor mit Suchen/Ersetzen schauen, ob beim Anlegen der Tabellen in den SQL-Befehlen als Zeichensatz oder Kollation ISO/Latin 1 angegeben ist; das muss dann natürlich raus. (Hier gab es bei mir Schwierigkeiten. Erstens, weil die Datei recht groß ist. Zweitens, einfach so. Aber der Download mit phpMyAdmin und der Upload mit HeidiSQL danach hat geklappt.)
6. Fertig. Die config.php mit den Zugangsdaten zur zweiten Datenbank versehen und schauen, ob das Blog mit der neuen Datenbank funktioniert. Dabei muss man Wordpress in den Einstellungen sagen, dass ab jetzt UTF-8 gilt und nicht mehr ISO. Dann – aber erst dann – kann man die ursprüngliche Datenbank löschen.

Das darf man alles bestimmt nicht. Und es führt zu grässlichen Datenbanken, Greueln im Auge des Herrn. Furchtbaren Hybriden oder so etwas. Ausprobieren auf eigene Gefahr, und ein paar SQL-Kenntnisse sind sicher hilfreich. Wer viel SQL kann, der wird sicher laut lachen und sagen, dass das alles doch viel einfacher geht.
Aber was soll ich sagen: bei mir funktioniert’s.

Anhang, nachträglich:
Mit einem Hex(adezimal)-Editor kann man sich anschauen, wie auf der Festplatte gespeicherte Dateien wirklich aussehen. (Na ja, wirklicher jedenfalls.) Hier zwei Textdateien in einem Hex-Editor dargestellt, die nur aus dem Text “Das ist ein Übel.” bestehen. Entschuldigung, ich wollte ein großes Ü drin haben.

Die obere Datei ist in Windows-1225 gespeichert, das ISO-8859-1 sehr ähnlich ist. Das Zeichen “D” ist durch die Zahl 44 kodiert, das Zeichen “a” durch “61″ (jeweils im Hexadezimalsystem). Pro Zeichen ein Byte. Der Editor ist so nett, rechts daneben gleich die gängige Entsprechung der Byte-Zahl anzuzeigen, so dass man nicht nur die tatsächlich gespeicherten Bytes sieht, sondern auch einen Hinweis darauf, wofür sie vermutlich stehen.
Die untere Datei ist in Unicode-16 gespeichert. Da sind für jedes Zeichen 2 Byte (16 bit) reserviert. Das Zeichen “D” bzw. der Unicode-Codepoint U+0044 ist durch die zwei Zahlen “44″ und “00″ repräsentiert. Warum zwei Bytes/Zahlen? Weil das bei UTF-16 immer so ist. Aber welche Zahl kommt zuerst, die 44 oder die 00? Im Prinzip geht beides, und es gibt auch beide Varianten – die eine heißt big-endian und die andere little-endian. Um sicher zu gehen, dass man weiß, welche Version benutzt wird, steht gerne mal am Anfang einer UTF-16-Datei “FFFE” beziehunsgweise eben “FEFF”. Und ja, big-endian und little-endian stammen aus Jonathan Swifts Gulliver’s Travels.

(In UTF-8 wäre das “D” nur durch die Ein-Byte-Zahl 44 kodiert, das “Ü” dagegen durch die zwei Bytes c3 und 9d. Und die obere Datei braucht nur halb so viel Speicherplatz wie die untere.)

Quelle: Herr Rau aus dem Lehrerzimmer 2011. | Permalink | 6 Kommentare