Und wieder bin ich knapp zu spät und hab meinen Sonntag verpasst. Naja. Diejenigen die tatsächlich meine Posts lesen dürften wissen, dass ich zwar jeden Sonntag poste, aber nur vielleicht jeden dritten Sonntag etwas interessantes. Oder so.

Neues gibt es von der VISlib zu berichten: die VISlib hat nun ihren Release 1.0 erreicht!

Damit hat sie auch ihren finalen Entwicklungsstand erreicht. Auf Basis des Release 1.0 werden wir lediglich Bugs fixen. Neue Funktionalität werden wir keine mehr einführen. Stattdessen führen wir im Trunk des VISlib-Repositories das The.Vislib.Legacy-Project durch. Dahinter verbirgt sich eine stufenweise Migration zur TheLib.

Letzte Woche hab ich schon über Legacy-Code geschrieben. Das Thema ist beständig.

Eigentlich gibt es zwei Sichtweise auf Legacy-Code:

  1. Die Einen halten Legacy-Code für einen Schrotthaufen den man unbedingt los werden muss.
  2. Die Anderen halten Legacy-Code für eine Goldgrube die man unbedingt nutzbar machen muss.

Die Wahrheit ist nicht, wie so oft, irgendwo dazwischen, sondern schlicht und ergereifend: beides ist wahr! Legacy-Code ist ein Schrotthaufen voller Gold! Das Gold muss man nutzbar machen und den Schrott muss man los werden. Das ist natürlich aufwändig und so darf man nicht gierig werden. Mit jedem Projekt sollte man ein kleines bisschen Schrott los werden und ein kleines bisschen Gold freilegen. So wird mit der Zeit alles gut.

Für die TheLib haben wir dieses Problem natürlich auch! Um die „kleinen Schritte“ durchzuführen, von denen ich grad geschrieben habe, haben wir das Projekt the.vislib.legacy gestartet.

Immer wenn man an einer Software arbeitet die nicht trivial oder klein ist, dann arbeitet man unweigerlich auch mit Legacy-Code. Damit meine ich Quelltexte die alt sind. Entweder will man sie ersetzen oder auch nicht, aber sie mit dem neu entstehenden Code zu verheiraten ist nie einfach. Im Besonderen, wenn man Interfaces nach außen hat, z.B. zu anderer Software, welche zumindest Teile der eigenen Software benutzt. Bei solchen Aufgaben zeigt sich, ob man sein Handwerk versteht. Damit meine ich nicht programmieren. Das ist einfach und kann praktisch jeder lernen. Ich meine Software-Entwicklung, Design und Architektur.

Ich arbeite zusammen mit Freunden an dem Aufbau der THElib, als Nachfolger und Ersatz der VISlib. Vor allem wollen wir einige Design-Fehler beheben die in der VISlib drin sind und wir auch nicht mehr raus kriegen, eben wegen zu starken Abhängigkeiten zu weiterer Software. Natürlich schreiben wir die THElib nicht komplett neu. Sie basiert zu sehr großen Teilen auf dem Code der VISlib, lediglich entschlackt und korrigiert. Aber hier sehen wir uns einer sehr großen Basis von Legacy-Code gegenüber die wir behandeln müssen. Es ist einfach nicht einfach.

Mein vielleicht wichtigstes Programmierprojekt für meine privaten Projekte und für meine Arbeit ist thelib_icon16 TheLib. Die Idee ist einfach in dieser Lib Klassen zu sammeln die wir (zwei Freunde und ich) geschreiben haben und immer und immer wieder in unterschiedlichen Projekten benutzen. Diese Klassen sind üblicherweise Wrapper um API-Aufrufe oder andere Libraries (z.B.: STL, Boost, und alle anderen) für einfachere Bedienung oder bessere Kompatibilität untereinander. Aus dieser Idee kommt auch der Name unserer Lib: TheLib – Totally Helpful Extensions (Total Hilfreiche Erweiterungen). Außerdem ist es einfach cool #include "the/exception.h" zu schreiben.

Was ich mir aber immer wieder anhören muss: „Warum schreibst Du eine Lib? Es gibt doch schon jede Menge Libs für alle Aufgaben.“

Nun, wenn das wahr wäre, dann würde keiner von uns mehr Programme schreiben, sondern wir würden alle nur noch Programme aus fertigen Libs komponieren. Das machen wir aber (noch) nicht. Zumindest, ich mache das nicht. D.h. TheLib ist tatsächlich hilfreich. Sie ist kein Ersatz für die ganzen anderen Libs, sondern nur eine Ergänzung, eine Erweiterung.

Ein Beispiel: Strings!

Die String-Funktionen in TheLib sind nicht annäherend so mächtig wie sie sein müssten um einen Texteditor zu schreiben. Sollen sie auch nicht sein. Wir haben diese Funktionen geschrieben und etwas über die Basisfunktionen hinaus zu gehen. Die Idee ist es über einfache Funktionen Anwendungen die Möglichkeiten zu geben einfach zu bedienende Benutzungsschnittstellen zu implementieren.

Vor allem unter Linux (aber auch unter Windows) gibt es im Prinzip drei unterschiedliche Typen von Strings:

  1. char * und std::string speichert ASCII oder ANSI Strings die von der lokalen Spracheinstellung des System abhängen,
  2. char * und std::string speichern Multi-Byte-Strings, z.B. im UTF-8-Format, und
  3. wchar_t * und std::wstring speichern Unicode Strings.

Je nach entsprechendem Stringtyp sind unterschiedlichen API-Aufrufe notwendig, z.B. um die Länge des Strings zu ermitteln::

  1. strlen
  2. mehrere Aufrufe von mbrlen
  3. wcslen

Ein Problem ergibt sich nun bei den Fällen 1. und 2., da moderne Linuxe oft eine Spracheinstellung benutzen welche UTF-8-Strings in den Standard-Strings ablegen. Solange strings nur geschrieben, gespeichert und dargestellt werden ist das eine tolle Möglichkeit Abwärtskompatibilität zu erhalten und einen vollen Unicode Zeichensatz zu unterstützen. Allerdings, sobald etwas komplexere Aktionen durchgeführt werden sollen (sowas wie einen Teilstring auswählen) verhalten sich Implementierungen auf diesem Ansatz fehlerhaft, da sie die UTF8-Multi-Byte-Zeichen als mehrere einzelne Zeichen interpretieren.

Beispiel:

  • Der Benutzer ist ein Geek und gibt „あlptraum“ als Eingabe ein.
  • Das System benutzt utf8-en als lokale Spracheinstellung und speichert den String in einem std::string.
  • Deine Anwendung will nur das erste Zeichen haben, z.B. um es als typographische Initialie darzustellen.
  • Der normale Ansatz ist nun char* first_char = s[0]; und std::string remaining = s.substr(1);
  • Da das japanische  „あ“ aber zwei Bytes benutzt ist das Ergebnis: „0“ + „Blptraum“

Das Problem gilt nicht nur für japanische Zeichen, sondern logischerweise potentiell für alle Zeichen die nicht im 7-Bit ASCII abgedeckt sind. Schlimmer noch: das Problem existiert für alle Operationen die zeichenweise arbeiten, z.B. auch Vergleiche ohne Berücksichtigung von Groß-Klein-Schreibung.

Beispiel wie ein String zu Kleinbuchstaben konvertiert wird:

// Zuerst machen wir es wie die STL es vorschlägt
// http://notfaq.wordpress.com/2007/08/04/cc-convert-string-to-upperlower-case/

std::string data;
// Der Inhalt von 'data' wird nun auf "あlptraum" gesetzt und das System benutzt utf8-en als Spracheinstellung

std::transform(data.begin(), data.end(), data.begin(), ::tolower);
// Und nun ist der Inhalt von 'data': "0blptraum"
// ...

Um das Problem zu vermeiden initialisiert TheLib die System-Spracheinstellung für die Anwendung und erkennt ob eine UTF-8-Einstellung benutzt wird. Ist das der Fall, dann benutzt TheLib für alle API-Aufrufe die Varianten für Multi-Byte-Strings und die Ergebnisse entsprechen der Erwartung. Zusätzlich bietet TheLib explizite Funktionen zur Konvertierung nach und von UTF-8-Strings (z.B. für Dateizugriffe).

Natürlich braucht man TheLib nicht und das Problem zu lösen. Es gibt andere Libs (vermutlich. Ich kenne nur die IBM-Unicode-Lib, aber die scheint mir ein riesiges Ding zu sein) oder man kann sich selber Workarounds schreiben oder man ignoriert das Problem, weil es bei „den eigenen Anwendungsfällen nicht auftreten wird“. Wie dem auch sei, die TheLib das einfach machen zu lassen ist einfach praktisch. Mehr ist da nicht dahinter.

Mist! Ich wollte doch jeden Sonntag posten. Naja, ich versuche diese Ausrutscher minimal zu halten und möglichst immer gleich nach zu holen.

Eine Neuigkeit: Das TheLib-Projekt benutzt nun ein Subversion-Repository!

Nachdem Mercurial sich absolut nicht bewährt hat war unsere Experimentierfreude aufgebraucht und wir sind lieber auf einem System umgestiegen, von dem wir wissen dass es tut und wie es tut.

Natürlich gib es viele Projekte die mit Mercurial super toll funktionieren und natürlich gibt es viele Gründe warum alles mit Git besser wäre. Ganz ehrlich: Ist mir egal.

Die Arbeit an der TheLib geht weiter.

Eins habe ich in meiner bisherigen Arbeit als Entwickler von Forschungssoftware gelernt: große Softwareprojekte an Universitäten sind extrem schwierig durchzuführen. Hauptsächlich weil alle beteiligen Personen „Forscher“ sind und keine „Entwickler“. Es fehlt die Erfahrung, es fehlen die Prozesse und es fehlen die Strukturen um gemeinsame Ziele (Kompromisse) zu definieren. Gleichzeitig gibt es einfach Aufgaben, die durch kleine Programme nicht zu lösen sind. Als Ergebnis ist die meiste Software die im Rahmen von Forschungsprojekten an Universitäten entstehen nicht praktisch einsetzbar. Ein Zustand, mit dem ich mich nicht abfinden will.

Der Ansatz den wir mit TheLib verfolgen basiert auf der Idee von „Divide and Conquer“. Anstatt eine große Software zu entwickeln und zu warten die alles kann, konzentrieren wir uns auf kleinere Bestandteile der Software und steigern die Nutzbarkeit, Wartbarkeit und dadurch die Wiederverwendbarkeit dieser Komponenten. Die TheLib stellt Basisklassen zur Verfügung. Ich sehe das Projekt als „Ergänzung“ zu den bestehenden Projekten wie die STL oder BOOST an. Es ist keine Konkurenz und will auch keine sein. Darum achten wir auf eine extrem hohe Kompatibilität mit diesen Projekten.

Und, obwohl die TheLib in ihrem Ziel und Umfang recht bescheiden gehalten ist, macht sie uns schon sehr viel Arbeit. Naja. Aber das gehört dazu. Wenn es einfach wäre, dann könnte es ja jeder. ;-)

Das Jahr 2012 ist fast vorüber. Ich möchte die Gelegenheit nutzen um ein bisschen zu rekapitulieren. Ok, ok. Jahresrückblicke mag niemand (ich auch nicht), aber trotzdem.

Anfang des Jahres hab ich meine Dissertation verteidigt. Damit ging auch meine Arbeit am Visualisierungsinstitut der Universität Stuttgart zu Ende. Aber nur meine Arbeit „am“, nicht meine Arbeit „mit“. Ich bei weiterhin auch fleißig im Kontakt mit den „Stuttgartern“ und wir haben noch viele spannende „heiße Eisen“ im Feuer.

Dann bin ich nach Dresden gezogen und hab an der Technischen Uni Dresden meine neue Stelle angenommen, als Post-Doc in der Nachwuchsforschergruppe VICCI. Die Stadt ist toll und die Gruppe ist super. Ich hab viel Spaß bei der Arbeit und auch hier laufen Forschungsprojekte für die ich mich begeistern kann.

Was noch? Die TheLib wurde gestartet. Zusammen mit zwei Freunden und ehemaligen Kollegen aus Stuttgart hab ich mich daran gemacht die Fehler der VISlib zu beheben, in dem wir eine neue, bereinigte Lib aus der Taufe heben. Es gibt da viel zu tun, aber ich bin mir sicher es lohnt sich.

Und natürlich ist da noch mein privates Spiel-Projekt: Springerjagt. Auch wenn ich schon letztes Jahr angefangen hatte an den Regeln zu feilen, so hat das Spiel dieses Jahr seinen Namen gekriegt. Und seine Webseite, auch wenn da nicht viel zu sehen ist. Aber, dass ich definitiv ein Projekt was ich auch weiterhin verfolgen will und werde.

Womit wir eigentlich auch schon bei den Vorsätzen für das neue Jahr sind (auch wenn noch 1-2 Tage dafür Zeit ist): Eigentlich nur, dass ich mein Bestes geben werde, damit 2013 genau so gut und erfolgreich verläuft wie 2012. Nein, sogar noch besser! Konkretere Pläne braucht es da gar nicht :-)

So, und weil ich nicht vor habe zu Neujahr extra noch einmal zu posten, wünsche ich euch jetzt:

„Einen guten Rutsch ins neue Jahr!“

Das TheLib Projekt wurde am 22.3. gestartet.

Es handelt sich dabei um den Nachfolger der VISlib, eine offene Bibliothek von Totally Helpful Extensions für C++ und C# mit dem Fokus auf wissenschaftliche Visualisierung. Die TheLib entsteht als Kooperation zwischen dem Visualisierungsinstitut der Universität Stuttgart und der Professur für Computergraphik und Visualisierung an der TU Dresden. Source Code und Error Tickets werden SourceForge gehosted.

Ich bin gespannt, wie sich dieses Projekt entwickelt.