Was bisher geschah

Die Anfänge

Am Anfang, das war so 1988, wollte ich mal etwas schaffen, mit dem man mithilfe von Programmablaufplänen programmieren konnte. Bald stellte sich mir die Frage, was soll in die Kästchen rein geschrieben werden? C? Pascal? Oder was Eigenes?
Ich war begeisterter TurboPascal Programmierer, was Anfang der Neunziger darin gipfelte, dass ich als meine Autonummer WI-TP60 wählte, nach der Objekt-orientierten Version Turbo Pascal 6.0. Aber im Laufe der Zeit nervte mich die Wirtsche Stringenz von Pascal mehr und mehr. Auch schien mir Borland immer mehr den roten Faden zu verlieren. Und den Sprung von DOS nach Windows, haben sie meiner Meinung nach völlig vermasselt (Keine Ahnung, ob etwa Delphi eine Renaissance ist, habs nie ernsthaft probiert).
Ich hatte zu der Zeit im Rahmen meines Jobs Zugriff auf richtig fette IBM-Rechner. Dort fand ich REXX (die IBM-Großrechner-Variante - nicht dieses lahme OS/2-Ding!). REXX hat sowas wie Strukturen ("Stems"), viele sehr clevere Stringverarbeitungsfunktionen und war - technikbedingt -schweinegrottenschnell. Es war als Commandosprache angelegt und bot so auch sehr schöne Möglichkeiten für Metaprogrammierung ("interpret"). Das wiederum brachte die nötige Flexibilität ins Spiel. Genervt hat lediglich die Fehlersuche manchmal, da REXX schwach getyped war.
Jedenfalls konnte ich damit Experimente machen, mit eigenen Vorstellungen von Objektorientierung. Das war schon mal sehr inspirierend.

Es hat einen Namen!

Dann - 1994 - lernte ich C++ kennen. Ich ließ Turbo Pascal und REXX hinter mir und fing an, "Reni", wie ich es schon damals nannte, in C++ zu bauen. Zuerst mit Borland C++ und später dann mit MS Visual C++.
Warum es "Reni" heißt? Vermutlich hat es mit einer nicht richtig bewältigten Frauengeschichte zu tun. Mehr sag ich dazu nur meiner Psychotherapeutin...
Mittlerweile hatte ich für mich die Frage beantwortet, was die Kästchen enthalten sollten: C (wie auch C++) hat eine mir zu kranke Syntax. Pascal war mir zu unpraktisch (Dito Modula). REXX war nicht getyped. Smalltalk war mir zu alt und zu komisch (LISP genauso). Und so weiter und so fort. An allen Sprachen hatte ich etwas rum zu mäkeln. Es ist mir natürlich bewußt, das ist alles sehr subjektiv.
Alles lief also darauf hinaus, meine eigene Programmiersprache zu entwickeln.
Kurz darauf kam für mich noch ein weiteres Argument dazu: Java. Für meine Vorstellung ist Java entstanden, indem man Smalltalk-Semantik mit C-Syntax versehen hat. Damals dachte ich, man sollte eigentlich genau umgekehrt vorgehen. "Richtige Speicherverwaltung", nicht Garbarge Collection - und - eine ordentliche Syntax. (Dabei hatte ich ein bisschen außer Acht gelassen, daß Syntax von Smalltalk auch nicht so richtig toll ist.) Auf jeden Fall gab das noch einen zusätzlichen Motivationsschub.
In den folgenden 10 Jahren nutzte ich meine sich entwickelnde Programmiersprache, um mein C++-Kung-Fu zu perfektionieren. Man muß das so sagen, denn scheinbar war mir "es schön zu machen" immer wichtiger, als fertig zu werden. Ich konzentrierte mich auch komplett auf den "linearen" Teil, also das, was in die Kästchen reinkommt. Die graphische Komponente hatte (und habe) ich ziemlich aus dem Fokus verloren.

Scharfe Konturen zeigen sich

Schließlich kam C# in die Welt - Die Microsoft-hat-die-Nase-voll-von-Java-Sprache. Java hat auch mich immer echt genervt. Das war für mich immer eine Sprache für Leute, die es auch mal mit Programmieren versuchen wollten. Aber C# dagegen hatte schon was. Es war nicht C++, aber immerhin. Als ich dann auch noch beruflich damit zu tun hatte, war ich hin und weg. Aber was mich ehrlich gesagt am meisten begeisterte waren die Sachen drumherum. Die IDE, die Dotnet-Bibliotheken und "the great and still growing" Resharper.
Nebenbei war ich mittlerweile auch von C++ etwas genervt, aber wiederum weniger von der Sprache selbst, als vielmehr vom Support innerhalb Visual Studio (Über die anderen IDEs will ich gar nicht reden, die spielen alle mindestens eine Liga tiefer). Z. B.: wer braucht ein IntelliSense, das nur funktioniert, wenn keine Fehler vorliegen?
Also schrieb ich dann den Compiler in C# um und machte damit weiter.
Und wieder ging es mehr ums Kung-Fu als ums fertig werden...
Mittlerweile bekam ich auch bei immer mehr Teilen des Compilers ein Gefühl von Ultimativität. Der Parser, der zentrale Syntaxbaum-Visitor und die Namensauflösungs-Strategie haben sich in einer Weise stabilisiert, dass ich es ziemlich genauso wieder designen würde, müsste ich wieder bei null anfangen.

In welchem Universum bin ich - zum Kuckuck?

Jedoch sind meine Lösungen ziemlich weit von dem entfernt, was ich mal als Compilerbau gelernt hatte. Wenn ich versuche, mir Hilfe aus Büchern zu holen, muß ich regelmässig feststellen, dass das alles nahezu nichts mit den Problemen zu tun hatte, die sich mir stellen. Zum Beispiel lex und yacc: die lösen derart unbedeutende Probleme, das man sich fragt, ob die mit ihnen einhergehende Verkomplizierung des Compilierprozesses wirklich das kleinere Übel ist. Mehrere Anläufe im Laufe der Jahre endeten immer mit dem Urteil: "Was fürn Scheiß". Und wie man einen Visitor baut, der kontextabhängig durch den Syntaxbaum marschiert, wenn die Ausdruckstypen nicht nur vom Syntaxelement sondern auch vom Kontext abhängen, hab ich auch nirgendwo gefunden. Wie machen die anderen das, wenn es Templates oder Generics oder wie auch immer die Dinger sonst heißen, gibt. Vermutlich ist das geheimes Druidenwissen.

"Kein Plan überlebt die erste Feindberührung"

Naja, mal sehen, was passiert, wenn ich es schaffe, dass eine größere Community da drauf guckt. Stellt sich dann raus, dass ich die ganze Zeit auf dem falschen Dampfer bin?
Ich hoffe nicht.
Ich hoffe, ich habe genial neue Methoden gefunden.
So genial und neu, dass ich damit in die Geschichte eingehen werde.