Automatische Informationen

Seit Ende November lese ich in der Heilbronner Dammgrundschule den Schülern der Klasse 4b vor. Alle Kinderohren hörten mir von Beginn an gespannt zu. Ja, sie hörten zu, denn nun ist das Schuljahr vorbei. Aber der letzte Vorlesetag war noch einmal besonders schön. Nicht nur wegen den netten kleinen Erinnerungsmappe, die sie mir schenkten. Sondern auch, weil alle am letzten Tag unbedingt noch einmal mir vorlesen wollten. So wie wir das in den letzten Wochen immer gemacht hatten. Das hat mich riesig gefreut.

Und so sage ich tschüss. Tschüss, Alper, Beyzanur, Cihan, Diana, Ebrar, Edona, Enes, Faruk, Ilirida, Jil, Kemal, Kerime, Kimberly, Lejla, Mert, Mervisa, Nico, Nikola, Semanur, Silvana, Siyabent, Umut und Zilan.

Es war mir eine Freude, euch vorlesen zu dürfen. Denn auch ich habe viel bei euch gelernt.

Und, wie sagte Kimberly mir noch zum Abschied, bevor ich eine kleine Träne verdrücken musste? “Wir sehen uns bestimmt wieder!”. Das werden wir.

PS: Das nächste Schuljahr kommt bestimmt. Welche Klasse es wohl diesmal wird?

Vor einigen Tagen bin ich über ein kleines Artefakt gestolpert, dass den ersten erfolgreichen Lauf des ersten von mir erstellten Programms dokumentiert. Am 18. Juli 1980 durchsuchte mein erstes Programm eine bestimmte Festplatte nach sog. Lademodulen und listete diese auf, mitsamt Übersetzungsdatum und -uhrzeit. Von einem Hello World wusste ich damals noch nichts, sonst hätte ich mir nicht so viel Mühe mit diesem Programm machen müssen ;-)

Über eine gehörige Portion Vitamin B organisierte ich mir ein Praktikum über die Sommerferien in einem Rechenzentrum. Zwei Monate zuvor entschied ich für mich, dass ich was mit Informatik machen wollte (“Wenn Sie gut in Mathematik und Physik sind, dann könnte Ihnen Informatik gefallen”, las ich im Buch der Ausbildungsberufe und Studienfächer).

So saß ich im Juli 1980 im viel zu großen Büro des Abteilungsleiters. Ich war alleine dort, er war im Urlaub. Mein Betreuer knallte mir zwei dicke Ordner auf den Tisch. Er meinte noch: “Das sind programmierte Unterweisungen über Computer und deren Programmierung. Die können Sie ja mal durcharbeiten” und ließ mich allein. Jede dieser “programmierten Unterweisungen” (heute würde man sagen: e-learning book ohne e-) sollte innerhalb von zwei Wochen durchgearbeitet werden. Es fing mit einer Definition eines Bits an und hörte mit den Tiefen der COBOL-Programmierung auf. Na toll, mein Praktikum sollte nur drei Wochen dauern.

Dank ein paar Überstunden war ich schon nach zwei Tagen fertig. Gut, mein Gehirn fühlte sich wie ein Kaugummi an. Und ich hatte wohl auch die eine oder andere Übung übersprungen. So gerüstet ging ich am dritten Tag zu meinem Betreuer und fragte nach einer Programmieraufgabe. Er meinte, es soll etwas nützliches sein und bei Ihnen würden alle sowieso in COBOL programmieren. JCL würde er mir teilweise zeigen, aber ich müsste noch eine dieser programmierten Unterweisungen durcharbeiten. Zum Glück hatte ich darin schon Routine.

Das nützliche Programm sollte eine ganze Festplatte nach Lademodulen durchsuchen und diese auflisten. Ein Lademodul ist in etwa das, was heute eine dynamische Programmbibliothek ist. Aber auch vollständige Programme wurden in Lademodule übersetzt. Auf der Festplatte waren die Lademodule durch eine bestimmte Bytefolge gekennzeichnet und einige 130 Byte später war deren Übersetzungsdatum und -uhrzeit abgelegt. Algorithmisch nicht zu komplex, aber dummerweise ging auch nichts anderes als eine sequentielle Suche auf dem Raw Device. Na ja, immerhin waren die Platten damals nur ca. 10 MiB groß. Ach ja, das Ganze lief natürlich unter MVS.

So schrieb ich denn mein erstes Programm. Schrieb ist genau richtig, denn alle dortigen Codierer schrieben ihre Programm in ein Papierformular. Die angestellten Codierer durften dann die Formulare im Schreibbüro abgeben, in dem so ca. 20 Schreibkräfte das geschriebene Programm in Lochkarten umwandelten. Diese wurde dann beim Operator abgegeben und schon nach einem Tag hielt man das Ergebnis des Übersetzungslaufes in Händen. Ich durfte mein Programm nicht im Schreibbüro abgeben, sondern musste selbst Lochkarten auf einer Uraltmaschine stanzen, die kein anderer benutzen wollte. Ein Tippfehler bedeutete mit einer neuen Lochkarte von vorne beginnen zu müssen.

Ich weiß nicht, wie lange ich im Kämmerchen mit dem Lochkartenstanzer zubrachte. Aber endlich, nach ein zwei Korrekturläufen wurde mein Programm vom Compiler übersetzt. Pro Korrekturlauf verging mindestens ein halber Tag, aber der Operator hatte ein Einsehen und priorisierte meine Eingaben etwas höher ;-). Ein Fehlerchen war noch zu beheben und vor etwas mehr als 30 Jahren lief mein erstes Programm erfolgreich.

Jeder, der das erste eigene ernsthafte Programm fertig gestellt hat, kennt dieses Gefühl: Herrscher über eine Maschine. Extrem befriedigend und motivierend.

Der Rest des Praktikums war für mich dann nur noch Kür. Einige Tage im Operating arbeiten, an den netten Bandstationen. Und zwei weitere kleine Programme durfte ich dann auch noch schreiben. Das zweite an einem Lochkartenstanzer mit Zeilenpuffer. Ade Tippfehler! Das dritte sogar an einem Bildschirmterminal. Wow! Aber was diese Programme taten, weiß ich nicht mehr. Ich glaube, dass dritte Programm rechnete Zylinder- und Satzgrößen in Blockgrößen um. Oder umgekehrt. Egal.

Ja, lang ist’s her. Und der Weg von damals auch.

Gestern durfte ich an einer sehr interessanten und teilweise emotionalen Diskussion teilnehmen. Es war der Abschlusstermin der diessemestrigen Projektstudie Softwareentwicklung, von mir großspurig Retrospektive getauft. Ob es wirklich eine Retrospektive war sei einmal dahin gestellt. Auf jeden Fall haben wir uns über Bewahrenswertes, Verbesserungswürdiges und Bemerkenswertes unterhalten.

Ich möchte hier einmal die Ergebnisse zusammenstellen und ggf. kommentieren.

Auf jeden Fall möchte ich allen danken, die dafür gesorgt haben, dass eine Diskussion zu Stande gekommen ist. Da kann ich noch so “nett” sein. Letzten Endes ist es meine Aufgabe, die Arbeiten zu bewerten. Um so schöner finde ich es, dass wir es in diesem Semester zu einer offenen Diskussionskultur geschafft haben.

Danke schön!

So, nun die Punkte, die wir angesprochen haben. Meine Bemerkungen sind kursiv gekennzeichnet.

Bewahrenswertes

Teambildung

Die Zusammenstellung der Teams nach dem Zufallsprinzip wurde von allen positiv gesehen. Dadurch haben sich neue Bekanntschaften gebildet, insgesamt haben sich alle näher kennen gelernt.

Das Vorgeben (und Annehmen) von projektspezifischen Rollen führte nach Meinung der Teilnehmer zu einer professionellen Arbeitsweise, die sich von der üblichen Gruppenarbeit erheblich unterscheidet.

In diesem Semester kam es zum ersten Mal zu einer umfangreicheren Zusammenarbeit zwischen den Projektteams. Fehlten in einem Team bestimmte Kompetenzen, so halfen Mitglieder eines anderen Teams aus.

Das sehe ich auch so positiv. Das liegt aber nur zum Teil an der Umgebung, die ich bereit gestellt habe. Zum größten Teil ist das das Werk der Teilnehmer. BTW, heute habe ich einen interessanten Artikel über Gruppen- vs. Teamarbeit gelesen, der passt gut zur Situation der Projektstudie ;-)

Regularien

In der Projektstudie wurde nicht nur die Art und Weise vorgegeben, wie sich die Teams zusammensetzen. Neben der Festlegung auf bestimmte Werkzeuge (Trac, Mercurial) wurden weitere “Spielregeln” von mir definiert. Dazu gehörten wöchentliche Statusreports, Protokollierung aller Besprechungen, Verwendung des Ticketsystems, u.s.w.

Diese Vorgaben sollen beibehalten werden, evtl. sogar ausgebaut werden, um einen der verbesserungswürdigen Punkte, die Arbeitsbelastung, abzumildern.

Ich bin immer wieder erstaunt, wie gut feste Regeln ankommen. Zuerst denke ich, dass diese als Einschränkung empfunden werden. Im Laufe des Semesters stellt sich heraus, dass diese Regeln eher helfen. Daher werde ich in Zukunft die Regularien im Sinne von Hilfestellungen weiter ausbauen. Angedacht (und von Ihnen bestätigt) sind: definiertes “Standardteam” (1 Projektleiter, 1 Dokumentator, 1 Qualitätsmanager, Rest Entwickler), definierte Entwicklungsumgebung (Maven, Hudson, Mercurial, Trac), definierte Ablaufumgebung (Portal Server), weitere Vorlagen.

Organisatorisches

Die regelmäßigen Präsenztermine wurden positiv aufgenommen. Wir haben uns zu den festen Terminen in der großen Gruppe getroffen, offene Punkte gemeinsam besprochen, ggf. haben einige ihre Arbeitsergebnisse präsentiert und anschließen haben die Projektteams separat gearbeitet.

Dadurch wurde ereicht, dass sich jedes Projektteam regelmäßig getroffen hat, offene Punkte schneller erkannt und behoben wurden. In normaler Gruppenarbeit passiert es oft, dass man sich zu selten trifft und erst gegen Ende entdeckt: die Einzelteile passen nicht zusammen.

Ebenfalls wurde positiv angesprochen, dass ich während der Präsenztermine (und darüber hinaus) ansprechbar war. Mein “Management by walking around” hat vielen Teams weitergeholfen. Das sollte nach Ansicht der Teilnehmer ebenso bewahrt werden, wie der Einsatz eines studentischen Coaches.

Dieser Coach hatte angeregt, dass sich alle Projektleiter gerade in der ersten Zeit zu einem Erfahrungsaustausch treffen. Auch dieses Vorgehen hat vielen geholfen. Solche teamübergreifenden Treffen sollen zukünftig auch für andere Rollen (Entwickler, Qualitätsmanager, …) stattfinden.

Es freut mich, dass mein Herumlaufen nicht als Spitzelversich gewertet wurde, sondern eine Hilfe war. Auch in Zukunft werde ich versuchen, einen studentischen Coach zu finden, der den Teilnehmern die Hemmschwelle mindert, zu fragen und ggf. zu eskalieren. Die übergreifenden Besprechungen halte ich für eine sehr gute Idee.

Inhaltliches

Ingesamt wurde der Lerneffekt der Projektstudie als groß eingestuft. Im Grundstudium wurden eher theoretische Inhalte gelernt, die nun angewendet werden konnten. Trotzdem wurden auch die eher theoretischen Inhalte dieses Semesters als nützlich für die Projektstudie anerkannt. Die Teilnehmer äußerten, dass sie sich selbst besser kennengelernt haben, insbesondere auch was ihre eigene fachlichen Ziele betreffen.

Seufz, das ist das Ziel der Projektstudie. Und wenn das erreicht ist, bin auch ich zufrieden ;-).

Verbesserungswürdiges

Arbeitsbelastung

Die Arbeitsbelastung wurde von sehr vielen als zu hoch angesehen. Einige meinten sogar, dass man sich in diesem Semester zwischen der Projektstudie und sonstigen Prüfungen entscheiden müsste. Es gab aber auch Stimmen, die meinten, die Belastung sei hoch, aber nicht zu hoch gewesen.

Sicher ist die Arbeitsbelastung bei einer Projektstudie nicht unerheblich. Die Projektstudie ist mit 6 Credits bewertet, dass sind 180 Stunden. De facto kommen noch die 2 Credits von Projektmanagement 2 hinzu, dass man auf eine Nettoarbeitszeit von einem Monat kommen kann.

Ich denke, die Gründe für die als hoch empfundene Arbeitsbelastung sind vielfältiger Natur. Zunächst einmal ist es die erste Projektstudie im Studium. Vorher wurden Vorlesungen und Übungen besucht, bei denen man selbst nicht zu sehr aktiv sein musste. Das ist in der Projektstudie definitiv anders. Zum anderen haben fast alle Projektteams ihr Arbeitspensum selbst bestimmt und sich dabei überschätzt. Möglicherweise aus Gründen des Nichtversagenwollens unterblieben korrigierende Maßnahmen. Sicher auch aus Angst um eine schlechte Note. Es gab zu viele Details bei der Entwicklung zu beachten, mit denen sich die Teilnehmer bisher so nicht beschäftigt haben. Die Rollenaufteilung war in einigen Teams nicht optimal.

Viele dieser Punkte lassen sich durch Hinweise, durch Coaching und durch Regelungen (siehe oben) verbessern. Auch sollte die Einstufung und der Arbeitsaufwand für die Projektstudie überdacht werden. Daran bin auch ich interessiert.

Hinweise

Die Teilnehmer wünschten sich weitere Hinweise zu einzelnen Regelungen, wie z.B. zur Möglichkeit einer fließenden Rollenverteilung in Form der Definition einer Kernrolle und möglichen Varianten. Auch einige Werkzeuge, wie z.B. Mercurial und Ant bedürfen einer weitergehenden Erklärung. Einer der Teilnehmer meinte:

Mercurial ist bestimmt ein tolles Werkzeug. Wenn es näher erklärt würde, brächte es für alle einen riesigen, umfassenderen Nutzen.

Die weiteren Hinweise werde ich ab nächstem Semester gerne geben.

Transparenz bei der Benotung

Viele Teilnehmer wünschten sich eine größere Transparenz bei der Notengebung, nach dem Motto: “Wenn ich folgendes mache (unterlasse), bekomme ich eine um X% höhere (niedrigerere) Note”.

Ich fand die Diskussion über den Sinn und Unsinn von Noten spannend. Lernt man für eine gute Note oder um etwas besser zu können? Das ist natürlich eine Frage, die jede(r) für sich selbst beantworten muss. Genauso wie die der Relevanz guter Noten im Zeugnis.

Die Zusammensetzung der Note ergibt sich aus den gewichteten Teilnoten “Codepräsentation”, “Individuelle Leistung gemäß eigener Rolle”, “Teamleistung” und “Leistung für das Team”. Ich selbst (und die meisten Führungskräfte wohl auch) wäre froh, wenn man projekt- und teamunabhängig über einen festen Katalog z.B. die Leistung für das Team messen könnte. So müssen wir uns mit Heuristiken behelfen und alle das Gehirn eingeschaltet lassen ;-)

Bemerkenswertes

Ich fand die sehr intensive Nutzung des Wikis besonders bemerkenswert. Ich habe zwar noch keine Statistik erstellt, aber in diesem Semester wurde mehr mit dem Wiki (Trac) gearbeitet, als in den Semestern vorher zusammengenommen (damals: DokuWiki und Mantis). Möglicherweise hängt dies auch mit der zunehmenden Nutzung der Wiki-Technologie im Grundstudium zusammen.

Die Teilnehmer bemerkten die sehr intensive Kommunikation, sowohl innerhalb der Teams als auch zwischen den Teams. Das hätten sie sich nicht so (positiv) vorgestellt. Die darüber hinaus persönlichen Erfahrungen waren für die meisten ein Highlight.

Jetzt beim Schreiben fällt mir ein weiterer Punkt ein: viele Teilnehmer haben sich mit dem “warum” beschäftigt. Das finde ich toll. Und noch besser ist es, wenn sich alle die Frage stellen: Warum?

Bemerkenswert fanden viele (inkl. mir) die gute Moderation der Retrospektive durch zwei der Teilnehmer. Und das schöne Protokoll ;-)

Falls ich etwas vergessen oder ungeschickt dargestellt habe, einfach eine E-Mail an mich. Oder hinterlassen Sie einen Kommentar zu diesem Blogeintrag.

Eben stolpere ich über den Artikel Applescript Engine in Java. Dort wird beschrieben, wie man unter Mac OSX von Java aus auf AppleScript zugreifen kann. Das dort beschriebene Beispiel habe ich gleich mal nach Clojure konvertiert. Und siehe da: es geht noch kürzer (und einfacher).

(import '(javax.script.ScriptEngineManager))
(def mgr (javax.script.ScriptEngineManager.))
(def engine (. mgr getEngineByName "AppleScript"))
(. engine eval "tell application \"iTunes\" to play")

Ist das die Zukunft der Java-Plattform?

Meine kleine Datensicherungssoftware für Twitter, Twacbak muss dringend aktualisiert werden: die Benutzerauthentifizierung mittels Name und Kennwort (“Basic Authentication”) wird zum 30.06.2010 abgeschaltet. Statt dessen soll das OAuth-Protokoll verwendet werden, bei dem Name und Kennwort nur durch Twitter selbst verwaltet werden und Benutzer einzelnen Anwendungen das Recht geben, auf ihre Daten bei Twitter zuzugreifen. An sich eine gute Idee, da keine Kennworte mehr bei externen Anwendungen gespeichert werden.

Twacbak nutzt noch das bisherige Verfahren, bei dem über HTTP Basic Authentication Name und Kennwort mittels Base64 verscheiert übertragen werden. Dabei beruhigt höchstens die mögliche Übertragung per SSL. Das Modul zur direkten Kommunikation habe ich nicht selbst entwickelt. Statt dessen passte ich die Python Twitter Tools (PTT) an meine Bedüfnisse an.

Der 30.06.2010 näherte sich, besonders letzte Woche. Der Author der PTT scheint gerade OAuth zu implementieren, aber ob er bis zum 30.06.2010 fertig wird, bleibt offen. Und dann bräuchte ich ja noch Zeit, die Änderungen in Twacbak zu integrieren. Eine einfache Risikoabschätzung zeigt: besser etwas anderes.

OAuth ist kein triviales Protokoll. Es gibt für die unterschiedlichsten Szenarien Möglichkeiten der Anbindung. In den meisten Beispielen wird davon ausgegangen, dass die Anwendung, die auf Twitter zugreifen möchte, selbst eine für jeden zugänglich Webanwendung ist. Twacbak ist aktuell eine reine Konsolenanwendung. Und selbst wenn Twacbak einmal eine Webanwendung wird, würde es bei mir nur im lokalen Netz laufen.

Das ist die Situation: Twacbak muss bis Ende Juni 2010 an OAuth angepasst werden, OAuth ist ein komplexes Protokoll, mein bisheriges Modul zur Kommunikation mit Twitter unterstützt kein OAuth.

Mitte November 2009 stolperte ich über Tweepy. Damals war es nicht besonders ausgereift, kein Vergleich zu PTT. Zum Glück hatte ich es in meinem Brain einsortiert und schaute es mir letzte Woche noch einmal im Detail an. Etwas anders aufgebaut als PTT unterstützt es nun recht ausgereift OAuth.

Bleibt das Problem, wie man sich in einer Konsolenanwendung bei Twitter über OAuth authentifiziert. Die Beispiele im Web gaben nicht viel her. Ein wenig herumexperimentieren, Python’s REPL half immens, kam heraus, dass es recht einfach ist:

auth = tweepy.auth.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
auth_url = auth.get_authorization_url()
webbrowser.open(auth_url)
pin = getline('Enter PIN: ').strip()
if pin:
    access_token = auth.get_access_token(pin)
    # sichere access_token.key und access_token.secret für zukünftige
    # Zugriffe, z.B. in einer Datenbank

Die Werte für CONSUMER_KEY und CONSUMER_SECRET erhält man nach der Registrierung einer Anwendung bei Twitter. Mittels get_authorization_url() erhält man von Twitter eine URL, unter der ein Benutzer die Anwendung authorisieren kann. Nach der Authorisierung erhält der Benutzer auf der Webseite eine PIN, die er dann in der Konsolenanwendung angeben muss. Diese dient dazu, dass die Anwendung über Twitter ein sog. Access Token erhält. Damit authentifiziert sich die Anwendung später gegenüber Twitter. Das Access Token ist benutzer- und anwendungsspezifisch und damit wesentlich sicherer als ein Kennwort.

Der spätere Zugriff ist dann wieder einfach:

auth = tweepy.auth.OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET)
# lese key und secret aus Datenbank
auth.set_access_token(key, secret)
api = tweepy.API(auth, parser=tweepy.parsers.JSONParser())

Über das Objekt api können dann die Methoden der Twitter-API authentifiziert aufgerufen werden. Fertig.

Fertig? Nein. Tweepy hat eine leicht andere Philosophie als PTT. Aber zum Glück ist Python nicht statisch typisiert. Sonst hätte ein Großteil von Twacbak angepasst werden müssen (Ja, ich weiß: geringere Kopplung …). Dank Duck Typing, eines der besonders angenehmen Merkmale von Python, und der guten Konfigurierbarkeit Tweepy’s musste ich nur einige wenige Stellen anpassen. Nach kurzer Zeit war ich dann wirklich fertig mit der Umstellung.

Twacbak arbeitet nun mindestens so gut wie vorher. Subjektiv scheint es sogar schneller mit Twitter zu kommunizieren. Aber das kann auch daran liegen, dass Twitter die Kommunikation mittels OAuth bevorzugt abwickeln könnte.

Jetzt kann ich wieder in Ruhe darüber nachdenken, wie sich Twacbak weiter entwickeln soll. Vermutlich in Richtung Webanwendung ;-)