Bei dem hier betrachteten Traveling-Salesman-Problem geht es darum, eine möglichst kostengünstige Rundreise durch eine gegebene Menge an “Städten” (ich werde bei der Terminologie “Stadt” bleiben) zu finden, wobei jede Stadt genau 1 Mal besucht werden muss. Jede Wegstrecke zwischen 2 Städten ist mit bestimmten Reisekosten verbunden. In dem von mir gemeinten Fall des metrischen TSP entsprechen die Reisekosten genau der Luftlinie zwischen den beiden Städten. Daher habe ich die Städte der Einfachheit halber als Punkte in der Ebene modelliert (mit einer X- und einer Y-Koordinate), womit bereits erste Experimente möglich sind.

Phase 1: Reduktion auf den Trivialfall des TSP

TSP - Trivialfall mit nur 3 Städten

Mein Algorithmus greift darauf zurück, dass das Rundreiseproblem für 3 Städte trivial ist, weil es nur 1 mögliche Rundreise durch 3 Städte gibt (siehe Grafik auf der rechten Seite).

Bei 1-3 Städten kann der Algorithmus daher direkt die Lösung zurückgeben, weil sie offensichtlich ist.

Bei mehr als 3 Städten arbeitet der Algorithmus in 2 Phasen.

In der 1. Phase werden die gegebenen Städte solange gefaltet, bis nur noch 3 Städte übrig sind.

Es werden jeweils 2 Städte gefaltet. Das sieht so aus, dass eine neue fiktive Stadt erzeugt wird, deren Koordinate gleich dem Mittelpunkt/Zentrum der 2 gefalteten Städte ist. Die 2 gefalteten Städte werden dann durch die neue fiktive Stadt ersetzt, wobei sich die fiktive Stadt ihre “Vorbilder” (“Kind-Städte”) merkt. Dadurch wird das Falten zugleich umkehrbar.

Eine naive Implementierung sieht zum Beispiel so aus, dass in jedem Schritt zufällig eine Stadt ausgewählt und ihr nächster Nachbar berechnet wird. Diese beiden Städte werden dann gefaltet. Der Vorgang wird so lange wiederholt, bis wie gesagt nur noch 3 Städte übrig sind. Fiktive Städte können genauso gefaltet werden wie die Ursprungs-Städte. (Dadurch ergibt sich je nach Anzahl der Städte eine beliebig tiefe “Verschachtelung”.)

Phase 2: Entfalten der Städte mit optimaler Integration der Kind-Städte

Nach der 1. Phase sind wir also beim Trivialfall mit 3 Städten angekommen. Das ist auch schon unsere vorläufige Lösung bzw. die vorläufige Rundreise.

In der 2. Phase werden die fiktiven Städte wieder entfaltet, wobei die vorläufige Rundreise bei jedem Schritt erhalten wird.

TSP - Fiktive Stadt (blau) mit Kind-Städten (rot) in einer vorläufigen Rundreise zu Beginn von Phase 2

Betrachten wir die Grafik auf der rechten Seite. Nehmen wir an die beiden rot markierten Städte seien die Kind-Städte der blau markierten fiktiven Stadt. (Wie man auch gut sehen kann befindet sich die blaue Stadt genau im Zentrum ihrer beiden Kind-Städte.)

Wenn die fiktive Stadt nun in Phase 2 durch ihre Kinder ersetzt wird, dann gibt es genau 2 Möglichkeiten, wie man die beiden Kind-Städte in die gegebene Rundreise integrieren kann. Dazu muss man sich die blaue Stadt wegdenken, denn diese existiert dann ja nicht mehr.

TSP - Entfalten mit beiden Integrationsmöglichkeiten (grün = die bessere Variante)

Auf dem nächsten Bild sind die beiden Möglichkeiten eingezeichnet. Die grüne Variante ist offensichtlich die kürzere und damit auch die bessere Wahl.

Halten wir fest: Beim Entfalten muss der Algorithmus nach jedem Schritt entscheiden, wie er die neuen Städte in die bestehende Rundreise integriert. Dabei gilt es zwischen genau 2 Alternativen zu wählen… und das ist relativ leicht.

Phase 2 endet, wenn keine fiktiven Städte mehr übrig sind, die noch entfaltet werden könnten. Die Rundreise ist damit “fertig” und kann vom Algorithmus zurückgegeben werden.

Namensgebung: RFA

Weil der Algorithmus auf dem Falten & Entfalten der Städte beruht taufe ich ihn RFA: Rekursiver-Falt-Algorithmus bzw. recursive-fold-algorithm.

Beispiele

TSP - Rundreise mit 100 Städten

TSP - Rundreise mit 500 Städten

Die Rundreise auf der linken Seite besteht aus 100 Städten und wurde im Bruchteil einer Sekunde berechnet.

Die Rundreise auf der rechten Seite besteht aus 500 Städten und wurde in nur etwas mehr als 1 Sekunde berechnet.

Wie man an den beiden Beispielen auch gut sehen kann arbeitet der RFA keineswegs optimal, denn an der einen oder anderen Stelle überschneiden sich die Rundreisen sogar (das sicherste Zeichen dafür, dass eine Lösung suboptimal ist).

Nichtsdestotrotz handelt es sich in beiden Fällen um sehr gute Näherungslösungen, die zudem in kürzester Zeit berechnet wurden.

Performanz & Güte des RFA

Der RFA befindet sich, was die Laufzeit betrifft, in der Komplexitätsklasse O(n²)¹ (Faustregel: Verdoppelt man die Anzahl der Städte, so braucht der Algorithmus 4 Mal so lang). Die Speicherkomplexität liegt dagegen bei O(n).

In allen mir bekannten Fällen stellten die vom Algorithmus erzeugten Rundreisen eine gute bis sehr gute Näherung an die optimale Lösung dar.

Dank seiner überragend hohen Geschwindigkeit eignet sich der RFA in meinen Augen besonders für die Berechnung von Näherungslösungen bei sehr großen Probleminstanzen mit vielen tausenden Städten. Für eine Rundreise durch 10000 Städte *klick* benötigt meine eigene, sehr simple Python-Implementierung beispielsweise ca. 7 Minuten und 20 Sekunden. Gemessen an der Qualität der erhaltenen Näherungslösung ist das ziemlich schnell.

Ausgehend von dieser Näherungslösung kann die Rundreise dann Stück für Stück durch weitere Algorithmen dem Optimum näher gebracht werden.

Zum Vergleich möchte ich außerdem an meinen evolutionären Algorithmus für das TSP erinnern (habe ich damals ebenfalls in Python implementiert). Dieser brauchte bei Städtezahlen jenseits der 100 bereits ewig für eine Näherungslösung. (Für weitere Details siehe Projekte -> Lernleistung.)

Testlauf mit TSP-Instanzen der TSPLIB

Für TSP – Testläufe gibt es die sogenannte TSPLIB. Sie enthält dutzende von TSP-Instanzen mit den unterschiedlichsten Eigenschaften. Von kleinen bis sehr großen Städte-Zahlen ist alles dabei. Das besondere ist, dass in der TSPLIB in vielen Fällen die optimale Lösung bereits enthalten ist. Damit kann man die Ergebnisse von TSP-Algorithmen überprüfen oder ihre Güte in der Praxis abschätzen.

Bisher habe ich meinen Algorithmus zwar hoch gelobt, aber ich bin glaubwürdige Aussagen schuldig geblieben. Daher habe ich ihn auf einige metrische TSP-Instanzen der TSPLIB angesetzt (Quelle):

Im Schnitt sind die von meinem Algorithmus berechneten Rundreisen 119.14% länger als die jeweilige optimale Rundreise.

Damit schlägt sich der RFA bei deutlich besserer Laufzeitkomplexität mindestens genausogut wie die Christofides-Heuristik bzw. der Christofides-Näherungsalgorithmus (mit einer Laufzeitkomplexität von O(n³)). Die Christofides-Heuristik hat nämlich für metrische Rundreiseprobleme eine feste Gütegarantie von 50%, d.h. sie garantiert einen Faktor von höchstens 150%, d.h. die Lösungen sind maximal 1,5fach so lang wie die optimale Lösung. (Sie ist damit der bisher beste Algorithmus mit einer festen Gütegarantie.)

Zwar kann ich (noch?) nicht beweisen, dass der RFA ebenfalls über eine Gütegarantie verfügt. Aber in der Praxis zeigt sich, dass der Faktor deutlich unter 150% bleibt.

Übertragbarkeit auf nicht-metrische Rundreiseprobleme

Der RFA ist zwar auch übertragbar auf nicht-metrische Rundreiseprobleme (das Falten von 2 “Städten” muss man dann entsprechend neu erfinden), allerdings erhoffe ich mir davon keine so guten Resultate. Der RFA beruht nunmal hauptsächlich auf der Dreiecksungleichung (denn für je 2 “Städte” muss eine Art fiktive Stadt im Zentrum der 2 Städte konstruierbar sein). Je stärker diese verletzt wird, desto schlechter werden die Ergebnisse vermutlich sein. Daher eignet sich der RFA auch nur bedingt für asymmetrische TSP-Instanzen (also wenn die Reisekosten für A -> B nicht immer auch den Reisekosten B -> A entsprechen (bspw. bergauf vs. bergab)).

Ein dahingehender Test meinerseits steht aber noch aus.

Verbesserungsmöglichkeiten

Abgesehen von der Art der Implementierung (bis jetzt nur in Python; viel schneller wäre C++) kann man den Algorithmus selbst, d.h. seine Laufzeitkomplexität, definitiv noch weiter verbessern.

Ich sehe großen Spielraum in Phase 1 beim Falten der Städte. Die wesentliche Rechenleistung in Phase 1 besteht darin, zu einer gegebenen Stadt ihren nächsten Nachbarn zu finden. Das kann man deutlich beschleunigen, indem man die Städte zu Beginn von Phase 1 partitioniert (die “Landkarte” wird auf bestimmte Weise in Quadrate aufgeteilt). Dadurch muss man beim Suchen des nächsten Nachbars nicht mehr alle Städte berücksichtigen, sondern nur noch diejenigen Städte, die sich in den umliegenden/benachbarten Partitionen befinden. Beim Falten von 2 Städten muss dann natürlich sichergestellt werden, dass die neu erzeugte fiktive Stadt ihrerseits in die korrekte Partition eingeordnet wird.

Die Güte des Algorithmus kann man womöglich deutlich verbessern, indem man eine Methode entwickelt, die auf intelligente Weise die Städte faltet. In meiner naiven Implementierung geschieht die Auswahl der zu faltenden Städte nämlich zufällig. An dieser Stelle kann man gewiss noch Verbesserungen erzielen, indem man die Reihenfolge des Faltens nicht nur dem Zufall überlässt.

In Phase 2 sehe ich wenig Potenzial zur Verbesserung, weil das Entfalten – wie beschrieben – quasi optimal erfolgt. Die Reihenfolge des Entfaltens spielt jedoch mMn. wenigstens eine untergeordnete Rolle, deshalb behalte ich mir eine nähere Untersuchung von Phase 2 vor.

Zusammenfassung

Der von mir entwickelte Algorithmus für das metrische TSP hat eine Laufzeitkomplexität von O(n²) und eine Speicherkomplexität von O(n). Weil er auf dem Falten & Entfalten der Städte beruht und das TSP dabei (zumindest zwischenzeitlich) auf den Trivialfall reduziert, nenne ich ihn RFA: Rekursiver-Falt-Algorithmus.

Obwohl meine Python-Implementierung ausgesprochen naiv vorgeht und ich mir kaum Mühe gegeben habe effizienten Code zu schreiben, bewältigt sie TSP-Instanzen der TSPLIB in sehr kurzer Zeit. Die Länge der dabei gefundenen Lösungen lag im Durchschnitt nur ca. 19% über der jeweils optimalen Lösung (also Faktor 119%; der höchste Faktor betrug 130%).

Daher kann der RFA durchaus mit der Christofides-Heuristik – der bisher beste Algorithmus mit einer festen Gütegarantie für das metrische TSP – konkurrieren, nicht zuletzt weil diese eine deutlich schlechtere Laufzeitkomplexität von O(n³) besitzt (und überdies auch noch sehr viel komplizierter ist). Eventuell kann ich beweisen, dass auch für den RFA eine feste Gütegarantie gilt. In der Praxis schlägt er sich auf alle Fälle sehr gut.

Der RFA ist zwar grundsätzlich auch übertragbar auf nicht-metrische Rundreiseprobleme, allerdings hängt die Güte des RFA sehr wahrscheinlich von der Dreiecksungleichung ab. Je stärker diese verletzt wird, desto schlechter werden die Ergebnisse vermutlich sein.

Dank seiner überragenden Geschwindigkeit eignet sich der Algorithmus in meinen Augen besonders für die Berechnung von Näherungslösungen für sehr große TSP-Instanzen mit vielen Tausend Städten.

Download meiner Python-Implementierung

RFA_demo.zip (2.2 MB)

Der Quelltext befindet sich im Ordner “src” (die Dateien sind UTF-8-kodiert). Die im Artikel verwendeten TSPLIB-Challenges (und viele weitere) befinden sich im Ordner “TSPLIB”.

Die auszuführende Datei ist src/RFA_demo.py. Ich habe Python 2.6 verwendet, es sollte aber auch mit Python 2.5 laufen.

In der Datei RFA_demo.py kann man auch einige Einstellungen verändern. Ich habe die entsprechenden Stellen deutlich hervorgehoben und jede Einstellung in Deutsch beschrieben (ansonsten ist alles in Englisch gehalten). Sogar Laien haben also eine faire Chance die Demonstration auf ihrem PC auszuführen.

Viel Spaß damit!

• Der Backup-Vorgang ist durchschaubar bzw. leicht nachvollziehbar, weil es sich um einen gewöhnlichen Packer handelt und nicht um eine spezielle Backup-Software, bei der man so genau gar nicht weiß, wie sie arbeitet (das kann ich persönlich gar nicht leiden).
• RAR-Dateien kann man (im Gegensatz zu den meisten Backup-Containern kommerzieller Backup-Software, bspw. Acronis True Image) nahezu auf jeder Plattform entpacken, weil der Entpack-Algorithmus öffentlich verfügbar ist. Das gilt natürlich auch für ZIP, 7zip und die meisten anderen Archiv-Formate.
• Das RAR-Format unterstützt sogenannte recovery records (Wiederherstellungsinformationen). Kleinere Schäden an der Backup-Datei (Beispiel: ein paar Sektoren auf der Festplatte spielen verrückt) können damit behoben werden.
• Die Verschlüsselung von RAR-Dateien erfolgt – wenn gewünscht – mit AES-128. Dieser Standard gilt als sicher.

Im Folgenden zeige ich mit welchen Einstellungen man WinRAR für Backups optimiert.

Einstellungen: “Allgemein”

1. Ziel-Datei: In welcher Archivdatei sollen die Dateien gesichert werden?
2. Update-Modus: Das Backup-Archiv soll mit den Quelldaten synchronisiert werden. Das bedeutet, dass neue Dateien hinzugefügt, geänderte Dateien erneuert und gelöschte Dateien auch im Backup gelöscht werden. Hierdurch werden außerdem das 2. und alle folgenden Backups stark beschleunigt, weil quasi-inkrementelle Backups gemacht werden.
3. Kompressions-Methode: Damit das Komprimieren nicht zu viel Zeit in Anspruch nimmt stellen wir die Kompression auf eine schwächere aber schnellere Stufe.
4. Authentizitätsinformationen hinzufügen: Fügt bei der Erstellung des Archivs nochmal einige allgemeine Daten wie Archivname etc. in das Archiv ein. Diese werden beim späteren Öffnen des Archivs geprüft, um grobe Manipulationen zu verhindern. Bietet zwar wenig Sicherheit, kostet aber auch nichts.
5. Wiederherstellungs-Informationen hinzufügen: Hier handelt es sich um den oben beschriebenen recovery record. Unter Erweitert kann man dieses Feature genauer konfigurieren.

Einstellungen: “Erweitert”

Einstellungen, die sehr nützlich sind, aber dem persönlichen Gutdünken obliegen, habe ich blau eingerahmt.

Zu den roten Markierungen:

1. Datenströme speichern: Sehr wichtig, wenn NTFS als Dateisystem eingesetzt wird. Einige Applikationen legen in zusätzlichen NTFS-Dateiströmen einige Informationen ab, die nicht zu den Dateiinhalten selbt gehören, aber mit den jeweiligen Dateien verknüpft sind. Es handelt sich quasi um eine Art von Meta-Informationen, die ohne diese Einstellungen verlorengehen würden.
2. Wiederherstellungs-Informationen: Hiermit legt man fest, wie groß der prozentuale Anteil des recovery records am Archiv sein soll. 2-5% halte ich für angemessen. Standard ist übrigens 1%.

Zu den “Volumen”-Einstellungen: Diese sind nur nutzbar, wenn man das Backup-Archiv in mehrere Teilarchive aufsplittet. Dazu muss man eine Volumengröße unter “Allgemein” angeben.
Jedes “Wiederherstellungs-Volumen” kann genau 1 Original-Volumen wiederherstellen, sogar dann, wenn dieses komplett verloren gegangen ist. Angenommen man hat 30 Teil-Archive (“Volumen”) und 3 Wiederherstellungsvolumen, dann dürfen bis zu 3 Volumen verlorengehen bzw. beschädigt werden. Im Zweifel lohnt sich hier ein Blick in die WinRAR-Hilfe.

Einstellungen: “Dateien”

Der wahrscheinlich wichtigste Teil am Backup: Die zu sichernden Dateien bzw. Verzeichnisse müssen ausgewählt werden.

Hier kann man außerdem bestimmte Dateien bzw. Verzeichnisse vom Backup ausschließen. Bei mir gehören zum Beispiel Downloads definitiv zu den ausgeschlossenen Daten. *.tmp sowie *.bak-Dateien brauchen genausowenig gesichert zu werden.

Ebenfalls sehr nützlich ist es, bestimmte Dateien zwar zu sichern, aber dabei von der Kompression auszuschließen. Das macht das Backup dieser Dateien/Dateitypen deutlich schneller. Zum Beispiel macht es wenig Sinn *.rar, *.zip oder *.jpg-Dateien zu komprimieren, weil diese Dateien bereits komprimiert vorliegen. Ein paar weitere Vorschläge für diesen Filter: *.mp3 *.avi *.mpg

Aufpassen muss man bei der Struktur des zu erzeugenden Archivs. Ich spreche mich sehr stark für die Einstellung “Volle Pfade inkl. Laufwerksbuchstaben” aus, damit nicht nur die Daten selbst, sondern auch ihr genauer Ablageort jederzeit wiederherstellbar bzw. nachvollziehbar ist. In der Standardeinstellung gehen diese Informationen verloren und bei vielen Dateien wird das sehr schnell sehr hässlich, weil man nicht mehr unterscheiden kann, woher die Dateien/Ordner im Einzelnen gekommen sind.

Einstellungen: “Backup”

Wie der Name sagt sind diese Einstellungen speziell für Backups vorgesehen.

“Gemeinsam genutzte Dateien öffnen” sorgt dafür, dass WinRAR versucht, auch momentan durch andere Programme geöffnete Dateien zu sichern. Nichtsdestotrotz wird WinRAR das bei vielen Dateien mit einer Fehlermeldung quittieren. Das ist aber völlig normal.

“Archivnamen aus folgender Maske erzeugen” hängt an den Archivnamen eine Zeichenkette an, die dynamisch zum Beispiel aufgrund der aktuellen Kalenderwoche erzeugt wird. In meinem Fall wird “yyyymm” angehängt, also z.B. “201001″. Dadurch wird maximal 1 Monat lang einunddasselbe Archiv genutzt (“RobertBackup201001.rar”). Für den nächsten Monat erzeugt WinRAR automatisch ein neues Archiv (“RobertBackup201002.rar”).
Folgende Zeichen werden in der Maske akzeptiert (aus der WinRAR – Hilfe; dort findet man weitere nützliche Details):

Damit kann man schon eine ganze Menge erreichen. In diesem Punkt steht WinRAR kommerzieller Backup-Software in nichts nach, eher im Gegenteil. Lediglich das Löschen alter Archive geschieht nicht so leicht automatisch, da muss man schon noch selbst Hand anlegen. Aber um ehrlich zu sein lösche ich meine Backups auch viel lieber selbst…

Kommentar hinzufügen

Im letzten Reiter kann man dem Archiv einen Kommentar hinzufügen. Beispiel:

In diesem Backup enthalten:
C:\Users\Robert\
D:\eclipse

Ausgeschlossen:
C:\Users\Robert\Downloads *.tmp *.bak

Backup-Methode: Synchronisation (geänderte/neue Dateien werden hinzugefügt/überschrieben, gelöschte Dateien werden aus dem Archiv gelöscht)

Speichern der Einstellungen als Profil

Nun wäre das ganze ziemlich mühselig, wenn man all diese Einstellungen jedes Mal aufs Neue festlegen müsste. Dafür bietet WinRAR sogenannte Profile an. Unter “Allgemein” kann man seine Einstellungen auf diese Weise für das nächste Mal speichern (siehe Bild auf der rechten Seite).

Nicht vergessen im folgenden Dialog die ersten beiden Haken anzukreuzen! Außerdem empfehle ich einen Haken bei “Verknüpfung auf dem Desktop anlegen”. Diese Verknüpfung sollte man immer mit Administratorrechten ausführen (kann man in den Einstellungen derselben auch dauerhaft festlegen).

Fazit

Backups mit WinRAR sind schnell, klein, übersichtlich, leicht zu konfigurieren und sicher. Mit Hilfe der Einstellung “Archivnamen aus folgender Maske erzeugen” kann man zudem eine automatische Konsolidierung der Backups umsetzen.

Was will man mehr?

Error occurred during initialization of VM
Could not reserve enough space for object heap
Could not create the Java virtual machine.

This error message occurred every single time Java was involved in something… Even “java -version” crashed…

After several hours I figured out it was not a problem of having too less memory but instead a problem of having too much free memory. In particular, my system (a virtual server) always seems to have a lot of free memory, which is in fact used by the other virtual server instances on the same physical machine. Thus, Java attempts to allocate a very big part of the memory (expecting it is not used otherwise). The memory allocation fails and Java crashes with the deceptive message “Could not reserve enough space for object heap”. At least this is my explanation so far…

The solution

The problem can be fixed by manually specifying the maximum heapsize. E.g., execute “java -Xmx128m -version” instead of “java -version”.

Since it is a pain and sometimes almost impossible to enable this commandline parameter (think of applications making use of java indirectly) you can make it the default by changing the environment variable _JAVA_OPTIONS. Either edit /etc/environment (persistent solution) or execute

export _JAVA_OPTIONS="-Xmx128m"

(solves the issue only for the current session).

It worked for me and I’m running Ubuntu 8.04 on a VPS hosted by Hosteurope.

Inzwischen habe ich die ersten 2 Semester hinter mir, befinde mich also noch im Bachelor-Stadium; das 3. Semester hat seit einigen Wochen begonnen. Dieser Artikel soll einen kurzen Rückblick darstellen, der sich wahrscheinlich besonders für diejenigen lohnt, die ein Informatik-Studium in Betracht ziehen.

Hinweis: Ich gebe hier meine Sicht der Dinge wieder, also meine Meinung.

Wintersemester 08/09

Im WS 08/09 habe ich mein Informatik-Studium an der TU Darmstadt begonnen. Für diejenigen, die vllt. Informatik studieren werden, dürfte dieser Teil am spannendsten sein.

Grundlagen der Informatik 1

In GdI 1 gab es eine Einführung in das Programmieren. Von einer Einführung kann dabei aber kaum die Rede sein, denn es ging durchaus ziemlich in die Tiefe. Angefangen haben wir mit Scheme, einer funktionalen Programmiersprache, die mit LISP verwandt ist und mit der ich und die meisten meiner Kommilitonen zuvor nichts zu tun gehabt haben. Funktionale Programmierung war für die meisten, mich eingeschlossen, absolutes Neuland.

Das war insofern ein Problem, als dass viele meiner Kommilitonen Schwierigkeiten beim Einstieg in die funktionale Programmierung hatten – nicht nur die absoluten Neulinge, sondern auch einige der Erfahreneren. Bei Scheme werden nämlich fast alle Probleme mit rekursiven Funktionen gelöst. Schleifen im klassischen Sinne stehen quasi nicht zur Verfügung. Und wie sortiert man bspw. eine Liste rekursiv, wenn man bisher nur iterative Implementierungen kennt? Erstmal gar nicht so einfach!

Es stellte sich jedoch sehr schnell heraus, dass die Erfahrung mit Scheme eine echte Bereicherung war. Wer GdI 1 mit einer guten Note übersteht, der dürfte hinterher keine Probleme mehr mit Rekursionen haben.

Der zweite und geringfügig größere Teil drehte sich um Java. Das Verhältnis Scheme : Java kann man ungefähr mit 40 : 60 beschreiben. Beinhaltet waren solche Themen wie Objektorientierte Programmierung, d.h. was sind Klassen/Objekte, was ist Vererbung und wie funktioniert sie, Polymorphismus, Generische Typen (Generics) und ähnliches.

Klausuren: Im Dezember gab es eine Semestralklausur, in der es nur um Scheme ging. Nach Ende der Lehrveranstaltungen (während der Semesterferien) gab es dann noch eine endgültige Prüfung, die zu etwa 40% aus Scheme und zu 60% aus Java-bezogenen Aufgaben bestand.

Bewertung: Der Veranstalter ist den Studenten bei Problemen fast immer entgegengekommen, die Folien & die Übungen waren gut gemacht und die Klausuren waren sehr fair. Für Einsteiger ohne Programmiererfahrung aber trotzdem ein gewaltiges Stück Arbeit!

Technische Grundlagen der Informatik 1

TGdI 1 beinhaltete Grundlagen der Digitaltechnik, also boolesche Algebra / boolesche Funktionen, kombinatorische und sequenzielle Logik, KV-Diagramme, digitale Schaltungen, Signalpfade, wichtige digitale Schaltungen (Multiplexer, Decoder, …), darunter auch Speicherelemente (Flipflops), Automaten (Mealy und Moore) uvm.

Klausuren: Auch hier gab es eine Semestralklausur im Dezember und eine Prüfung am Ende des Semesters.

Bewertung: Die Folien waren relativ gut gemacht, teilweise habe ich aber den roten Faden vermisst. Insgesamt aber immer noch sehr gut gemacht, auch die Übungen und die Klausur ließen nicht viel zu wünschen übrig. Allerdings ist der Stoff einfach einfach. Wer hier durchfällt sollte sich Gedanken machen!

Mathematik für Informatiker und Wirtschaftsinformatik 1

Mathematik für Inf und WInf 1 war zusammen mit FGdI 1 die einzige Herausforderung im 1. Semester. Dazu muss ich etwas weiter ausholen.

Inhaltlich gesehen ist Mathe 1 nicht sonderlich schwer. Im Wesentlichen geht es um die gewöhnliche Analysis (mit einstelligen Funktionen), d.h. Folgen, Reihen, Grenzwerte, Funktionen, Differential- und Integralrechnung. Jedoch wird das Ganze sehr mathematisch aufgezogen. Der Vorlesung kann man kaum folgen, die wichtigen Informationen gehen in einem Schwall unnötiger mathematischer Sätze und Beweise völlig unter. Dazu muss man sagen, dass die Veranstaltung vom Fachbereich Mathematik organisiert wird. Sie wird also auch von einem Mathematik-Professor gehalten. Das merkt man auch sehr deutlich.

Klausuren: Es gab nur 1 Klausur am Ende des Semesters.

Bewertung: In Mathe 1 wird relativ leichter Stoff mit mathematischen Beweisen derart aufgeblasen, dass die eigentliche Leistung darin besteht, die wenigen wichtigen Informationen zu filtern bzw. überhaupt zu erfassen, ohne sich dabei von der gigantischen Menge unnötigen Wissens, das ebenfalls vermittelt wird, erschlagen zu lassen. Die Übungen waren anfangs schwer, weil man mathematische Beweise führen musste. Und das ist erstmal schwer bis unmöglich. Später wurden die Übungen aber besser. Die Klausur war schließlich ausgesprochen fair, aber vor allem eines: leichter, als alle erwartet hatten. Trotzdem sind hier viele gescheitert.

Formale Grundlagen der Informatik 1

FGdI 1 ist mir bis heute noch ein Rätsel. Wie man dem Titel der Veranstaltung ansehen kann geht es hier um die theoretische Informatik.

Rätsel deshalb, weil im Grunde genommen extrem einfacher Stoff (Sprachen, Reguläre Ausdrücke, Grammatiken, Chomsky-Hierarchie und dazugehörend DFAs, NFAs, PDAs) dermaßen mit formaler Sprache aufgeblasen wird, dass man sich erstmal immer fragt: “WHAT THE FUCK SOLL DAS HEISSEN?” Und wenn man es dann verstanden hat, denkt man sich: “Ist ja total easy. -.-”

Die Verantwortung liegt hier nicht nur bei den Veranstaltern, denn schließlich muss man sich an die formale Sprache erst gewöhnen, bis man sie wirklich verstehen kann. Aber es gab quasi keinerlei Erklärendes. Im Wesentlichen wurde wild drauflos definiert und wir mussten dann erraten, wozu die einzelnen Definitionen jeweils im Gesamtzusammenhang gebraucht wurden. Wie man es auch dreht und wendet: Wenn man gerade erst mit dem Studium anfängt, dann ist das eine echte Herausforderung!

Klausuren: Es gab wie in Mathe 1 nur eine Klausur am Ende des Semesters. :/

Bewertung: Während die Vorlesung inkl. Folien ziemlich bescheiden war, so waren die Übungen einigermaßen in Ordnung und die Klausur war sehr fair. Man konnte 60 Punkte erreichen, für eine 1.0 brauchte man aber nur 48 Punkte. Hier kann man eigentlich nur durchfallen, wenn man das falsche lernt. Ein gutes Auge für das Wesentliche hilft Wunder!

Sommersemester 2009

Grundlagen der Informatik 2

GdI 2 war eine monströse Veranstaltung, in der sich alles um Algorithmen und Datenstrukturen drehte, auch mehrere Index-Strukturen waren dabei; Laufzeit- und Speicherkomplexität von Algorithmen inklusive uvm. Alles in allem war es vor allem eines: verdammt viel, für die meisten zu viel! Nicht ohne Grund ist GdI 2 als “Exmatrikulator” berüchtigt (womit sich die Veranstalter für meinen Geschmack allzu oft gebrüstet haben, so als wären sie besonders stolz darauf).

Hier noch ein paar Stichworte zur Illustration: Komplexität von Algorithmen, Sortierverfahren, Graphenalgorithmen, Allgemeine Bäume und Binärbäume, Binäre Suchbäume, Mehrwegbäume, B-Baum u. Varianten, Digitale Suchbäume, Hashverfahren (intern, extern, erweiterbar), Graphische Datenstrukturen, Spezielle Themen (Bitmap Index, Indexstrukturen für “broadcast data”, etc.)

Klausuren: Nur eine Klausur am Ende des Semesters, für die man sich einen Bonus von bis zu einem ganzen Notensprung erarbeiten konnte.

Bewertung: Die Vorlesung war in Ordnung, soweit ich das beurteilen kann. Unser Professor schien aber häufig unvorbereitet zu sein; er selbst sagte entschuldigend, er hätte dieses Semester sehr viel zu tun.
Wie bereits geschrieben konnte man sich einen Bonus erarbeiten. Ab 191 Punkten in den bewerteten Hausübungen und Programmieraufgaben hat man einen vollen Notensprung für die Prüfung erhalten. Das war insofern manchmal ärgerlich, als dass die Hausübungen und Programmieraufgaben in mehreren Fällen unklar/missverständlich formuliert waren und die Folien oft erst verspätet ins Netz gestellt wurden. Ansonsten waren die Übungen und die Programmieraufgaben durchaus sehr hilfreich und man konnte sehr viel dabei lernen.
Die Klausur am Ende war ziemlich fair, es wurden sogar diejenigen belohnt, die sich den letzten Foliensatz nochmal komplett durchgeschaut haben (dazu kam eine sehr leichte Aufgabe dran, die man aber ohne diesen Foliensatz nicht bearbeiten konnte). Ich bin sehr zufrieden mit dieser Veranstaltung, einzig die Tatsache, dass man sich ständig als “Exmatrikulator” aufgeführt hat, ist mir mehrfach übel aufgestoßen. Man stand quasi dauernd unter Verdacht, Lösungen von Kommilitonen zu kopieren. Das nervt irgendwann…

Technische Grundlagen der Informatik 2

In TGdI 2 wurde uns im Wesentlichen beigebracht wie Prozessoren funktionieren. Das beinhaltet die verschiedenen binären Zahlen-Darstellungen (1er-Komplement, 2er-Komplement, Gleitkommazahlen uvm.), die Begriffe Steuerwerk & Operationswerk, ALUs und eine Einführung in die MIPS-Prozessorarchitektur (Eintaktimplementierung, Mehrtaktimplementierung und eine Implementierung mit Pipelining und alles was dazugehört, also z.B. Forwarding und Hazard Detection uvm.). In der Praxis haben wir mit Verilog gearbeitet, einer Hardware-Beschreibungssprache. Mit dieser Sprache haben wir in vielen Übungen digitale Schaltungen beschrieben und simuliert; eine sehr spannende Angelegenheit. Eine kleine Einführung in die Assembler-Programmierung hat es hier ebenfalls gegeben.

Klausuren: 1 Semestralklausur, die für das Ergebnis nur insofern relevant war, als dass man sich hier einen Bonus für die eigentliche Klausur am Ende des Semesters holen konnte.

Bewertung: Die Veranstaltung war sehr gut gemacht! Gute Folien, gute Übungen und eine fordernde, aber faire Klausur zum Schluss. Die Semestralklausur war ebenfalls in Ordnung. Außerdem – gut, das ist jetzt eher subjektiv – war das Thema sehr interessant.

Mathematik für Inf und WInf 2

Von der Qualität der Veranstaltung her genauso schlimm wie Mathe 1. Die eigentliche Leistung bestand wieder darin rechtzeitig vor den Klausuren den ganzen Schmodder, den man sich umsonst reingezogen hat, wieder loszuwerden und einen freien Kopf zu kriegen. Dann erst kann man sich richtig auf die Klausur vorbereiten.

Inhaltlich bot Mathe 2 lineare Algebra, Analysis mit mehrstelligen Funktionen und einfache Differentialgleichungen (DGL), lineare Systeme von DGL usw.

Klausuren: Wie bei Mathe 1 gab es nur eine Klausur am Ende des Semesters. Diese Klausur war – anders als bei Mathe 1 – viel schwerer als wir erwartet hatten. So kam dann auch eine Durchfallquote von 60% bzw. eine Durchschnittsnote von 4.27 zustande. Ich habe es dennoch geschafft unter die besten 10% zu kommen, trotzdem bin ich etwas enttäuscht von der absoluten Note.

Bewertung: Ja, was soll man dazu sagen? Die Vorlesung ist grauenvoll, weil sie zu 90% unbrauchbares mathematisches Gedöns enthält, das eine riesige Belastung darstellt, weil man eben erstmal nicht weiß, was davon nun Gedöns ist und was man wirklich braucht. Also zieht man sich alles rein und ordnet den Stoff hinterher in “Unbrauchbar” und “Brauchbar”. Sorry, aber das muss einfach mal gesagt werden: Die Vorlesung ist scheiße.
Die Übungen hingegen waren einigermaßen in Ordnung. Es gab übrigens viele betreute Extra-Übungen vor der Klausur – eine super Gelegenheit zur Vorbereitung, die man bei anderen Veranstaltungen meist nicht bekommt.

Formale Grundlagen der Informatik 2

Kurzfassung: Nach FGdI 2 habe ich mich kaum noch über FGdI 1 beschwert.
Das liegt daran, dass FGdI 2 letzteres nochmals deutlich unterboten hat. Erklärungen gab es keine und die wenigen Beispiele in den Folien verstehe ich heute noch nicht – trotz guter Prüfungsnote. Hier hat man sich keine Mühe gegeben, so viel steht fest. Mal wieder hat sich mein Motto “schlimmer geht immer” bestätigt. Dagegen war die Mathe 2 – Vorlesung fast schon wieder genießbar.

Inhaltlich ging es in FGdI 2 um die Aussagenlogik (quasi boolesche Algebra) und die Prädikatenlogik (im Wesentlichen Aussagenlogik erweitert um All- und Existenzquantoren).

Klausur: Nur eine Klausur am Ende des Semesters (48 Punkte brauchte man für 100%, 60 gab es insgesamt). Naja: eigentlich! Leider gab es während der Klausur in einem der Gebäude einen Feueralarm. Dadurch konnten etwa 2 Drittel der Studenten die Klausur nicht weiterschreiben und mussten die Klausur etwa 3 Wochen später wiederholen – der neue Termin für FGdI 2 lag zudem direkt hinter 2 anderen knackigen Klausuren. Einen Vorteil hatten wir Wiederholenden (ich war einer der Unglücklichen) also nicht, denn wir mussten uns auf die anderen Klausuren konzentrieren (unter anderem auf den “Exmatrikulator”: GdI 2). Trotzdem war die Wiederholungsklausur schwerer als die 1. Klausur. Schwerer ist eigentlich der falsche Ausdruck: Die Wiederholungsklausur war um Längen schwerer! Es gab in jeder Ecke irgendeine Falle, und die meisten sind voll ins Messer gelaufen.
Hier die Notenspiegel der beiden Klausuren im Vergleich (PDF von mir erstellt, Angaben ohne Gewähr!): Notenspiegel FGdI2 SS09
Unbedingt zu beachten sind die Punktegrenzen auf Seite 2. Ursprünglich benötigte man 24 Punkte zum Bestehen (50% von 48). Diese Grenze wurde bereits bei der 1. Klausur deutlich herabgesetzt. Bei der Wiederholungsklausur brauchte man schließlich nur noch 15 Punkte! Das sind etwa 31%!
Man kann sich also ungefähr ausmalen wie viel schwerer die Wiederholungsklausur war. Für mich war das Ganze nicht mehr nachvollziehbar.

Bewertung: Die Vorlesung & die Folien waren grauenvoll, die Übungen mäßig und die Klausuren wurden insofern versaut, als dass die Wiederholungsklausur in einem völlig unangebrachten Ausmaß schwerer war als die 1. Klausur. FGdI 2 war sehr bitter!

Fazit

Die ersten 2 Semester sind definitiv eine Durststrecke. Besonders diejenigen Veranstaltungen, die vom Fachbereich Mathematik organisiert werden (das sind Mathe 1 & 2 und Formale Grundlagen 1 & 2), leiden an grauenvollen Vorlesungen und schwer nachvollziehbaren Folien/Skripten. Genausogut könnten wir auch die normalen Mathe-Vorlesungen hören, da bräuchte es kein Mathematik für Informatiker (das beziehe ich jetzt wirklich nur auf die Vorlesung; was die Übungen und die Klausur angeht habe ich nichts einzuwenden ). Mich haben also keineswegs die Veranstaltungen gestört, in denen es etwas theoretischer zuging. Nein, mich stört, dass sich der FB Mathematik bei Veranstaltungen für Informatiker scheinbar nicht die allergeringste Mühe zu geben scheint. Die Veranstaltungen tragen zwar “für Informatiker” im Namen, inhaltlich ist das jedoch (abgesehen vllt. von der Klausur) kaum zu spüren. Mag sein, dass sie den Stoff tatsächlich ein wenig für die Informatiker angepasst haben. Für mich steht aber fest: Da ist noch viel zu viel Luft nach oben.

Das 3. Semester hingegen sieht bisher ausgesprochen gut aus. Das liegt ganz gewiss auch daran, dass sämtliche Veranstaltungen vom FB Informatik organisiert werden. Man spürt sofort, dass die Veranstalter einen ganz anderen Blick auf die Dinge haben und vermitteln.

Fallt mir nicht in den Rücken…

Ich habe schon mehrfach die Lehrveranstaltungen des FB Mathematik im Fachschaftsforum kritisiert, da hier wie gesagt einiges im Argen liegt. Dabei sind mir viele Kommilitonen in den Rücken gefallen mit scheinheiligen Argumenten wie “schau dir doch Erklärungen im Internet an” oder “das ist der Anspruch einer Universität” usw. Sinngemäß wurde mir viel zu oft vermittelt: “Wenn du zu dumm dafür bist, dann studier etwas anderes oder organisiere dich besser.” Das möchte ich an dieser Stelle gerne vermeiden.

Niemand konnte mir bisher erklären, warum sich manche Veranstalter (des FB Mathematik) auf die faule Haut legen dürfen, während man sich bei anderen bereits über Kleinigkeiten aufregt (mehrfach geschehen).
Die Grundlagen-Veranstaltungen der ersten 2 Semester, die vom FB Mathematik organisiert werden, sind einfach scheiße. Diese meine Ansicht habe ich jetzt an mehreren Stellen mehr oder weniger grob erklärt (Kurzfassung: es steht zwar “für Informatiker” drauf, das ist aber nicht drin!). Findet euch damit ab, dass man mich nicht von dieser Ansicht abbringt, indem man mir immer wieder erklärt, dass es Veranstaltungen gibt, die noch schlechter sind oder dass ich zu dumm oder zu faul bin. Ich habe Mathe 1/2 und FGdI 1/2 auf Anhieb bestanden und außer bei FGdI 2 habe ich jedes Mal zu den besten 10% gehört (bei FGdI 2 nur zu den besten 16% mangels Motivation). Von Dummheit oder Faulheit möchte ich nichts mehr hören, egal wie ihr diese Anschuldigungen verpackt.

Zunächst einmal: Generics ermöglichen mittels formaler Typparamter, dass Klassen (und Funktionen), die bestimmte Dienste zur Verfügung stellen, mit mehreren Datentypen umgehen können.
Wenn wir zum Beispiel zwei beliebige Objekte als “Paar” verwalten wollen, dann benötigen wir eine entsprechende Klasse mit zwei Attributen, einer Möglichkeit die Objekte darin zu speichern und wieder auszulesen.

An sich nichts schweres:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Pair {
    Object obj1, obj2;
    // Das Einspeichern von Objekten ist der Einfachheit halber nur beim Erzeugen des Paares möglich...
    Pair(Object obj1, Object obj2) {
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
    public Object getFirst() {
        return this.obj1;
    }
    public Object getSecond() {
        return this.obj2;
    }
}

Diese Klasse hat aber einen Haken. Beim Einspeichern gehen die Informationen über den Typ der eingespeicherten Objekte verloren. Wenn wir den Typ wiederherstellen wollen müssen wir einen expliziten Cast durchführen. Andernfalls erhalten wir immer nur Objects.

Pair paar = new Pair(new MeinApfel(), new MeinApfel());
MeinApfel apfel = (MeinApfel)paar.getFirst();

Bei Listen ist das Problem noch dramatischer. Ohne Generics muss man bei jeder Leseoperation auf einer Liste explizit casten:

Vector liste = new Vector();
for(int i=0; i<10; i++)
    liste.add(new MeinApfel());
// ...
for(int i=0; i<liste.size(); i++)
    esseApfel((MeinApfel) liste.get(i));

Bei so vielen expliziten Casts riskiert man außerdem ClassCastExceptions, falls das referenzierte Objekt nicht zu dem entsprechenden Typ konvertiert werden kann.

Abhilfe schaffen hier die Generics. Das soll erstmal am Beispiel der obigen Pair-Klasse demonstriert werden, die folgendermaßen generisch gemacht werden kann:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

public class Pair<A,B> {
    A obj1;
    B obj2;
    Pair(A obj1, B obj2) {
        this.obj1 = obj1;
        this.obj2 = obj2;
    }
    public A getFirst() {
        return this.obj1;
    }
    public B getSecond() {
        return this.obj2;
    }
}

A und B sind sogenannte formale Typparameter, die in diesem Fall für beliebige Typen stehen.
Folgendermaßen erzeugen wir jetzt Paare von Integer-Objekten:

// anschaulich wird hier A = Integer und B = Integer gesetzt
Pair<Integer, Integer> paar = new Pair<Integer, Integer>(new Integer(2), new Integer(3));
 
// kein Cast mehr nötig, weil auch die Signatur von getFirst() quasi dynamisch an Integer angepasst wurde
Integer zahl = paar.getFirst();

Dasselbe ist natürlich auch bei Listen möglich, die bei der Einführung der Generics auch gleich generisch gemacht wurden. Bei Listen gibt es im Gegensatz zu dem Pair-Beispiel nur einen formalen Typparameter, der den Typ der gespeicherten Elemente festlegt.

// Eine Liste von Elementen des Typs "MeinApfel" anlegen...
Vector<MeinApfel> liste = new Vector<MeinApfel>();
liste.add(new MeinApfel());
 
// ...
 
// funktioniert problemlos, da die Signatur von get() genau wie getFirst() aus dem ersten Beispiel an den ggb. Typ angepasst wurde
MeinApfel apfel = liste.get(0);

Richtig trickreich wird es, wenn Funktionen, die Listen entgegennehmen, generisch gemacht werden sollen. Angenommen wir wollen eine Funktion schreiben, die eine Liste von Nahrungsmitteln entgegennimmt und ihr Gewicht bestimmt.
In diesem Fall werden sogenannte Wildcards benötigt.

Intuitiv müsste die Funktion folgendermaßen aussehen:

public double wiege(List<Nahrungsmittel> liste) {
    // ...
}

Diese Funktion würde aber entgegen unserer Intuition bspw. keine Liste mit Äpfeln annehmen, obwohl Äpfel in der Klassenhierarchie ganz klar ein Subtyp von Nahrungsmittel darstellen würden (public class Apfel extends Nahrungsmittel).
Es funktioniert deshalb nicht, weil List<Apfel> einfach nicht kompatibel ist zu List<Nahrungsmittel>. Beispiel:

1
2
3

Vector<Nahrungsmittel> liste1 = new Vector<Nahrungsmittel>(); // OK!
Vector<Apfel> liste2 = new Vector<Apfel>(); // OK!
liste1 = liste2; // FEHLER: cannot convert from Vector<Apfel> to Vector<Nahrungsmittel>

Dieser Code wird vom Compiler deshalb nicht akzeptiert, weil man in eine Liste von Äpfeln keine Nahrungsmittel einfügen kann. Wenn liste1 vom Typ List<Nahrungsmittel> auf liste2 vom Typ List<Apfel> verweisen würde, dann würde das bspw. die Signatur von liste1.add(…) verletzen, denn liste1.add(new Nahrungsmittel()) wäre nicht möglich, weil liste1 auf eine Liste von Äpfeln (und nur Äpfel!) zeigen würde. Das meine ich, wenn ich schreibe, dass List<Apfel> nicht kompatibel ist zu List<Nahrungsmittel>.

Das Problem löst man mit besagten Wildcards:

public double wiege(List<? extends Nahrungsmittel> liste) {
    // akzeptiert alle Listen, deren Elemente Nahrungsmittel oder Subtypen davon sind
}

? steht für einen unbekannten Typ. Bekannt ist bei einer List<?> nur, dass – wie bei jeder typ-parametrisierten Liste – die Elemente, die in der Liste gespeichert sind, alle vom selben (unbekannten) Typ sind.
Das “extends Nahrungsmittel” schränkt die möglichen Typen hier aber insofern ein, als dass Nahrungsmittel die “obere Schranke” darstellt. ? darf hier also vom Typ Nahrungsmittel oder ein Subtyp davon sein.

Es gibt auch die Möglichkeit eine untere Schranke zu definieren: List<? super Nahrungsmittel> bzw. allgemein List<? super X>. Erlaubt sind dann Elemente vom Typ X oder Supertypen davon.

Bleiben wir zunächst bei unserer List<? extends Nahrungsmittel>. Wir können zumindest eingeschränkt mit einer solchen Liste arbeiten: Lesen, aber nicht Einfügen. Das Einfügen klappt deshalb nicht, weil der genaue Typ der Liste nicht bekannt ist. Zwar kann man einen Apfel zu einem Nahrungsmittel konvertieren. Aber die Liste enthält ja nicht notwendigerweise Nahrungsmittel. Sie kann genausogut Birnen enthalten – daher darf man in eine solche Liste keine neuen Objekte einfügen.

Im Folgenden eine Tabelle, die die erlaubten Operationen auf einer Liste dokumentiert:

Bleibt nur noch die Frage zu klären, warum man in eine List<? super X> Elemente vom Typ X und Subtypen von X einfügen darf. Bei List<? extends X> ist das schließlich auch nicht möglich. Nunja, bei extends X sind die Elemente der Liste vom Typ X oder Subtypen davon, d.h. spezieller. Bei super X sind die Elemente vom Typ X oder Supertypen von X, d.h. allgemeiner. Daher kann man Objekte vom Typ X oder von einem Subtyp von X nach Belieben in eine solche Liste einfügen, weil man Objekte von einem bestimmten Typ immer zu einem allgemeineren Typ konvertieren kann.
Faustregel: Jeder Apfel ist ein Obst, aber nicht jedes Obst ein Apfel!

So… es muss jetzt mal raus. Seit Montag haben wir Semesterferien, d.h. es gibt keine Vorlesungen/Übungen mehr und wir bereiten uns jetzt auf die Prüfungen vor. Die erste Prüfung ist Mathematik für Informatiker I.

Ich habe daher seit Montag jeden Tag etwas geübt und auch damit angefangen, das Mathe-Skript vom Professor mal ernsthaft und konzentriert durchzugehen. Das heißt, dass ich v.a. versuche, die vielen Beweise zu verstehen, um die ich bisher häufig einfach einen Bogen gemacht habe. Diese Beweise sind allerdings bis auf ganz wenige Ausnahmen absolut unverständlich… es werden z.B. ständig die unmöglichsten Umformungen gemacht ohne, dass das auch nur in einer Randnotiz vermerkt wäre – zum Kotzen!

Nach einem vollen Semester Mathematik – in dem ich mir wirklich Mühe gegeben habe, zu verstehen, was der Professor da immer predigt – und nach mehrfachen Versuchen, den Mathematikern doch noch eine Chance zu geben, lautet mein Fazit ein für allemal:

• Mathematiker erklären ihr Fach absichtlich schlecht, obwohl sie selbst bspw. von Beweisen fordern, dass sie bloß gut kommentiert und nachvollziehbar sein sollen
• Mathematiker stehlen dadurch Lebenszeit, die man auch besser nutzen könnte (um mal auf den Titel zurückzukommen)

Ich bin ja sowas von angepisst von dieser abartigen Arroganz, die die Mathematiker bei uns an der Uni an den Tag legen… das ist ja sowas von erbärmlich. Es gibt nichts, was der dümmste Dorftrottel nicht besser erklären könnte als ein Mathematiker – ich kann mir jedenfalls nichts vorstellen.
So oft haben meine Kommilitonen und ich schon gestöhnt “oh man, das ist doch eigentlich total einfach”, nachdem wir endlich etwas verstanden hatten, was uns die lieben Mathematiker auf die gottverdammt dämlichste Art und Weise versuchten, beizubringen (dieses Gefühl wird wohl jeder kennen).

Warum tun sich Mathematiker so schwer damit, ihr Fach menschlich zu erklären? Der Formalismus beißt sich nämlich kein bisschen mit Verständlichkeit (das Gegenteil wird immer von Mathematikern behauptet)!
Ich schätze, dass die Mathematiker einfach nicht wollen, dass man ihr Fach so darstellt, wie es nunmal ist: relativ simpel, wenn man’s vernünftig erklärt. Oder es ist einfach eine sehr alte Tradition und jeder Professor sagt sich “warum sollen es die Studenten von heute besser haben als ich – die sollen auch schuften müssen, auf die vernünftigen Erklärungen scheiße ich”…

Zum Schluss möchte ich noch eines sagen: Mathe ist nur eine von 4 Lehrveranstaltungen in diesem Semester. Jede Lehrveranstaltung hat es gewaltig in sich – und man ist gelegentlich immer mal frustriert. Das ist normal, wenn man studiert – erst Recht bei Informatik (es ist einfach schwer). Aber nirgends ist es a) so heftig wie bei Mathematik und b) nirgends habe ich auch nur den geringsten Anlass dazu zu denken, dass die Professoren/Tutoren ihr Fach mit Absicht schwer erklären. Im Gegenteil: Überall versucht man den Stoff so verständlich und anschaulich rüberzubringen wie nur irgendwie möglich! Nur bei Mathe nicht. Da ist es gerade andersrum… und DAS ist es, was mich so sauer macht.
Außerdem ist es so, dass Mathematik nicht nur bei uns so verhasst ist. Von verschiedenen Leuten aus meinem Abi-Jahrgang und von Studenten aus anderen Fachbereichen höre ich (im Wesentlichen) genau dasselbe.

Letztenendes muss ich da so oder so durch – und ich werde es schaffen! Und von Zeit zu Zeit werde ich den Mathematikern gehörig in den Arsch treten, indem ich ihnen zeige, wie man es besser macht…

Das führt dazu, dass man auch während größerer Downloads mit gefühlter voller Bandbreite surfen kann (habe ich selbst getestet und kann ich zu 100% bestätigen). Man merkt dann kaum noch, dass die Leitung in Wirklichkeit voll ausgereizt ist (= optimal).

Ich habe es gestern auch mal auf die Spitze getrieben: Ich habe eine sehr große Datenmenge heruntergeladen und währenddessen über das Internet ein Strategiespiel gespielt (bei diesem Spiel kommt es v.a. auf gute Reaktionszeiten an, d.h. auf eine gute Internet-Verbindung). Normalerweise wäre das nicht möglich gewesen, da das Spiel dauernd geruckelt hätte usw. Da ich aber cFosSpeed klargemacht habe, dass der Download nicht so wichtig ist wie das Spiel, habe ich den Download im Hintergrund nicht beim Zocken gespürt. Dabei war die Leitung die ganze Zeit zu 100% ausgereizt. Die Bandbreite wurde von cFosSpeed einfach geschickt zwischen den Anwendungen aufgeteilt – entsprechend meiner Einstellungen.

Ganz ehrlich… für DSL 1000 – Kuhkaff – Menschen wie mich ist cFosSpeed eine erstklassige, wenn auch leider nicht kostenlose Software. Ich überlege mir ernsthaft, mir diese Software nach Ablauf der 30 Tage – Demo zuzulegen (zudem man lebenslang zu allen Updates/Upgrades Zugang hat).
Die Bedienung von cFosSpeed ist zwar etwas gewöhnungsbedürftig, aber immerhin sind die populären Anwendungen/Prokotolle bereits vorkonfiguriert. So wird bspw. das Surfen und das Zocken von Anfang an mit einer hohen Priorität bedacht. Filesharing-Prokotolle werden auch schon von Haus aus “gedrosselt”. Sollte man doch mal eine Anwendung hinzufügen wollen, die nicht bereits in cFosSpeed eingetragen ist, dann ist das problemlos möglich.

Alles in allem kann ich cFosSpeed nur uneingeschränkt weiterempfehlen und hoffe, dass auch ihr von meiner “Entdeckung” profitiert. Probiert es einfach aus, es ist wirklich herrlich!

Wichtigster Unterschied zur Schule ist, dass an der Universität keine Allgemeinbildung gelehrt wird. Man kann stattdessen einen von vielen vielen vielen Studiengängen wählen. An manchen Universitäten werden mehr Studiengänge angeboten, an anderen weniger. Ich studiere momentan B.Sc. Informatik an der TU Darmstadt. B.Sc. bedeutet Bachelor of Science und ist ungefähr gleichwertig mit einem Vordiplom. Wenn man diesen Abschluss erreicht hat, dann bedeutet dies, dass man das Grundstudium abgeschlossen hat und das Hauptstudium, in welchem man sich i.d.R. weiter spezialisiert, antreten kann.

Jeder Studiengang besteht aus einer bestimmten Anzahl von Semestern – B.Sc. Informatik hat 6 Semester. Jedes Semester ist ein halbes Jahr lang – man unterscheidet zwischen Wintersemester (1. Oktober bis 31. März) und Sommersemester (1. April bis 30. September).

Jedes Semester wiederum besteht aus bestimmten Lehrveranstaltungen. Eine Lehrveranstaltung heißt zum Beispiel “Mathematik I für Inf und WInf” (Inf=Informatiker, WInf = Wirtschaftsinformatiker) und besteht mindestens aus den zugehörigen Vorlesungen, Übungen und Prüfungen. Jede Lehrveranstaltung wird außerdem von einem Professor, dem verschiedene Hilfskräfte zur Seite stehen, geleitet.

In den Vorlesungen, die in sehr großen Hörsälen von dem jeweiligen Professor gehalten werden, wird der Stoff in sehr schnellem Tempo abgehandelt. Meistens muss man daher nach der Vorlesung einiges nacharbeiten, um den Stoff auch wirklich zu verinnerlichen. Die Vorlesungen dauern jeweils 2 Semesterwochenstunden (SWS), von denen jede 45 Minuten lang ist. Generell wird an der Universität vieles in Semesterwochenstunden gemessen. Werden für eine Vorlesung zum Beispiel 4 SWS angeben, so heißt das, dass man in dem Semester jede Woche durchschnittlich (!) 4×45 Minuten Vorlesung hat.
(Die Teilnahme an den Vorlesungen ist nicht verpflichtend, aber ratsam.)

Beim Lernen des Stoffes helfen die Übungen, die von den Veranstaltern angeboten werden. Eine Übung findet meistens einmal pro Woche oder alle 2 Wochen statt und dauert i.d.R. 2×45 Minuten. Da man nicht alle Hörer der Vorlesung in einer einzigen Übung betreuen kann, werden die Studenten verschiedenen Übungsgruppen zugeteilt. Jede Übungsgruppe besteht i.d.R. aus etwa 20-40 Studenten (das ist bei mir so) und wird von einem Tutor geleitet. Die Aufgabe des Tutors ist es, den Studenten zu helfen und ihre Fragen so gut es geht zu beantworten.
Man trifft sich dann schließlich zu bestimmten Zeiten mit seiner Übungsgruppe und dem Tutor in einer Räumlichkeit der Universität und bearbeitet verschiedene Gruppenaufgaben zum Vorlesungsstoff, die jeweils vor der Übung veröffentlicht und von den Studenten ausgedruckt und mitgebracht werden sollen. Bei der Bearbeitung der Aufgaben soll das Gelernte eingeübt werden.
(Die Teilnahme an den Übungen ist aber meistens nicht verpflichtend, aber wie bei den Vorlesungen ratsam.)

Es gibt allerdings nicht nur Gruppenaufgaben, sondern auch Hausaufgaben. Sie werden Hausübungen genannt. Diese Hausübungen sollen am besten alleine bearbeitet werden, damit man sich auch wirklich sicher sein kann, dass man die Aufgaben selbstständig lösen kann. Meistens ist es erlaubt, die Hausübungen auch in (kleinen!) Gruppen zu lösen – dies muss aber explizit angegeben werden und es muss trotzdem jeder Student seine eigene Lösung abgeben.

Die Hausübungen kann man am jeweils nächsten Übungstermin bei seinem Tutor abgeben (Anmerkung: bei manchen Lehrveranstaltungen kann man die Hausübungen auch online abgeben, natürlich besonders häufig in der Informatik und ähnlichen Fächern). Der Tutor wird die Lösungen dann bis zum nächsten Übungstermin korrigieren, ggf. sogar mit Anmerkungen versehen (wie man die Aufgabe z.B. hätte besser lösen können o.ä.).
Wichtig: Bei vielen Lehrveranstaltungen steht es dem Studenten frei, ob er seine Hausübung bearbeitet und abgibt (auch, wenn er es im eigenen Interesse tun sollte).
Bei manchen Lehrveranstaltungen werden die Hausübungen allerdings bewertet. Man nennt dies dann bewertete Hausübungen. Der Veranstalter kann dann zum Beispiel vorschreiben, dass man mindestens 50% der Punkte in den (bewerteten) Hausübungen erreichen muss, um für die Prüfung zugelassen zu werden. Die Bewertung wird von dem jeweiligen Tutor vorgenommen. Die Abgabe der Hausübungen ist bei solchen Lehrveranstaltungen natürlich Pflicht – ansonsten erhält man keine Punkte.

Zusätzlich zu den Vorlesungen und den Übungen gibt es bei manchen Lehrveranstaltungen auch noch Praktika, Seminare und weitere.
Praktika sind zum Beispiel bei “Grundlagen der Informatik I” kleine Softwareprojekte, die ebenfalls benotet werden. Dabei kommt es vor allem darauf an, das Gelernte anzuwenden. Auch die Planung usw. fließen in die Bewertung ein.
Seminare sind, soweit ich das bisher überblicken kann, benotete Vorträge, für die sich Studenten selbstständig etwas tiefer in eine bestimmte Thematik einarbeiten mussten. sind Lehrveranstaltungen kleineren Umfangs (meist über einige Wochen), an deren Ende das Gelernte entweder mit einer Hausarbeit oder einem Vortrag überprüft wird, woraus dann eine Note hervorgeht.

In den Prüfungen (der üblichen Lehrveranstaltungen) stellt sich schließlich heraus, ob die Studenten das nötige Wissen verinnerlicht haben und unter Zeitdruck anwenden können. Manche Prüfungen sind übrigens geteilt in zwei einzelne Klausuren (die dann für das Gesamtergebnis zusammengerechnet werden). Die Prüfungen finden während der Semesterferien statt. Es handelt sich also gar nicht um echte Ferien – es werden lediglich keine Vorlesungen mehr gehalten, daher auch vorlesungsfreie Zeit genannt.
Zu den Prüfungen ist anzumerken, dass die Veranstalter teilweise komplizierte eigene Regelungen vorsehen. So ist es beispielsweise bei manchen Lehrveranstaltungen so, dass überschüssige Punkte aus den bewerteten Hausübungen zur Verbesserung der Prüfungsnote genutzt werden können. Wenn man sich in den entsprechenden Hausübungen gut schlägt, kann man seine Prüfungsnote am Ende also nochmal deutlich verbessern!
Weiterhin ist zu sagen, dass man die Prüfungen in der Regel relativ leicht schaffen sollte, wenn man die Vorlesungen und Übungen regelmäßig besucht und seine Hausübungen macht. Der Stoff ist schwer, aber man bekommt viel Unterstützung bis zur Prüfung.

Wenn man eine Prüfung nicht besteht, muss man sie – wenn möglich – in einem späteren Semester wiederholen oder das Studium abbrechen. Meistens hat man eine begrenzte Anzahl von Versuchen.

Das waren so die wichtigsten Elemente des reinen Studentenlebens.
Während der Vorlesungszeit geht man in die Vorlesungen, besucht die Übungen, macht seine Hausübungen usw. Wie viel Zeit das etwa kostet, kann ich noch nicht genau beschreiben, weil es im 1. Semester natürlich etwas langsamer los geht. Für die zweite Hausübung von Grundlagen der Informatik I habe ich aber immerhin fast 4 Stunden gebraucht. (Ich werde in einigen Wochen, wenn es richtig hart wird, an dieser Stelle einen kleinen Aufwandsvergleich zur Oberstufe einfügen.)
Wenn die Vorlesungen dann vorbei sind, bereitet man sich auf die Klausuren vor. Das schwierigste dabei ist, dass es die meiste Zeit über niemanden gibt, der einen dazu zwingt, zu lernen. Es gibt Menschen, die damit besser umgehen können und es gibt Menschen, die damit eher nicht zurecht kommen – und der Stoff ist wirklich hart.

Alles in allem macht mir persönlich das Studium bisher wirklich Spaß! Das liegt zum einen daran, dass der Stoff wirklich anspruchsvoll ist und man definitiv nicht gelangweilt ist. Zum anderen ist es schlicht und ergreifend so, dass der Anteil dessen, was mich absolut nicht interessiert, sehr gering ist. Diese ganzen Schulfächer, die man ohne Weiteres aus dem Lehrplan streichen könnte, gibt es jetzt nicht mehr.

Als letzter Hinweis sei noch gesagt, dass für Erstsemester (Ersties) von der Universität oder von höhersemestrigen Studenten sogenannte Orientierungsphasen bzw. Einführungswochen angeboten werden. Alles, was in diesem Artikel beschrieben ist und noch viel viel mehr, wird dann innerhalb von 1 Woche o.ä. ausführlich erklärt. Man wird also auf keinen Fall im Regen stehen gelassen.

Durch Zufall bin ich nämlich auf OpenID gestoßen, ein Single Sign-on-System, das ziemlich genau einem System entspricht, an dessen Entwicklung ich selbst schon gearbeitet habe und das dasselbe Ziel hat: Das Problem der vielen Accounts/Logins auf etlichen verschiedenen Webseiten zu lösen…

Das würde mich ja gar nicht stören (bis auf die Arbeit, die ja jetzt quasi umsonst war, weil der OpenID-Standard sich offenbar bereits durchgesetzt hat), wenn da nicht noch dieser andere Vorfall wäre:
Als ich vor kurzem eine Variante des Transportproblems lösen musste, ist mir ein schier genialer Algorithmus eingefallen, der bereits verdammt gute Näherungslösungen und in den meisten Fällen sogar optimale Ergebnisse lieferte. Damals wusste ich gar nicht, dass das Problem in der Wissenschaft bereits abgehandelt wurde und ich wusste auch nicht, dass es “Transportproblem” genannt wird. Aber es handelt sich in der Tat um eine Variante des eigentlichen Problems (für die, die es interessiert: eine Lagerstätte/Quelle kann bei dieser Variante immer nur genau eine Ware liefern und somit nur einen Bedarf decken). Dennoch: Der Algorithmus, den ich entwickelt habe, entspricht der Vogelschen Approximationsmethode… der Ansatz, der dahinter steckt, den gibt es also schon länger.

Fazit: Ich lebe in der falschen Zeit! (Kommt mir auch aus ganz anderen Gründen häufig so vor.)
PS: Den Titel bitte nicht falsch verstehen, ich käme im Leben nicht darauf, irgendwem vorzuwerfen, er hätte mir meine Idee geklaut, nur weil er sie vor mir hatte! Das ist eigentlich eine Selbstverständlichkeit, aber hier lesen ja immer noch Juristen mit und da erkläre ich es lieber nochmal.

[UPDATE am 12.11.2008: Inzwischen bin ich bei layer-ads.de angekommen. Sie haben mir jetzt schon 5 Monate lang keinen Grund gegeben mich zu beklagen, das danke ich ihnen mit diesem Hinweis. Update 10.10.2009: Inzwischen ist aber auch Layer-ads.de mit seinen Auszahlungen in Verzug. Was ich damit meine erfahrt ihr hier.]

Vorneweg: Ich habe mich juristisch beraten lassen und mir wurde versichert, dass es vollkommen legal ist, wenn man einen Sachverhalt aus der eigenen Perspektive wahrheitsgemäß wiedergibt.

An die Juristen, denen man alles zwei Mal erklären muss: Dieser Artikel gibt meine persönliche Wahrnehmung wieder und den Eindruck, den bin-layer.de auf mich gemacht hat.

bin-layer.de

bin-layer.de ist eine Webseite, die sogenannte Sponsoren an Webmaster vermittelt, ohne dass die Webmaster selbst Kontakte knüpfen müssen. Es handelt sich also um ein ganz normales Unternehmen für Internetwerbung, genauso wie beispielsweise das bekanntere layer-ads.de.

Die Anmeldung bei bin-layer.de am 14.03.

Seit dem 14. März war ich bei bin-layer.de angemeldet und habe nach deren Anweisungen (Einbau von bestimmtem Javascript-Code) auf meiner Webseite DS NoPaste Layer eingeblendet, d.h. diese großen und zugegeben lästigen “Popups”, die meist die Hälfte der Webseite überdecken. Aber immerhin konnte man die Layer auf normalem Wege schließen und sie sind dann auch wirklich verschwunden. Außerdem steht mir ein finanzieller Ausgleich als Betreiber meiner stark frequentierten Seite einfach zu – meiner Meinung nach. (Zudem hätte ich die Layer-Einblendungen in Zukunft nur noch zu bestimmten Zeiten aktiviert, sodass die Benutzer von NoPaste die meiste Zeit über ungestört surfen können.)

Es ist nun so, dass DS NoPaste, eine Tool-Seite für das Browsergame DieStämme, sehr beliebt ist und pro Tag durchschnittlich etwa 1000-1500 “echte” Besucher hat. Das hatte zur Folge, dass ich pro Tag sage und schreibe mindestens 2€ eingenommen habe. Denn für 1000 gewertete Layer-Einblendungen erhält man – das wird von bin-layer.de garantiert – mindestens 4€, manchmal auch mehr (Maximum: 8€). Ein Layer zählt übrigens dann als gewertet, wenn er vollständig angezeigt und frühestens nach 3 Sekunden geschlossen wird.

Vor der Sperrung meines Accounts habe ich durch diese Vergütung pro Woche locker 18€ eingenommen! Für den gesamten Webspace inkl. Domains bezahle ich pro Monat nur 8€! D.h. ich hätte meine Kosten um ein Vielfaches decken können und einen Taschengeld-Bonus von etwa 60€ / Monat gehabt!

Die Sperrung meines Accounts am 17.04.

Das war natürlich zu schön um wahr zu sein. Die erste Auszahlung von 15€ habe ich zwar erhalten, aber die restlichen bis heute angesammelten 65€ verbleiben bei bin-layer.de. Als ich mich nämlich heute bei bin-layer.de einloggen wollte um die nächste Auszahlung zu beantragen (es waren übrigens bereits 4 Auszahlungen in der Warteschleife) erhielt ich folgende Fehlermeldung:

Hinweis: Sie wurden am 17.04.2008 Gesperrt! Grund:
Fake

Bei eventuellen Fragen wenden Sie sich bitte an den Support

Die Auskunft des offiziellen Supports

Ich habe mich natürlich dann umgehend beim Support gemeldet, per ICQ. Nach etwa 10 Minuten hieß es, mein Account wurde gesperrt, weil meine viele tausend Besucher bei den Sponsoren nichts gekauft hätten. Bei “echten” Besuchern wäre das unmöglich, deshalb müsse man von Manipulationen (“zusätzliche[n] Tools oder [von] Proxynutzung” o.ä.) ausgehen.

Dazu muss man sich folgendes klar machen: bin-layer.de vermittelt Sponsoren an die Webmaster, die für bestimmte Produkte werben. Zum Beispiel werden dann Layer eingeblendet, die für bestimmte Handys o.ä. werben. Offenbar kann bin-layer.de zurückverfolgen, ob über die Werbeeinblendungen meiner Webseite solche Produkte gekauft wurden. Und das ist angeblich nicht der Fall.

Jetzt kommt aber das, was mich wirklich in Rage bringt: Bei bin-layer.de wird man für gottverdammte Werbeeinblendungen bezahlt und nicht dafür, ob die Werbung dann tatsächlich einen Effekt hat oder nicht. Davon kann sich auf der bin-layer.de-Webseite jeder selbst überzeugen.

Ich habe dann erstmal freundlicherweise diesen logischen Fehler übergangen und forderte Einblick in die Verkaufs-Daten, die belegen sollen, dass über meine Webseite nichts gekauft wurde. Die unbefriedigende Antwort:

“Das ist natürlich nicht möglich, das sind interne Geschäftsdaten.”

Anschließend kam ich auf obiges Argument zu sprechen: Webmaster werden für Werbeeinblendungen bezahlt und nicht für tatsächlich verkaufte Produkte. Und ich habe deutlich gemacht, dass auf meiner Webseite die Werbung ordnungsgemäß (nach AGB usw.) eingeblendet wird.

Dann kam wieder das Totschlag-Argument:

“Aufgrund unserer Daten müssen wir eben davon ausgehen, dass das nicht der Fall ist.”

Also aufgrund ihrer Daten müssen sie davon ausgehen, dass die Werbeeinblendungen auf meiner Webseite NICHT ordnungsgemäß eingeblendet werden. Eine andere Erklärung außer Manipulation meinerseits sei nicht möglich:

“(…), Ihre Daten lassen nur auf Manipulation schließen, aufgrund der Verkaufsstatistik.”

Oder nochmal anders:

“Ich hab nun mehrfach die Verkaufsstatistik angeführt, das ist ein konkreter Beweis dafür, dass nur Manipulation erfolgt sein kann.”

Das ist meiner Meinung nach eine lachhafte und unseriöse Begründung. Es ist einfach eine falsche Aussage, weil ich nichts manipuliert habe! Und es ist mir vollkommen egal, ob meine Besucher etwas von den Sponsoren kaufen, solange das nicht ansatzweise in den AGB von bin-layer.de oder sonst irgendwo erwähnt wird.

Natürlich habe ich nicht aufgegeben und weiterhin widersprochen und wollte den guten Mann erleuchten, aber dagegen war er resistent. Wenn ich davon überzeugt wäre im Recht zu sein, dann solle ich doch den Rechtsweg gehen und dann werde man vor Gericht alles beweisen. Natürlich wurde der Gute dabei auch immer unfreundlicher – zumindest ist das mein persönlicher Eindruck.

Fazit

Meiner Meinung nach wurde ich zu Unrecht gesperrt. bin-layer.de hat m.E. gegen seine eigenen AGB verstoßen. Die Existenz einer “Verkaufsstatistik” halte ich für fragwürdig.
Ich denke, dass sie einfach einen Grund gesucht haben, mich loszuwerden und die 65€, die sie mir noch nicht ausgezahlt haben, selbst einzustreichen. Das kann ich natürlich nicht mit Bestimmtheit sagen, deshalb nochmal für die Juristen: Das ist meine persönliche Vermutung. Ich hoffe, das ist verständlich. (Ich könnte es natürlich nochmal für diejenigen aufmalen, die besonders schwer von Begriff sind. Oder besser noch: Wie wäre es mit Vortanzen? Oder nicht doch besser ein Gedicht drüber schreiben?)

Als erste Konsequenz dieses Vorfalls habe ich diesen negativen Erfahrungsbericht geschrieben. Mit bestem Gewissen kann ich sagen, dass er der Wahrheit entspricht und dass ich weder über- noch untertrieben habe.
Außerdem wechsele ich nun zu der Konkurrenz: euros4click.de. Ich hoffe, dass die so seriös und zuverlässig sind, wie sie versprechen.
Abschließend noch ein paar Dinge:

• man sieht sich immer 2x im Leben (Rache ist süß)
• ich hoffe, dass dieser Artikel von möglichst vielen Menschen gelesen wird, auf dass sie nicht zu Unrecht bei bin-layer.de gesperrt werden, wie es mir meiner Meinung nach passiert ist
• ich werde versuchen, diesen Artikel bei Google so gut wie möglich zu platzieren
• wer ähnliche Erfahrungen gemacht hat, der soll das bitte in den Kommentaren schreiben oder diesen Artikel auf seiner eigenen Webseite verlinken!

Links

Diese Links sollen zeigen, dass ich mit meiner Kritik lange nicht alleine stehe:

• http://jollyroger.cc/newsflash/bin-layer-quo-vadis.html
• http://jollyroger.cc/newsflash/binlayer-gehts-noch.html
• http://jollyroger.cc/newsflash/bin-layer-am-rande-der-legalit-t.html
• http://board.raidrush.ws/archive/t-314183.html
• http://forum.layer-ads.de/partnerprogramme/6313-bin-layer-fuer-mich-pleite.html
• http://www.affiliate.de/forum/viewtopic.php?t=12078
• http://www.affiliate.de/forum/ftopic12452.html
• http://blog.darksoft-projects.de/2007/09/26/bin-layer-erstickt-im-agb-sumpf/
• http://blog.darksoft-projects.de/2007/10/07/bin-layer-will-nun-regelmasig-auszahlen/
• und viele mehr

Abgesehen davon: Die Deutsch-Prüfung am 10. war eher mäßig. Ich habe mich für einen Vorschlag mit zwei Gedichten zum Thema “Abend” entschieden. Das eine Gedicht war expressionistisch und das andere Gedicht war romantisch. Da das expressionistische Gedicht aber überhaupt keine expressionistischen Merkmale hatte, habe ich mir anfangs schwer getan. Irgendwie habe ich es dann gerettet, indem ich um 2 Ecken gedacht und damit doch noch ein Merkmal entdeckt habe. (Man muss mir ja erstmal das Gegenteil beweisen.) Trotzdem rechne ich alles in allem nur mit 5-10 Punkten. Sollte es mehr geben, ist die Freude dann umso größer.

Über eine andere Sache bin ich hingegen besonders (haha Wortspiel) froh: Meine besondere Lernleistung habe ich vorhin fertiggestellt und ausgedruckt. Es handelt sich um schätzungsweise 60-70 Seiten, wovon 31 Seiten normaler Text und die restlichen Seiten Python-Quelltext sind. Um den Quelltext farbig ausdrucken zu können, habe ich mir übrigens SciTE heruntergeladen… mit Openoffice oder MS Word war mir das leider nicht möglich.
Mit der besonderen Lernleistung fällt auf jeden Fall eine große Last von mir ab, denn ich gebe zu, dass ich in den letzten Wochen deswegen doch ordentlich im Stress war. Wenn man während der schriftlichen Abiturprüfungen noch eine besondere Lernleistung fertigstellen muss (die BeLL muss am letzten Tag der schriftlichen Abiturprüfungen abgegeben werden), dann geht es halt rund.

Die besondere Lernleistung inkl. Quelltext werde ich dann, wenn sich das Abitur dem Ende zuneigt, hier in meinem Blog veröffentlichen. Ich habe zwei umfangreiche evolutionäre Algorithmen programmiert, von denen ich zumindest den Algorithmus für das Traveling-Salesman-Problem niemandem vorenthalten möchte. Der hat nämlich einige sehr geile Funktionen… der andere Algorithmus ist natürlich auch sehr umfangreich, aber beim TSP geht es auch auf dem Bildschirm zur Sache (dank PyGame)…

Das Abitur besteht für mich jetzt nur noch aus 2 mündlichen Prüfungen: 1. Politik- und Wirtschaft-Prüfung irgendwann im Mai. 2. Präsentation zur besonderen Lernleistung Anfang Mai + Kolloquium.

Alles andere ist Kleinkram… ich bin also quasi fast ein freier Mensch! *JUBEL*

Für das sogenannte Traveling-Salesman-Problem soll ich außerdem im Rahmen dieser Lernleistung einen evolutionären Algorithmus schaffen.

Das Traveling-Salesman-Problem

Das Traveling-Salesman-Problem (TSP) ist einfach formuliert: Ein Handlungsreisender muss n Städte besuchen und am Ende zu seinem Ausgangsort zurückkehren. Gesucht ist die kürzeste Rundreise.

Viele schlaue und dumme Menschen haben sich auf der Suche nach einem effizienten Algorithmus jahrzehntelang den Kopf darüber zerbrochen. Einen Ansatz stellen die sogenannten evolutionären Algorithmen dar, die die Evolution als Vorbild haben.

Was ist ein evolutionärer Algorithmus?

Zitat Wikipedia:

“Ein Evolutionärer Algorithmus (EA) ist ein Optimierungsverfahren, das als Vorbild die biologische Evolution hat.”

Prinzipiell prozessiert ein evolutionärer Algorithmus eine Population mit n Individuen nach dem Vorbild der Evolution: “survival of the fittest”. Jedes Individuum stellt eine mögliche Lösung des jeweiligen Problems dar. Im Falle des TSP entspricht also jedes Individuum einer möglichen Rundreise.

Im Laufe des Algorithmus pflanzen sich außerdem je zwei Individuen fort und erzeugen ein Kind-Individuum nach Vorbild der Natur mittels Rekombination. Zusätzlich finden – ebenfalls nach Vorbild der Natur – mit einer bestimmten Wahrscheinlichkeit Mutationen statt, also z.B. (normalerweise) zufällige Veränderungen der Route.

Jeder Durchlauf eines evolutionären Algorithmus’ sieht also mehr oder weniger so aus:

• Entferne x Individuen aus der Population. (Zum Beispiel die beiden schlechtesten Routen.)
• Rekombiniere x-Mal zwei Individuen aus der Population. (Zum Beispiel die beiden besten Routen.)
• Wende mit einer bestimmten Wahrscheinlichkeit eine Mutation auf die Individuen an. (Zum Beispiel mit einer Wahrscheinlichkeit von 15%.)
• Wenn die maximale Anzahl von Durchläufen (Generationen) erreicht ist, beende den Vorgang, ansonsten starte einen neuen Durchlauf.

Die Güte bzw. Qualität eines evolutionären Algorithmus hängt vor allem von folgenden Faktoren ab:

• Populationsgröße
• Rekombinationsmethode
• Mutationsmethode
• Mutationswahrscheinlichkeit
• …

Ein evolutionärer Algorithmus für das Travelling-Salesman-Problem

Wie oben gesagt ist es meine Aufgabe für das TSP einen evolutionären Algorithmus zu programmieren. Als Programmiersprache habe ich mich für Python und als Entwicklungsumgebung für eclipse mit PyDev entschieden. (Damit lässt sich super arbeiten!)
Mit der Arbeit am evolutionären Algorithmus habe ich heute begonnen, und ich muss sagen: Ich bin bereits jetzt sehr zufrieden. Da die Güte des evolutionären Algorithmus – siehe oben – von vielen Faktoren abhängt, habe ich mich für eine Umsetzung entschieden, bei der ich all diese Faktoren leicht ändern kann.

Das ist mir ganz gut gelungen: Alle Parameter und Komponenten des evolutionären Algorithmus sind ganz einfach austauschbar. (Leider werde ich bis zum Erhalt meines Abiturs keine Quelltexte veröffentlichen. Der menschlichen Dummheit sind einfach keine Grenzen gesetzt und ich könnte mir vorstellen, dass man mir vorwirft, meine Arbeit aus dem Internet von einem “Robert Nitsch” kopiert zu haben.)

Nun folgt der schwierigste, aber wohl auch spannendste Teil meiner besonderen Lernleistung. Ich werde prüfen welche Parameter den besten evolutionären Algorithmus ausmachen und verschiedene Konfigurationen miteinander vergleichen. Natürlich wird auch eine Begründung nicht fehlen – also warum Konfiguration A besser ist als Konfiguration B.

Meine Arbeit und meine Ergebnisse muss ich abschließend in einem Skript dokumentieren und in einer Präsentation vorstellen. Meine Ergebnisse werde ich natürlich auch hier auf meiner Homepage festhalten, damit Schüler, die eine ähnliche Lernleistung erbringen, davon vielleicht profitieren können.

Für Tipps und Ratschläge bezüglich meiner besonderen Lernleistung bin ich natürlich jederzeit offen.

Heute morgen habe ich von “AntMe!” gelesen, einer Programmierumgebung, die man innerhalb von Microsoft®s .NET-Programmierumgebungen (IDEs) nutzen kann. Anscheinend kann man die zur Nutzung von “AntMe!” nötige Funktionalität nachträglich in eine beliebgie .NET-IDE integrieren (als Plugin o.ä.). Dann kann man offenbar (ich habe es noch nicht selbst probiert) die “Programmierung” eines Ameisenvolkes vornehmen, das im Anschluss gegen beliebige andere Ameisenvölker unterschiedlicher Programmierung antreten kann. Es gilt, Nahrung zu sammeln und ggf. zu kämpfen – nur einer übersteht auf Dauer die Konkurrenz. Der “Kampf” wird natürlich visuell veranschaulicht und man kann seinen Ameisen live beim Kampf zusehen:

© Microsoft

Was mich daran besonders fasziniert, ist die Idee, gegen die Ameisenvölker anderer Programmierer anzutreten und das eigene Ameisenvolk von mal zu mal zu perfektionieren. Im Moment bin ich deswegen dabei, Microsoft® Visual C#® 2005 Express herunterzuladen und zu installieren.

Alternativen zu AntMe!

Bis gerade eben habe ich Alternativen zu AntMe! ausprobiert – für Linux. Erstmal war es aufwändig, welche zu finden… dann fand ich Seed7 bzw. DNA Fight, konnte es aber leider trotz mehrerer Versuche nicht kompilieren (typisches Problem) konnte es aber erst nach dem Fertigstellen dieses Artikels erfolgreich kompilieren. Siehe dazu Kommentar 3 und folgende…
Nebenbei fand ich allerdings auch NERO, womit nicht das allseits bekannte Brennprogramm, sondern ein Spiel mit ähnlichen Funktionen und einem ähnlichen Spielziel, wie dem von AntMe!. Allerdings konnte ich auch hier die Linux-Version nicht zum Laufen bringen (diesmal konnte mein Packer das Archiv nicht entpacken)…

Wikipedia:

Im Spiel trainiert man Roboter, die für ihr Handeln vom Spieler entweder eine positive oder eine negative Bewertung bekommen. Gut bewertete virtuelle Genkonfigurationen haben eine höhere Chance, bei der simulierten Evolution mit einem anderen Gen verschmolzen zu werden.

> Offizielle Website von NERO

KI-Schlachtfelder mit dem Warcraft® 3 – Welteneditor…

Zum Abschluss hatte ich die Idee, ein Strategiespiel für mein Ziel zu zweckentfremden … dazu nahm ich Warcraft® 3 (bzw. die Erweiterung TFT) und erstellte mir im Welten-Editor eine sehr triviale Karte mit dem Titel “AI Wars” (deutsch: Krieg der künstlichen Intelligenzen), auf der 2 Spieler gegeneinander antreten konnten. Die 2 “Spieler” sind in Wirklichkeit die beiden künstlichen “Intelligenzen”. Man selbst kann nur zusehen (dafür gibt es 3 weitere Spielerslots).

Das Hauptfenster des Editors:

Damit auch überhaupt ein Kampf stattfinden kann, starten die KIs mit jeweils 15 Gold. Alle 15 Sekunden wird das vorhandene Gold in neue Einheiten umgesetzt. Die erste KI hat dabei ihr Lager in der oberen linken Ecke der Karte, die zweite KI genau gegenüber. Überdies hinaus haben beide KIs in ihrem Lager einen Brunnen der Gesundheit, an dem Einheiten sehr schnell geheilt werden können, falls sie verletzt sind.

Die KIs agieren hauptsächlich über einen Code, der alle 15 Sekunden ausgeführt wird. Dieser Code veranlasst z.B. alle Einheiten in der jeweiligen Basis zum aggressiven Vorrücken zur Basis des jeweiligen Gegners. Am Anfang rennen also sofort alle 15 Soldaten los und treffen sich in der Mitte mit den Einheiten des Kontrahenten. Da ein einzelner Code, der alle 15 Sekunden aufgerufen wird, allerdings weder eine ordentliche Programmierung zulässt, noch sehr viele Möglichkeiten zulässt, kann man natürlich jeder KI auch weitere “Auslöser” verpassen.

Ein Auslöser im Welten-Editor ist eine Einheit von Ereignissen, Bedingungen und Aktionen … als Ereignis kann z.B. ein Timer gelten, der alle X Sekunden ausgelöst wird. Im Welten-Editor von Warcraft® sind aber schier unendlich viele Möglichkeiten vorhanden… so kann man auch auf das “Angegriffenwerden” einer Einheit reagieren… und diese Einheit dann zum Gegenangriff oder Fliehen veranlassen. Wann immer ich also in diesem Artikel von einem “Code” rede, meine ich in Wirklichkeit einen oder mehrere Auslöser…

Der Auslöser-Editor:

Übrigens erhält eine KI für jeden feindlichen Soldaten, den sie tötet, 1 Gold, d.h. für jeden Soldaten, der getötet wird, erhält die KI einen eigenen Soldaten dazu. Damit eine KI deswegen nicht allzu schnell gewinnt, haben beide KIs in ihrem Lager einen starken Wachturm, der auf feindliche Einheiten schiesst und selbst sehr viel Leben (“Trefferpunkte”) hat. Es dauert also ein paar Minuten, bis sich das Spiel entschieden hat. Außerdem wird diese Karte von mir noch stark erweitert werden, sodass die KIs sich dann nicht nur bekämpfen müssen, sondern auch eine kleine Wirtschaft steuern müssen können. Dann relativieren sich die kleinen Vorteile beim Spielbeginn (wer zuerst zuschlägt usw.).

Das erste Anzeichen von Intelligenz…

Damit auch ich als Programmierer meinen Spaß habe, habe ich mir sogleich eine etwas überlegene KI geschaffen. Sie verfährt nicht mehr nur nach dem “Haudrauf”-Prinzip … jedes Mal, wenn eine Einheit einen Schlag kassiert, wird überprüft, ob diese Einheit noch mindestens 20% ihrer Trefferpunkte besitzt. Falls nicht, so rennt sie sofort zurück in die Basis zum “Brunnen des Lebens”, wo sie dann eine sehr hohe Regenerationsrate genießt. Sobald ihre Trefferpunkte auf über 90% der maximalen TP angestiegen sind, nimmt sie wieder an der Schlacht teil.
Dadurch werden gleich zwei Dinge erreicht: in der Basis steht immer eine kleine “Reserve”, die im Falle des Angriffes – obwohl sie natürlich geschwächt ist – dem Gegner etwas Kontra geben kann …
Außerdem, und das ist viel wichtiger, gelingt es der gegnerischen KI nun fast überhaupt nicht mehr, irgendwelche Soldaten zu töten. Damit versiegt also, zumindest in der jetzigen Version von “AI Wars”, die Hauptgeldquelle des Gegners…

Vorteile und Nachteile des Welteneditors für KI-Schlachten

Vorteile:

• nahezu unendlich viele Möglichkeiten der KI-Programmierung
• ebenfalls unendlich viele Möglichkeiten beim Gestalten der Umgebung/der Umstände
• eine äußerst schöne grafische Darstellung der Schlachten

Nachteile:

• beide Programmierer benötigen das Originalspiel
• das Spiel ist nicht plattformunabhängig (es läuft aber dennoch nativ sowohl auf Windows®- als auch Mac-Systemen)
• das Antreten zweier KIs ist etwas schwerfällig: man muss jedes Mal, wenn man 2 KIs gegeneinander kämpfen lassen möchte, die Karte editieren (die Auslöser des anderen Programmierers importieren und die eigene KI hineinepfriemeln…)

Solange es keine bessere Lösung gibt, werde ich diese Methode weiter ausfeilen und die Möglichkeiten des Warcraft – Welteneditors so gut es geht ausschöpfen. Da ich bisher nicht eine einzige Karte mit diesem Editor erstellt habe, ist das auch gleich eine gute Gelegenheit für mich, mich damit auseinanderzusetzen. Und wie man an den Screenshots und meinem Gerede erkennt, ist es gar nicht so schwer, wenn man sich ein paar Stunden Zeit nimmt (oder sie einfach hat).

Download der Karte

Für diejenigen, die bis hierher gelesen haben und sich trotzdem im Besitz von Warcraft 3 (+Erweiterung TFT!) befinden, biete ich meine Warcraft-Karte zum Download an. So könnt ihr auch gleich sehen, wie ich bestimmte Dinge realisiert habe. Ich würde mir sowas als Leser auf jeden Fall wünschen.

Download: AI Wars 1.00

Wer eine KI schreibt, die gegen meine KI gewinnt (“KI 1″ bzw. Spieler 11 stellt meine KI dar, KI 2 ist die dumme “Haudrauf”-Truppe), der darf mir seine KI natürlich gerne zukommen lassen. Dann werde ich meinerseits eine bessere KI schreiben und sie zurückschicken.

AI Wars mit Python

Ich träume im Moment von einem Python-Modul, mit dem man AI Wars ausführen kann – 2 ambitionierte Pythonprogrammierer lassen dann ihre künstlichen Intelligenzen gegeneinander antreten – das Modul gibt lediglich die Schnittstelle und damit auch die Spielregeln vor… außerdem ermöglicht es auch gleich die grafische Ansicht des “Kampfes”.

Innerhalb der nächsten Tage werde ich mich diesem noch nicht existenten Modul mal annehmen … zuerst überlege ich mir aber ein geeignetes Szenario für meine “AI Wars”. Für Vorschläge bin ich jederzeit offen – ich würde mich sehr über Ideen und Ratschläge freuen!