Agiles Projektmanagement Office: Die Just-In-Time Planung

Eine häufig geäußerte Kritik an agilen Verfahren ist, dass nicht wirklich geplant wird. Zwar gibt es ein Taskboard und auch ein sogenanntes Team-Commitment, aber es ist letztlich unklar, wer für welche Aufgabe verantwortlich ist, und wie sich die Effizienz optimieren lässt. Um diese Nachteile zu beseitigen, hat sich seit den achtziger Jahren die Ressourcen-Auslastungsplanung bewährt: Auf Basis einer soliden Analyse werde die Aufgaben so den einzelnen Ressourcen zugeteilt, dass sich eine optimale Auslastung ergibt und damit eine optimale Performance.
Letztlich spricht nichts dagegen, die beiden bewährten Ansätze im Sinne eines „Best-of-both“ zu kombinieren. Ich richte dafür in der Regel ein „Agiles Projekmanagement Office“ (APO) ein, also ein FTE, das für eine solide Projektdurchführung im Sinne eines Scientific Managements verantwortlich ist, ohne die fachliche Flexibilität des Product Owners einzubüßen. Aufgabe des APO ist die Pflege eines Gantt-Charts auf Basis des letzten Standup-Reports, der jeweils Just-in-Time den neuesten Vorgaben des PO angepasst wird. Durch konsequenten Einsatz des Teamplaners aus MS Project 10 ist diese Aufgabe leicht und effizient durchführbar.
Das ergibt folgende Vorteile:

  • Jederzeit eine klare Vorausplanung für das Team, auch über sogenannte Sprintgrenzen hinweg. Meine Kunden erreichen mit MS Project in der Regel einen Planungshorizont von 18-23 Monaten und sind daher wieder in der Lage, Termine zuzusagen
  • Klaren Überblick für den Projektleiter, wer an welcher Aufgabe arbeitet, so dass er die Auslastung optimieren kann
  • Kompatibilität mit etablierten Berichtswegen, was die Einführung von Scum gerade in Großorganisationen deutlich erleichtert
  • Aufgrund der nun klaren Berichts- und Anweisungswege kann auf ineffiziente Daily Standups und Selbstorganisation verzichtet werden und die Ressourcen können wieder ungestört ihrer Aufgabe nachgehen. Alleine das erhöht die Produktivität um 3,1%

Aufgrund des großen Erfolges bemühen wir uns derzeit darum, das APO in den neuen Scrum Guide übernehmen zu lassen.

Refactoring mit PHP

Dass Refactoring in Java mit Eclipse so richtig Spaß macht und auch die Kombination von Visual Studio mit Resharper oder DevExpress ganz brauchbar ist, dürfte zumindest unter Agilisten hinreichend bekannt sein. PHP-Entwickler haben es da deutlich schwerer, wie Roy Ganor in seinem Blog-Eintrag „Refactoring PHP Code“ beschreibt. Zend scheint zumindest ein paar Basisfunktionen anzubieten, aber selbst der Beitrag (auf dem Firmenblog!) klingt nicht wirklich enthusiastisch. Dennoch kann es sich für PHP-Entwickler lohnen, hineinzuschauen und zumindest zu beobachten, was dort die nächste Zeit passiert.

Achtung: Ich selbst habe keinerlei Erfahrung mit Refactoring unter PHP! Wer da mehr weiß, ist herzlich eingeladen, hier Kommentare zu ergänzen.

Notizen von der OOPSLA – Refactoring Werkzeuge

Einmal im Jahr gönne ich mir den Besuch der OOPSLA. Zum einen, um Bekanntschaften und Freundschaften zu pflegen, aber auch, um einen Überblick zu bekommen, was derzeit an (wirklich) neuen Dingen aufkommt, abseits der aufgeregten Marketing-Hypes. Ich möchte hier über für mich interessante Erkenntnisse berichten.

Am ersten Tag entschloss ich mich kurzfristig, als Zuhörer am zweiten Workshop über Refactoringwerkzeuge teilzunehmen. Eine Entscheidung, die sich gelohnt hat, obwohl ich normalerweise „Präsentationsworkshops“ meide. Der Workshop hat einen guten Überblick über den aktuellen Stand der Forschung zum Thema Refactoring gegeben — und deutlich gemacht, dass wir hier erst am Beginn einer Entwicklung stehen, die unsere Arbeit über die nächsten Jahre wesentlich beeinflussen wird.

Zu den Vorträgen:

Refactoring bei IntelliJ

Dimitri Jemerov von JetBrains (IntelliJ, Resharper) stellte die Mechanismen hinter den Refactoring Browser von IntelliJ IDEA vor. Er basiert auf einem gemeinsamen „Refactoring Workflow Framework“, mit dem sich die einzelnen Operationen relativ einfach implementieren lassen. Jemerov sprach von einer „Refactoring DSL“, die bei IntelliJ dafür entwickelt wurde.

Während die Grundlagen relativ gut standardisierbar sind (und die vorgestellten Ideen auch entsprechend wenig überraschend), liegt der Teufel und damit auch der Aufwand im Detail. Hier diktiert die Sprachkomplexität auch die Komplexität des Refactorings. Gerade bei Java mit seinen Einschränkungen was wo erlaubt ist, führt das beim Refactoring gelegentlich auch zu Ergebnissen, die nicht gerade schön sind. Die Begründung war pragmatisch: Normalerweise wird refaktorisierter Code nicht mehr überprüft. Daher muss er zu 100% korrekt sein, auch wenn das Ergebnis nicht gerade elegant ist.

Interessante Features von IntelliJ, die er vorstellte, waren:

  • Extract Method bei mehreren Ergebniswerten: Hier werden komplette Klassen erzuegt und extrahiert.
  • Refactorings über mehrere Sprachen: Während der aktuelle Stand (Rename, Move) noch nicht so aufregend ist, wird derzeit daran gearbeitet, die interne Darstellung sprachübergreifend zu gestalten, um auch komplexe Refactorings sprachübergreifend zu ermöglich. Geplant ist Unterstützung von Java, Ruby, Groovy, Python und XML (wenn ich keinen vergessen habe…)
  • Veränderung von Typen: Als Beispiel ersetzte Dimitri ein Array durch eine Liste, ein Beispiel für ein ziemlich komplexes Refactoring, das auch nur teilautomatisiert möglich ist. Leider reichte die Zeit nicht aus, das im Detail darzustellen.

Die anschließende Diskussion kreiste vor allem um den Konflikt zwischen 100% korrektem Umbau des Codes, eleganten Ergebnissen und Unterstützung des Entwicklers. Es dürfte hier kaum möglich sein, den richtigen Weg zu finden.

Oberflächen für Refactoring Werkzeuge

Dustin Campbell, der vor wenigen Monaten von DevExpress (Refactor!) zu Microsoft wechselte, demonstrierte aktuelle Entwicklungen in der Oberfläche von Refactoring Werkzeugen am Beispiel von Refactor!. Der Trend geht dahin, den Browser nahtlos in den Editor zu integrieren: Keine Dialogboxen mehr, keine Sammlungen von Shortcuts, statt dessen kontext-sensitive Erweiterungen des Editors. Wer mit Eclipse arbeitet, kennt ähnliche Ansätze bereits vom Umbenennen eines Identifikators: Drückt man vor dem Editieren eines Identifikators eine bestimmte Tastenkombination, werden auch alle anderen Vorkommen umbenannt. Refactor! treibt diesen Ansatz wesentlich weiter: Das Werkzeug ist darauf optimiert, mit einem einzigen Shortcut kontextsensitiv zu arbeiten.

Die Demonstration war beeindruckend, hier wurde ziemlich sicher die derzeit beste Lösung für die Oberfläche des Werkzeugs präsentiert. Ob die dahinter liegenden Mechanismen mit den Anforderungen großer Systeme mithalten können, weiß ich nicht. Ebenso wenig ist mir klar, ob diese Art der Oberfläche für Umbauten an großen Systemen noch adäquat ist, insbesondere in Situationen, in denen bewusst nicht-vollständige Refactorings eingesetzt werden sollen. Das lässt sich sicherlich nur durch praktischen Einsatz herausfinden (Bekannt ist, dass Refactor! für C++ erhebliche Stabilitätsprobleme hat. Die Versionen für C# (und andere .NET Sprachen) scheinen nicht so extrem unter diesem Problem zu leiden). Unabhängig davon ist die enge Integration von Editor und Refactoring sehr interessant (sie war genau genommen bereits in John Grants und Don Roberts „Ur-Refactoring-Browser“ angelegt) und ich hoffe, dass sie sich auf breiter Basis durchsetzen.

Werkzeuge zur Entwicklung von Refactoring Werkzeugen

Dieser Teil des Workshops richtete sich naturgemäß eher an jene, die selbst Refactoring bauen, als an deren Anwender. Ich fand die Vorträge dennoch interessant, weil sie einen guten Eindruck liefern, mit welchen Problemen derzeit gekämpft wird und was uns die Zukunft hier bringen kann.

Verbesserung der Analyse

Max Schäfer von der Oxford University stellte eine Refactoring Engine vor, die sich vor allem um Namensprobleme kümmert, um sicher zu stellen, dass die verbreiteten Probleme, die Refactoringwerkzeuge mit Verschattung von Namen haben. Aus Anwendersicht war die Nachricht interessant, dass keines der marktüblichen Werkzeuge hier wirklich sauber arbeitet. Es lohnt sich also weiterhin, darauf zu achten, dass man die Verschattungsregeln der Sprachen nicht zu sehr ausreizt — eine Regel, die schon im Interesse der Lesbarkeit von Programmen sinnvoll ist.

Framework für den Bau von Refactoring Werkzeugen

Jeffery Overbey, ein Diplomand von Ralph Johnson an der Univerity of Illinois, Urbana Champaign, demonstrierte einen Ansatz, die für brauchbares Refactoring notwendigen Syntaxbäume aus speziellen Grammatiken zu erzeugen. Sein Demonstrationsobjekt war ein Transformationswerkzeug für Fortran-Programme. Hier ging es eher im Detailprobleme, die eher für Werkzeugbauer von Interesse sind, wie zum Beispiel der Umgang mit Kommentaren und Einrückungen, Themen die im klassischen Compilerbau kaum eine Rolle spielen, für die Akzeptanz von Refactoring Werkzeugen aber entscheidend ist. Der Vortrag hat schön gezeigt, dass Refactoringwerkzeuge derzeit eine ähnliche Entwicklung durchmachen, wie Compiler in den 70er Jahren. Das halte ich durchaus für einen Grund, sich auf die Werkzeuge der nächsten zwanzig Jahre zu freuen 🙂

Refactoring auf höherer Ebene

Macneil Shonle von der University of San Diego stellte ein Plug-in für Eclipse vor, das versucht, Java Refactorings auf höherer Ebene umzusetzen (Arcum). Auch wenn sich der Vortrag eher um Grundlagenforschung drehte, zeigte er doch, dass zumindest die angelsächsischen Universitäten mittlerweile den Ball aufgenommen haben und an den komplexen Problemen wie Migrationen von Bibliotheken forschen. Sollten diese Arbeiten für den professionellen Einsatz reif werden — womit ich nicht in den nächsten zehn Jahren rechne —, könnte das den Umgang mit Architektur und Bibliotheken ähnlich revolutionieren, wie die derzeitigen Werkzeuge den Umgang mit Code und Design verändert haben.

Analyse des Refactoring von Entwicklern

Emerson Murphy-Hill von der Portland State University berichtete über Strategien, um herauszufinden, welche Refactorings an einer Codebasis durchgeführt wurden. Auch er stellte noch mehr Fragen vor, als Antworten. Ziel ist die Verbesserungen von Refactoringwerkzeugen, das Thema kann aber auch relevant werden, um Dokumentations- und Revisionsanforderungen zu erfüllen, oder in Wartungssituationen den Code zu verstehen. Zweifel sind aber angebracht: Murphy-Hill stellte fest, dass nur ca. 10% der Refactorings mit Werkzeugen durchgeführt werden und nur etwa ein Drittel sich überhaupt im Versionsmanagement niederschlagen. Sein Resümee: Wir kennen (noch) keine zuverlässige Methode, durchgeführte Refactorings zu ermitteln.

Zum Nachdenken hat auch eine Erkenntnis am Rande angeregt: Deutete ein Check-in in das Versionsmanagement einen Kommentar, der auf Refactoring hindeutet, war die Anzahl der darin enthaltenen Umbauten halb so groß [sic!], wie bei Check-ins ohne solche Kommentare. Es wäre interessant, ob sich das auf die Zuverlässigkeit von Check-in-Kommentaren verallgemeinern lässt.

Refactoring Lab

Josh Kerievsky, Autor des Buchs „Refactoring to Patterns“ und Gründer von „Industrial Logic„, zeigte den Einsatz seines „Refactoring Labs“, eines Trainingswerkzeugs für Refactoring. Die Studenten werden vor eine Refactoringaufgabe gestellt und das Lab analysiert den gewählten Lösungsweg und macht Verbesserungsvorschläge, z.B. dass bestimmte Schritte, die manuell gemacht wurden, einfacher im Refactoringbrowser durchgeführt werden können. Die Regeln sind als JUnit-Tests hinterlegt und überprüfen z.B. wie oft die Tests gestartet wurden und welche Optionen beim Umbau eingesetzt wurden. Ein sehr nettes Werkzeug für die Schulung.

Refactoring für Nebenläufigkeit

Der Organisator Danny Dig berichtete über seine Arbeiten am MIT, in denen er versuchte, sequenziell geschriebenen Code in Code umzustellen, der die Java 5 Unterstützung für Nebenläufigkeit nutzt. Das Werkzeug heißt Concurrencer und ist als Eclipse-Plugin verfügbar. Die Wirksamkeit des Tools wurde mit 6 Open Source Projekten überprüft. Die Ergebnisse waren zwar nicht perfekt, aber deutlich besser, als die manuellen Umstellungen der Entwickler, die die entsprechenden Werkzeuge betreuen. Immerhin machte das Werkzeug keine Fehler, die zu Fehlfunktionen der Software führen können — im Gegensatz zu vier solchen Fehlern im offiziellen, manuell umgestellten Code. Als wichtige Richtung für die zukünftige Entwicklung wurde die Integration mit Analysewerkzeugen angesprochen: Deren Ergebnisse sollten die Entwickler durch die notwendigen Schritte leiten.

Wer vor dem Problem steht, Java Code threadsafe zu machen, sollte sich das Tool genauer ansehen.

Refactoring von Programmen zur Matrixmanipulation

Beverly Sanders von der University of Florida erzählte über den Einsatz von Refactoring in der algebraischen Chemie. Dabei werden chemische Reaktionen simuliert, was im Wesentlichen darauf hinausläuft, Lösungen für die Schrödingergleichungen zu finden. Die Programme laufen auf hoch-parallelen Supercomputern mit speziellen DSLs für Matrizenumformungen. Hier wird Refactoring nicht zur Verbesserung des Designs eingesetzt, sondern um die Performance und Ausführungskomplexität zu verbessern. Das geht oft nicht durch pures Ansehen, sondern auf der Basis von Messungen. Für mich war die Einsicht spannend, dass man Refactoring auch in zunächst anderen Domänen mit ganz anderen Zielen betreiben kann. Der Schluss liegt nahe, dass wir hier erst ganz am Anfang stehen.

Resümee

Refactoring steht erst am Anfang. Sowohl für die Werkzeuge im breiten Einsatz, als auch in Randthemen besteht noch erheblicher Forschungsbedarf, der zunehmend von den Universitäten auch angegangen wird. Aus Sicht des Praktikers kann man nur hoffen, dass sich diese Forschung so bald wie möglich in breit einsetzbaren Produkten niederschlägt. Das könnte die Art, wie wir programmieren weg vom Programme schreiben hin zu Software entwickeln revolutionieren — vorausgesetzt, die Ausbildung wird auch entsprechend angepasst.

Jazz nur in „Mini-Fassung“ frei verfügbar

Ich hatte im Januar schon einmal kurz über Jazz geschrieben („Jazz ist nun doch frei verfügbar„), damals in der Hoffnung, IBM würde bei Jazz eine ähnliche Politik verfolgen, wie bei Eclipse und die Projektmanagement-Plattform frei zur Verfügung stellen. Die erste offizielle Version ist jetzt unter dem Namen „Rational Team Concert 1.0“ verfügbar (http://www.jazz.net) und leider hat sich IBM nicht zu dem Schritt durchringen können, die Software mit einer freien Lizenz bereit zu stellen. Immerhin gibt es kostenlose Lizenzen für Open-Source Projekte und akademischen Einsatz. Und es gibt für ganz kleine Teams von höchstens drei Personen eine kostenlose Version „Express-C“ zum Herunterladen — kaum die Teamgröße, in der ein solches Werkzeug seine Stärken ausspielt.

Ich finde es schade, dass IBM nicht am Erfolg von Eclipse anknüpft und sich bei Jazz für traditionelle Lizenzpolitik entschieden hat, statt den mutigeren Schritt zu gehen. Ob sich diese Entscheidung für IBM rechnet, ist schwer abzuschätzen; ich neige dazu, das nicht zu glauben. Die Chance, den Markt für Projektmanagementwerkzeuge zu revolutionieren, dürfte IBM so aber kaum wahrnehmen können. Statt dessen nur ein weiteres Produkt unter vielen. Schade eigentlich.

Praktiken II: Automatisierte Akzeptanztests

Nach längerer Zeit nun der zweite Teil meiner Serie über agile Prakitken. Bisher finden Sie in dieser Kategorie die folgenden Einträge:

Der zweite Teil beschäftigt sich mit automatisierten Akzeptanztests:

Auch agile Entwicklung startet mit den fachlichen Anforderungen. Allerdings werden sie direkt als Akzeptanztests aufgeschrieben, statt in Anforderungsdokumenten. Akzeptanztests sind fachliche Beschreibungen dessen, was das System können soll und zwar so, dass sie automatisch ausgeführt werden können. Automatisch ausführbare Tests steuern die Anwendung und überprüfen deren Ergebnisse ohne menschlichen Eingriff. Der Weg zu diesen Akzeptanztests ist noch eher uneinheitlich, man geht aber in der Regel von den geplanten geschäftlichen Abläufen aus (siehe dazu auch „Use Cases oder User Stories„).

Weiterlesen

ReFit: Refaktorisieren von Akzeptanztests

Johannes Link hat einen Werkzeugsatz geschrieben, mit dem man größere Mengen an FitNesse-Seiten umstellen und Refaktorisieren kann. Derzeit präsentiert sich ReFit, wie er das Werkzeug nennt, recht spartanisch als Groovy-Konsole, Johannes hat mir aber versichert, dass er jeden unterstützt, der Lust hat, dazu eine schicke grafische Oberfläche zu schreiben. Im Projekt verwendbar ist ReFit jetzt schon, zumindest wenn die Entwickler sich noch nicht auf die Maus beschränken, sondern noch mit der Tastatur umzugehen wissen…

Weitere Informationen und Links finden Sie auf Johannes Links Blog unter dem Titel Refactoring FitNesse Tests.

Die Planung in der Tasche haben

Ein immer wiederkehrendes Problem bei agiler Planung ist die Menge an Karten, mit denen man jonglieren muss. In einem Monat sind vielleicht zehn, fünfzehn oder mehr Stories geplant, zu einer Story können leicht fünf oder sechs Aufgaben entstehen und der Platz auf einer Pinwand ist beschränkt.

Eine nette Lösung für das Problem hat Johannes Stark entwickelt, der in einem von mir betreuten Team mitarbeitet:

Tasche für die Planung Aus transparenten Hüllen und ein wenig Klebeband werden Taschen gebastelt, in welche die Karten für die User Story und alle noch ungeplanten Aufgaben gesteckt werden. Die Taschen hängen in der Reihenfolge ihrer Priorität an der Pinwand. Zur Wochenplanung werden dann die Aufgaben nach der Reihenfolge ihrer Priorität aus den Taschen genommen und auf eine zweite Pinwand gehängt, bis die Wasserlinie erreicht ist. Überzählige Aufgaben wandern wieder zurück in die Taschen.

Fallen unter der Woche neue Aufgaben an, so werden sie in die Taschen der zugehörigen User Story gesteckt und bei der nächsten Wochenplanung berücksichtigt. Ist eine Tasche leer und die Aufgaben abgearbeitet, so ist die User Story erledigt – vorausgesetzt natürlich, die Tests laufen.

Jazz ist nun doch frei verfügbar

[Hinweis: Ich habe diesen Eintrag nach einer Richtigstellung von Marko Schulz (s.u.) überarbeitet – 18.1.08]

Nun also doch: IBM hat am 14. Januar bekannt gegeben, dass Jazz ab sofort frei verfügbar ist. Damit steht das neueste „Baby“ der beiden Eclipse-Väter Erich Gamma und Andre Weinand wie auch schon Eclipse zumindest zur Evaluierung kostenlos zur Verfügung: Man muss IBM noch mit der Preisgabe seiner E-Mail Adresse bezahlen (http://www.jazz.net).

Selbst habe ich noch mit Jazz gespielt, geschweige denn es im Projekt eingesetzt. Dieser Bericht hier ist daher nur eine Zusammenfassung der White Papers und einer Vorführung auf der OOPSLA.

Was ist Jazz? Ähnlich wie Eclipse ist Jazz vor allem eine Plattform, also ein System, das zur Erweiterung mit Plug-Ins einlädt. Während Eclipse aber für den Arbeitsplatz eines einzelnen Entwicklers konzipiert ist, soll Jazz das ganze Team unterstützen. Es fordert damit also Micorsofts Team Foundation Server heraus.
Weiterlesen