Rash thoughts about .NET, C#, F# and Dynamics NAV.

Auf dem .NET OpenSpace Süd in Karlsruhe hatte ich heute die Gelegenheit bei einem Coding Dojo mit Ilker Cetinkaya mitzumachen. Leider ist das Dojo nicht so richtig in Fahrt gekommen und wir haben es praktisch nicht geschafft auch nur eine einzige Regel der Kata.RomanNumerals zu implementieren. Der Grund dafür war (sicherlich nicht nur) aus meiner Sicht, dass es zwei starke Fraktionen innerhalb des Teams gab. Auf der einen Seite “Coder”, die sich tatsächlich von den Tests treiben lassen wollten und auf der anderen Seite eine Gruppe der “Knobler”, die sich nicht mit dem Test-first-Ansatz identifizieren können und lieber am Board einen Algorithmus entwickeln.

Aus meiner Sicht sind beide Ansätze für sich betrachtet auch völlig in Ordnung und können zu sehr guten Lösungen führen.

Wer z.B. nicht glaubt, dass der strikte Test-first-Ansatz für Kata.RomanNumerals funktioniert, der kann gern die Teilnehmer vom 2.ten Hamburger Coding Dojo fragen oder das github-Repository dazu durch browsen und die Entwicklung der Commits verfolgen.

Was aber offensichtlich überhaupt nicht funktioniert ist der Mittelweg. Wenn sich beide Gruppen nicht auf das Vorgehen einigen und im Zweifel immer nur der “lauteste” Änderungsvorschlag gewinnt, dann wird das Ergebnis mitunter unbefriedigend für beide Seiten. Beim Karlsruher-Dojo hatten wir am Ende nach einer gescheiterten Implementierungsphase und abrupten Abbruch sogar nur 7 rote und einen grünen Test vorzuweisen. Bei dem Grünen frage ich momentan sogar immer noch warum ausgerechnet dieser Test überhaupt gelaufen ist.

Um also eine solche Situation zu vermeiden sollte man sich also am Anfang entscheiden wie man sein Dojo gemeinsam durchziehen will. Im weiteren werde ich jetzt eher auf die von mir favorisierte Variante mit striktem TDD eingehen, auch wenn mich eine Knobler-Session mit ausgeprägter Analysephase auch mal als Vergleichswert interessieren würde.

Wie gesagt: Ich bin ausdrücklich davon überzeugt, dass beide Lösungswege funktionieren können – je nach Problem mal besser und mal schlechter.

Striktes TDD und der einfachste Lösungsvorschlag gewinnt

Ein oft genanntes Argument der “Knobler”-Fraktion am TDD-Ansatz ist, dass nicht vorrausschauend entwickelt wird. Hey Jungs – das ist doch genau der Trick. Solange ich keine Anforderung für irgendwelche Dinge habe (nicht im Kopf oder auf dem Papier, sondern als Test) wird keine Komplexität hinzugefügt. Es wird dann behauptet, dass bei Test-first am Anfang sinnfreie Implementierungen gewählt werden und dass man diesen Code am Ende ganz offensichtlich sowieso wieder wegschmeißen würde. Aber das stimmt einfach nicht. Auch wenn ich immer mehr Tests hinzunehme und meine Implementierung immer generischer wird, so wird die vorherige Lösung letztlich immer ein Spezialfall der generischen Variante sein und geht somit nie verloren.

Gerade der Fokus auf diese minimal mögliche Generalsierung der aktuellen Implementierung sorgt dafür, dass der Algorithmus am Ende korrekt herausfällt. Das Knobeln kommt an dieser Stelle natürlich wieder in den Ablauf herein. Allerdings knobeln wir so an wesentlich kleineren und damit leichteren Problemen  – selbstverständlich nun viel öfter und in kürzeren Zyklen.

Bei zukünftigen Coding Dojos würde ich also gern als Regel sehen, dass der einfachste Vorschlag, der zu Grün führt implementiert wird.

Temposteigerung durch gruppenweises Anlegen von roten Tests

Zu bestimmten Zeitpunkten und insbesondere auch am Anfang von vielen Katas sieht man jedoch oft Implementierungsmuster die gleich eine ganze Klasse an Tests abdecken könnten. Wenn man so eine Idee hat, dann sollte man die natürlich auch nutzen und so das Tempo steigern. Anstatt aber diese Idee einfach zu programmieren würde ich erst die komplette Gruppe von Tests schreiben und sicherstellen, dass alle neuen Tests auch wirklich "rot sind. Dieser Shortcut ist aus meiner Sicht methodisch völlig unproblematisch, da zu diesem Zeitpunkt nur neue Anforderungen im System dokumentiert werden und diese dann als Begründung für neue Komplexität herangezogen werden können.

Aber auch hier sollte die selbe Regel gelten: Die leichteste Implementierung gewinnt. Wenn also ein Teilnehmer eine einfachere Lösung anbieten kann, dann wird die genommen.

Training durch Wiederholung

Wie Ilker in der Auswertung bereits gesagt hat, würde ich auch gern nochmal in der selben Truppe ein Dojo machen. Vielleicht ergibt sich das ja sogar beim nächsten OpenSpace. Denn selbstverständlich geht es beim Coding Dojo nicht nur um Code sondern auch um die beteiligten Menschen.
Obwohl wir am Ende keine Lösung vorweisen konnten, habe ich in der kurzen Zeit sehr viel über die Entwicklungsmethodik anderer Teilnehmer gelernt – ich denke das hat mir wirklich eine Menge gebracht.

Training durch Wiederholung – Reloaded

Da ein wichtiges Element bei Katas auch die Wiederholung ist (und mir im Zug langweilig ist), habe ich zusätzlich für mich selbst und andere noch eine aufgeräumtere Variante der Kata mit minimalen Commits in das Repository hochgeladen. Unter http://github.com/forki/DojoHamburg/commits/Karlsruhe kann man die Änderungen von unten nach oben genau nachvollziehen. Wenn jemand ein Stelle findet wo ich zu viel implementiert habe oder wo die Änderung nicht sinnvoll und einfach erscheint, dann würde ich mich freuen darüber diskutieren zu können.

Am Mittwoch hat die .NET User Group Hamburg das zweite .NET Coding Dojo in wunderbarer Lage im Neuen Wall durchgeführt. Der Dank gilt diesmal Computer Futures, die uns freundlicherweise Raum, Beamer und Getränke zur Verfügung gestellt haben.

Ablauf

Nach einer kurzen Reflektion des letzten Treffens und Klärung der aufgetretenen Syntaxprobleme hat sich das Team dafür entschieden, die Kata.RomanNumerals zu implementieren. Wie beim ersten Treffen haben wir diese relativ einfache Kata auch wieder im Randori-Stil durchgeführt. Da das Team relativ gleich geblieben ist, konnten wir den Ablauf jedoch leicht erweitern. Um etwas mehr Schwung in die Test-Phase zu bringen, habe ich vorgeschlagen immer in der Rot-Phase zu rotieren. Zusätzlich haben wir git als Versionskontrollsystem im Einsatz gehabt und bei jeder Grün-Phase sowie nach Refactorings commited. Das Ergebnis kann auf meinem Github-Account bewundert werden.

Kata

Aus meiner Sicht bildet die Kata.RomanNumerals eine ideale Fortsetzung zur Kata.StringReplacer, die wir beim ersten Treffen hatten und ist praktisch perfekt mit Test-Driven Development lösbar. Insbesondere das nachträgliche Implementieren der scheinbar komplizierten Subtraktionsregel ist wunderbar anhand von wenigen Sonderfällen (= UnitTests) lösbar.

Was lief gut?

• Die Rotation der Teilnehmer klappte wieder problemlos – Danke Jungs 🙂
• TDD wurde als sehr erfolgreich für die Kata angesehen
• Nahezu alle Teilnehmer waren überrascht wie einfach sich die Subtraktionsregel in TDD implementieren lässt
• Die Randori-Form mit Rotation bei Rot sorgt für Aktivität
• Es wurde immer versuchen die einfachste Lösung zu wählen
• Die Rollen Driver, Co-Pilot und Publikum wurden klarer getrennt
• Es wurde nach jedem implementierten Test in das git Repository commited
• Ganz wichtig: Es hat wieder viel Spaß gemacht!

Was wollen wir besser machen?

• Noch mehr Wert auf das Naming legen
• Überraschenderweise hat sich kein Team getraut die Namenskonvention des ersten Teams zu verbessern
• Insbesondere auch die Commit-Kommentare sind noch nicht sehr aussagekräftig
• In den Refactoring-Phasen sollten die Tools (Resharper) besser genutzt werden
• Die Refactorings könnten noch ausführlicher diskutiert werden
• Von Anfang an externe Tastatur und Maus für den Laptop bereit stellen
• Internetverbindung um Syntaxfrage schneller klären zu können
• Parametrisierte Tests benutzen um weniger Test-Codierungsaufwand zu haben

Vielen Dank an alle Teilnehmer – wir sehen uns dann beim nächsten Dojo.

Gestern haben wir bei der msu solutions GmbH am Standort Halle unser erstes internes CodingDojo veranstaltet.

Ziele des internen Dojos

Da wir in der tagtäglichen Arbeit mit Microsoft Dynamics NAV entwickeln, wollten wir das Dojo auch mit Dynamics NAV und der Programmiersprache C/AL abhalten. Als wichtiges Ziel der Veranstaltung haben wir uns vorgenommen nach Test-Driven Development (TDD) zu arbeiten. Da TDD im NAV-Bereich (sicherlich mangelns Tools und Community) noch so gut wie unbekannt und unser selbstentwickeltes Test-Framework noch sehr jung ist, war diese Selbstverpflichtung für einige Team-Mitglieder in dieser strikten Form sicherlich noch Neuland.

Ablauf

Um die Messlatte für das erste Dojo daher nicht allzu hoch zu legen und mehr Fokus auf den Versionsverwaltung (git), die Test-Tools und die Kommunikation bzw. den Prozess selbst zu richten habe ich die relativ einfachen Katas FizzBuzz und DictionaryReplacer vorgeschlagen. Das Team hat sich dann für FizzBuzz entschieden.

Wie beim 1. NET CodingDojo in Hamburg gab es auch in Halle einige Startschwierigkeiten. Es scheint für viele Entwickler aufgrund der jahrelangen Entwicklungspraxis sehr schwer zu sein, tatsächlich zwischen Test und Implementierung zu unterscheiden.

Nachdem jedoch die ersten 3 Tests samt Implementierung geschafft und die explizite Trennung der Test- und Entwicklungsphasen erkannt wurden steigerte sich das Tempo des Teams enorm. So konnten wir dann auch Erweiterungen der Aufgabenstellung diskutieren und umsetzen.

Ich denke unser erstes msu Dojo war ein Erfolg und insbesondere die Wahl der Kata war für die erste Veranstaltung dieser Art ausgezeichnet. Für das nächste Mal wollen wir uns dann natürlich an eine schwierigere Kata wagen.

Randori-Stil

Da seit dem ”Dojo Deluxe” von und mit Ralf Westphal eine Diskussion über die Dojo-Formate aufgekommen ist, möchte ich hier auch noch meine Meinung dazu abgeben.

Da wir uns den Randori-Stil ausgesucht haben, gab es eigentlich vier verschiedene Rollen. Als erstes natürlich den Driver und den Co-Piloten, also eine Person, die die Tastatur bedient und eine die sagt “wo es lang geht”. Übrig bleiben dann in unserer Version noch der Rest des Teams als Publikum und ein Moderator. Da es die erste Veranstaltung dieser Art war, gab es noch sehr viele Hinweise vom Moderator. Bei nachfolgenden Veranstaltungen würde ich mir wünschen, dass der Moderator immer mehr in den Hintergrund rückt und die jeweiligen Co-Piloten deutlich aktiver werden. Das Publikum könnte noch mehr als das Kontrollorgan fungieren und auf Einhaltung der selbst auferlegten Richtlinien pochen. Als wichtigen Punkt für nachfolgende Veranstaltungen würde ich also noch eine klarere Trennung der Rollen sehen und dem Team mehr Eigenverantwortung auferlegen.

Randori-Stil vs. Tutorial

Die Befähigung des Teams den Entwicklungsprozess ohne starke führende Hand selbst zu kontrollieren ist für mich ein Kernziel bei einem CodingDojo. Ich denke hier unterscheidet sich der Randori-Stil (jedenfalls wie ich ihn bisher verstehe) stark von der Variante und den Zielstellungen die Ralf Westphal in seinem Dojo in München abgehalten hat. Wie Ilker Cetinkaya auch schon geschrieben hat ist Ralf’s Dojo-Variante wahrscheinlich näher am klassischen Workshop oder am Tutorial einzuordnen. Daran ist natürlich nichts falsch, ganz im Gegenteil: ich finde solche Workshops mit erfahrenen und charismatischen Sprechern extrem reizvoll. Insbesondere weil man bei einem Workshop aufgrund der intensiveren Vorbereitung des Sprechers in der kürzeren Zeit eine weit höhere fachliche Tiefe erreicht und man im Gegensatz zu klassischen Frontal-Vorträgen auch mehr Rückfragen stellen kann. Ralf hat sich dazu in seinem Blog ja auch intensiv und fundiert Gedanken gemacht.

“Einer weiß etwas und die anderen wollen es von ihm lernen”-Formate wie Ralf sie beschreibt sind also auch aus meiner Sicht sehr nützlich und bilden vermutlich sogar die Voraussetzung für ein Randori. Wenn nicht genug Leute im Raum bereits etwas über die zu benutzenden Techniken oder Methoden gehört haben, dann wird das Dojo bzw. das gemeinsame Lernen und Lehren vermutlich sehr zäh und der Moderator wird zum Hauptakteur. Es ist somit auch völlig einleuchtend, dass Ralf seine Event-Based Components natürlich nicht in einem Randori vorstellen kann. Das wäre dann wohl beim einem leeren FlipChart geblieben und ganz sicher auch eine Enttäuschung für alle Seiten.

Wenn jedoch hinreichend viele Leute bereits Erfahrungen mit der Materie gemacht haben, dann gibt es vermutlich auch unterschiedliche Interpretationen. Diese würde ich aber nicht so drastisch wie Ralf als “Unsicherheit” auslegen, sondern eher als Chance die Varianten gemeinsam zu diskutieren und Unklarheiten auszuräumen. Dabei muss es am Ende aber nicht zwingend einen Konsens geben.

Daher denke ich, dass auch ein Format mit weit weniger Moderation bzw. Anleitung wichtig ist, insbesondere auch um das bisher Erlernte in einer sicheren Umgebung zu testen und echtes TeamPlay zu trainieren. Den Begriff “Dojo” ausschließlich für solche freien Formate zu verwenden, ist wie Ralf beschrieben hat aus historischer Sicht wahrscheinlich eher ungeschickt. Dem stimme ich zu.

Ich denke hier hat Ralf hat meine Twitter-Kommentare evtl. auch etwas überbewertet (140 Zeichen sind natürlich oft auch missverständlich). Ich bin auch nicht dafür, dass alle Entwickler gleichgemacht werden sollen und es überhaupt keinen Lehrer gibt. Ganz im Gegenteil jeder soll sich einbringen, denn selbstverständlich sind immer unterschiedliche Wissengrade im Raum zu finden.

Dass alle etwas beisteuern klappt dann aber nur wenn die erfahreneren Entwickler sich auch mal darauf einlassen einen vorgeschlagenen “Irrweg” mit zu gehen und den Erkenntnisprozess so reifen zu lassen. Abgabe von Kontrolle ist zugegebenermaßen nicht gerade einfach, aber manchmal wird man vielleicht auch als alter Hase noch überrascht werden.

Gestern fand das erste .NET Coding Dojo in Hamburg statt und es war aus meiner Sicht ein voller Erfolg. Als erstes möchte ich mich an dieser Stelle bei der Firma masters of arts für die Räumlichkeit und natürlich bei allen Teilnehmer für die aktive Mitarbeit bedanken.

Durchgeführt haben wir das Dojo im Randori-Stil, d.h. es gab einen Entwickler, einen “Co-Piloten” und das Publikum. Nach jeweils 5 Minuten bzw. jedem neuen Testfall wurden die Positionen mit neuen Teilnehmer aus dem Publikum getauscht.

Nach einer kurzen allgemeinen Einführung in das Thema “Coding Dojo” habe ich die Aufgabenstellungen der Kata.FizzBuzz und Kata.DictionaryReplacer vorgestellt. Durch kurze Abstimmung haben wir dann (vermutlich durch meine Wortwahl beeinflusst) die Kata.DictionaryReplacer gewählt.

Mit der Wahl dieser Kata war ich nicht ganz unglücklich, da wir DictionaryReplacer schon im Online Dojo durchgenommen haben und ich deshalb die Fallstricke schon etwas einschätzen konnte.

Kata.DictionaryReplacer

Create a method that takes a string and a dictionary,
and replaces every key in the dictionary pre and suffixed with a dollar sign,
with the corresponding value from the Dictionary.

Tests

input : "",
          dict empty
output: ""

input : "$temp$", 
           dict ["temp", "temporary"]
output: "temporary"

input : "$temp$ here comes the name $name$",
           dict ["temp", "temporary"] ["name", "John Doe"]
output : "temporary here comes the name John Doe"

[codingdojo.org]

Nach kurzer Einführung in die Vorgehensweise des Test-Driven Developments (TDD) und Diskussion über sinnvolles Naming ging es dann auch richtig in die Entwicklung. Die Kata eignet sich in dieser Form auch sehr schön um tatsächlich “Test first” zu arbeiten. Die Implementierung folgt quasi als logische Konsequenz.

Interessant und ungleich komplizierter wurde es dann als wir eine zusätzliche Anforderung eingebaut haben. Da es sich bei der Kata um eine Art Templatesystem handelt liegt es nahe auch in den Values des Wörterbuchs neue Keys zu erlauben und somit eine beliebige Ersetzungstiefe zu erreichen. Diese Anforderung ist ein wunderbares Beispiel dafür wie sehr man mit Aufwandsabschätzungen daneben liegen kann. 😉

Die rekursive Ersetzung wurde noch sehr schnell gelöst, aber richtig schwer haben wir uns dann mit der Erkennung von zyklischen Ersetzungen und der daraus folgenden Endlosschleife getan. Nach und nach wurden immer kompliziertere Lösungsmöglichkeiten genannt, die aber in der gegebenen Zeit nicht fehlerfrei umgesetzt werden konnten. Als Folge haben wir immer noch einen Test “rot”. Wer Lust hat kann sich also die Quellen vom github Repository ziehen und als Hausaufgabe den verbleibenden Test “grün” machen.

In der Nachbetrachtung haben wir noch einige Sachen festgestellt:

Was lief gut?

• Die Rotation der Teilnehmer klappte problemlos
• Lösungsideen sprudelten förmlich aus dem Publikum
• Interessante Edge-Cases wurden gefunden
• Viele kleine Tipps (z.B. Resharper Shortcuts) wurden ausgetauscht
• TDD wurde als erfolgreich für die Kata angesehen
• Die Randori-Form sorgt für Aktivität
• Ganz wichtig: Es hat Spaß gemacht!

Was wollen wir besser machen?

• Schneller den ersten Test schreiben
• Intensivere Diskussion des Interfaces
• Noch mehr Wert auf das Naming legen
• Versuchen die einfachste Lösung zu wählen
• Mehr Wert auf Refactoring legen
  • wurde etwas vernachlässigt, da wir viel Zeit an der Endlosschleife verbraucht haben
• Die Rollen Driver, Co-Pilot und Publikum klarer trennen
• Nach jedem implementierten Testcase bzw. jeder Rotation der Teilnehmer in das git Repository einchecken
• Von Anfang an externe Tastatur und Maus für den Laptop bereit stellen
• Internetverbindung um Syntaxfrage schneller klären zu können

Als möglichen Termin für das Dojo haben wir jetzt grob jeweils den 3. Mittwoch im Monat vorgeschlagen. Über die Xing-Gruppe der .NET User Group Hamburg werden wir natürlich auch wieder entsprechende Einladungen verschicken.