Architekten programmieren nicht [OOP 2010]

Habe ich Ihre Aufmerksamkeit? Architekten programmieren nicht, ja das glaube ich – und stehe damit wohl gegen den (agilen?) Mainstream. Aber etwas “Gegenstrom” macht frisch und kregel ;-)

Wer etwas auf sich hält, sagt mal etwas zur Rolle des Architekten. Nach Lektüre eines weiteren Artikels von Neal Ford habe ich mir gedacht, darin sollte ich anderen nicht nachstehen. Also hier mal einige Gedanken zur Aufgabe des Architekten in der Softwareentwicklung.

Architekt als Rolle

Zunächst: Architekt ist für mich eine Rolle. Das ist ganz wichtig. Denn sonst wäre es unmöglich, dass sich kleinere Projekte einen Architekten leisten könnten. Idealerweise nimmt dann ein Projektbeteiligter (oder eine kleine Gruppe) die Rolle des Architekten ausschließlich ein – doch das ist eben nicht immer möglich. Also kann in kleinen Teams dieselbe Person sowohl Architekt wie noch etwas anderes sein.

Architekt als Schnittstellenfunktion

In Übereinstimmung mit vielen anderen bin ich sicher auch noch, wenn ich den Architekten als eine Person an der Schnittstelle zwischen anderen Projektbeteiligten sehe. Der Architekt ist insofern ein Übersetzer. Er hat Kontakt mit dem Kunden. Er muss mit der Projektleitung auf Augenhöhe sprechen. Er ist ein wichtiger technischer Ansprechpartner für das Entwicklerteam.

Ein Architekt muss daher ein gerüttelt Maß an Softskills besitzen. Er ist in ständigen Gesprächen und Verhandlungen. Er muss immer wieder auf dem Verständnisniveau seiner Gesprächspartner erklären. Er muss gut zuhören können. Er muss vermitteln/moderieren können. Und er braucht auch Durchsetzungskraft.

Architektur von Systemen von Funktionseinheiten

Ein Architekt hat aber natürlich nicht nur mit Menschen zu tun. Sein Metier ist die Software. Und da dreht sich seine Verantwortung ganz allgemein darum, Systeme von Funktionseinheiten zu entwerfen. Ja, genau so allgemeine denke ich das. Eine Funktionseinheit kann ein Betriebssystem Prozess (oder EXE) sein, das kann eine Maschine sein oder eine ganze Anwendung oder ein Cluster. In jedem Fall geht es um “Bausteine”, die Software sind oder Software ermöglichen, die zusammengeschaltet einen Kundennutzen bieten.

So allgemein möchte ich die Definition halten, um der ewigen Diskussion, was denn der Unterschied zwischen Application Architect und Enterprise Architect usw. sei, aus dem Weg zu gehen. Das sind einfach alles Architekten, die mit dem Entwurf von Funktionseinheiten zu tun haben, die nur eben auf unterschiedlichen Abstraktionsebenen liegen. Die Prinzipien sind jedoch auf allen Ebenen eher mehr als weniger gleich. Flexibilität und Effizienz müssen auch immer in Balance gehalten werden.

Und wenn Sie daraus jetzt lesen, dass dann doch jeder Entwickler auch Architekt sei, weil er Funktionseinheiten plane (allemal Klassen und Methoden), dann haben Sie Recht. Jeder Entwickler ist auch immer auf einer gewissen Ebene Architekt. (Manche nennen dann das, was er plant, Design statt Architektur, aber den Unterschied möchte ich grad mal vernachlässigen.)

Architektur als Abstraktion

Architekten gehen mit Funktionseinheiten um, Entwickler auch. Wo ist dann der Unterschied zwischen beiden?

Architekten planen, Entwickler bauen.

Das ist der entscheidende Unterschied. Er liegt wieder mal im Abstraktionsniveau. Architekten haben Überblick, Entwickler Detailblick. Architekten stehen auf einem Hügel und entwickeln Strategien, Entwickler führen aus.

Eine solche Aufgabenteilung halte ich für absolut natürlich und naheliegend. Führung und Ausführung sind zwei ganz unterschiedliche Tätigkeiten. Sozusagen unterschiedliche concerns der Softwareentwicklung.

Ein Dirigent führt ein Orchester, ein Musik spielt darin ein Instrument. Das heißt nicht, dass ein Dirigent kein Instrument spielen müsse. Im Gegenteil! Dirigenten sind immer ausgewiesene Instrumentalisten sogar auf mehreren Instrumenten. Aber während ein Dirigent dirigiert, spielt er (gewöhnlich) keines seiner Instrumente.

Daraus leite ich auch ab, dass ein Architekt eben nicht programmieren sollte. Zumindest nicht in dem Projekt, für das er Architekt ist. Das wäre ein Widerspruch zum Prinzip der Separation of Concerns, das auch auf Organisationen angewandt werden sollte.

Ein Architekt soll technisch absolut fit sein. Keine Frage! Er muss sich fit halten, er muss dem Team, das seine Architektur technisch auf Augenhöhe begegnen, er muss Erfahrung im Einsatz von Technologien haben, damit er sie planen kann. Dazu braucht es Praxis, Praxis, Praxis. Aber diese Praxis sollte ein Architekt sich nicht (!) in dem Projekt holen, in dem er Architekt ist.

Er mag im Pair Programming mit Entwicklern arbeiten – aber nicht als Driver. Er  mag Spikes entwickeln, um eine Architekturvision abzuklopfen. Er soll natürlich in Reviews eine sehr aktive Rolle spielen. Aber von Produktionscode sollte er die Hände lassen.

Der Grund ist ganz einfach: Wenn der Architekt seine Hände im Produktionscode schmutzig macht, gewinnt er soviel Detailwissen, verstrickt er sich so sehr im Tagesgeschäft, dass er seine Aufgabe als derjenige, der Überblick behält, nicht mehr erfüllen kann. Denn Überblick, Weitblick, Strategie: darum geht es bei Architektur. Bezogen auf die Abstraktionsebene soll der Architekt die Interessen des Großen Ganzen vertreten. Dazu braucht es jedoch Distanz von den nitty gritty details.

Architekt als Bewahrer

Und was ist das Große Ganze, für das der Architekt verantwortlich ist? Was ist das Ergebnis seiner Schnittstellenfunktion? Er grenzt sich zunächst von Projektmanagement oder auch einem ScrumMaster und ProductOwner ab, die auch das Große Ganze im Blick haben. Aber ganz untechnisch. Deren Interesse ist es, dass es voran geht. Die wollen nicht unter die Haube der Benutzeroberfläche einer Anwendung schauen. “Muss laufen!” ist ihr Credo. (Wobei der ScrumMaster sogar noch weniger Anspruch hat. Ihm geht es nur darum, dass das Vorgehensmodell korrekt gelebt wird. Wohin damit dann gegangen wird, ist ihm eigentlich egal.)

Der Architekt ist also der technische “Großverantwortliche”. Er muss den Einsatz von Technik und technischen Konzepten so planen, dass sie die Kundenwünsche erfüllt. Er wie die anderen ist er dabei selbstverständlich dem Zeit- und Kostenrahmen verpflichtet.

Konkret ist die Aufgabe des Architekten, dass die folgenden Aspekte von Software im Sinne des Kunden ausgeprägt und in Balance sind:

• Nützlichkeit
• Benutzbarkeit
• Belastbarkeit
• Evolvierbarkeit

Zu dieser Liste hat mich die Alte Definition von (Bau)Architektur in Wikipedia inspiriert. Nach der beruht Architektur auf drei Prinzipien: Stabilität, Nützlichkeit und Anmut (firmitas, utilitas, venustas).

Software ist kein Bauwerk. Also geht es bei Softwarearchitektur auch um anderes als Bauarchitektur. Dennoch glaube ich daran, dass Softwarearchitektur genauso scharf definiert werden sollte. Diese Aspekte scheinen mir das so zu leisten, dass keiner wegfallen darf und keiner mehr dazu kommen muss. (Oder habe ich eine –keit übersehen?)

Nützlichkeit: Software hat nur einen Zweck: Dem Kunden zu nutzen nach seinen Anforderungen. Das technisch sicherzustellen, ist die vornehmste Aufgabe des Architekten. Software die nicht nutzt, ist ihr Geld nicht wert. Nützlichkeit ist hergestellt, wenn die funktionalen Anforderungen wie auch nicht funktionale Anforderungen erfüllt sind. Nur wenn die Software tut, was sie tun soll, wenn sie das schnell genug tut und sicher genug usw., dann nützt sie. Darauf ist das System der Funktionseinheiten und die Nutzung von Technologien auszurichten.

Benutzbarkeit: Alle Nützlichkeit nützt nichts, wenn sie dem Anwender nur schwer zugänglich oder verständlich ist. Den Architekten sehe ich daher – vielleicht etwas untypisch – in der Verantwortung, die Usability im Blick zu behalten. Er muss das Team immer wieder dazu anhalten, Funktionalität nicht nur irgendwie auf die Straße zu bringen, sondern in einer Weise, dass sie dem Anwender auch “ohne Verrenkungen” zur Verfügung steht. Dem Kunden (ProductOwner) kann es nicht überlassen werden, schon bei der Anforderungsdarlegung oder durch Nörgeln beim Test von Releases Usability einzufordern. Die Softwareentwicklung selbst muss davon eine Vision haben – und die vertritt der Architekt.

Belastbarkeit: Software läuft nicht immer nur in Schönwetter. Benutzerzahlen steigen ungeplant, Datenvolumina nehmen unerwartet zu, Angreifer suchen nach Schlupflöchern, Anwender gehen unsachgemäß mit ihr um, Hardware fällt aus… Software ist vielen Belastungen diesseits und jenseits expliziter Kundenanforderungen ausgesetzt. Der Architekt muss das voraussehen und seine Planung angemessen darauf abstellen. Er  muss Toleranzen “einrechnen” und Spielräume schaffen. Dazu ist natürlich Erfahrung nötig – aber keine Glaskugel ;-) Belastbarkeit bedeutet, dass Software ihre Nützlichkeit auch über die unmittelbaren Anforderungen hinaus behält oder mit wenig Aufwand wiedergewinnen kann.

Evolierbarkeit: Zuguterletzt ist der Architekt dafür zuständig, über die Anforderungen des Kunden heute hinaus zu sehen. Zumindest er muss das Verständnis haben, dass Software sich ständig wandelt und daher eine Struktur haben muss, die sich an solchen Wandel immer wieder leicht anpassen lässt. Ein Architekt kennt den Kunden insofern besser als der sich selbst ;-) Auch wenn der Kunde meint, alle Wünsche geäußert zu haben, weiß der Architekt, dass das hochwahrscheinlich nicht der Fall ist – und muss seine Architektur (angemessen) flexibel halten. Software soll dem Kunden nicht nur heute dienen, sondern auch morgen und übermorgen. Evolvierbarkeit ist die Bedingung für die Möglichkeit zukünftiger Nützlichkeit.

Zur Evolvierbarkeit gehört auch, dass Veränderungen nicht nur möglich sind, sondern das auch mit vertretbarem Aufwand. Allemal hier schwingt also auch die Produktionseffizienz als Aspekt mit. Speziell herausgehoben habe ich sie jedoch nicht, da sie ansonsten der allgemeinen Verantwortung des Architekten unterliegt, der – wie die anderen Projektverantwortlichen auch – darauf achtet, dass mit Zeit und Geld sorgsam umgegangen wird.

Und ein Wort noch zur Korrektheit: Nützlichkeit schließt Korrektheit ein. Deshalb habe ich die Korrektheit nicht in dieser Verantwortlichkeitsliste ausdrücklich aufgeführt. Sie ist so grundlegend, dass sie eigentlich keiner Erwähnung bedarf. Ohne die Möglichkeit, Korrektheit jeder Funktionseinheit “auf Zuruf” belegen (oder zumindest überprüfen) zu können, ist das Ergebnis der Planung eines Architekten nicht wirklich Architektur zu nennen. Nützlichkeit und Evolvierbarkeit sind ohne Korrektheit bzw. ihre ständige systematische und damit automatisierte Prüfung nicht denkbar.

Der Architekt plant eine Software, d.h. ein System aus Funktionseinheiten, so, dass die Aspekte Nützlichkeit, Benutzbarkeit, Belastbarkeit und Evolvierbarkeit im Sinne absehbarer Kundenanforderungen ausbalanciert sind. Das ist keine leichte Aufgabe. Sie erfordert viel Erfahrung und technisches Know-How.

Vor allem erfordert sie aber eben ein strategisches Denken, das sich nicht gemein machen darf mit Codierungsdetails. Deshalb glaube ich ganz fest, dass ein Architekt nicht in seinem Architekturprojekt programmieren sollte. Er verliert sonst die Distanz, die nötig ist, um sich für diese vier wichtigen Aspekte gegen den Druck zu stemmen, den unweigerlich Projektmanagement, Kunde und Team auf ihn ausüben.

Call for Papers: prio.conference – Verteilte Architektur

Am 19. und 20. Oktober 2010 ist es wieder soweit: Die prio.conference (www.prioconference.de) widmet sich einem Thema, das viele Entwickler bewegt. In diesem Jahr ist das “Verteilte Architektur”.

Wie in den Vorjahren bin ich Technical Chair und suche spannende, wegweisende, lehrreiche Vorträge. Wer seine Erfahrung zum Thema “Verteilte Architektur” weitergeben möchte oder jemanden kennt, der etwas zu sagen hat, der melde sich per Email an techchair (at) prioconference.de.

Der offizielle Call for Papers ist hier: http://www.prioconference.de/Call-for-Papers

Ich bin gespannt auf Ihre Einreichungen…

TDD, aber bitte mit System

Hier sind zwei recht ordentliche Artikel zum Thema TDD: Teil 1 und Teil 2. Mir gefällt daran besonders, dass Neal Ford sein TDD beginnt mit einer kleinen Liste von Schritten auf dem Weg zur Beantwortung der Frage, ob eine Zahl eine Vollkommene Zahl ist.

Bei allem Gefallen an seinen Artikeln reibe ich mich jedoch an einigen Punkten.

Fragliche Objektorientierung

Wenn Sie die Wurzel einer Zahl berechnen wollten und ich würde Ihnen sagen, das geht mit C# so:

var sqc = new SqrtCalculator(7);
Console.WriteLine(“Wurzel aus 7: {0}”, sqc.Calculate());

Würden Sie das als naheliegend empfinden? Kaum.

Oder wenn ich Ihnen anbieten würde, einen String bei einer Zeichenkette so zu splitten:

var splitter = new StringSplitter(“ ”);
var words = splitter.Split(“the quick brown fox”);

Würden sie das als komfortable ansehen? Kaum.

Nichts anderes schlägt Neal Ford aber vor, wenn er seine Implementation zur Prüfung von Zahlen auf Vollkommenheit so aussehen lässt:

var c = new Classifier(6);
Console.WriteLine(“Ist 6 vollkommen: {0}”, c.IsPerfect());

Das ist genausowenig komfortabel oder naheliegend wie die obigen Beispiele. Das ist erzwungen objektorientiert. Das ist ein für den Anwender der Funktionalität nicht nachvollziehbarer API.

Die Prüfung, ob eine Zahl vollkommen ist, ist eine Funktion genauso wie die Prüfung, ob eine Zahl gerade ist oder die Berechnung ihrer Wurzel. Warum also sollte ich als Nutzer einer solchen Funktion(alität) eine Klasse instanzieren müssen? Warum sollte diese Klasse auch noch zustandsbehaftet sein?

Neil leitet das auf Seite 8 seines Teil 1 daraus ab, dass zwei interne Funktionen (factorsFor(int number) und isFactor(int number)) auf demselben Parameter arbeiten, der zu prüfenden Zahl. Er meint, das sei nun wirklich zuviel prozedurale Programmierung. Oder vielleicht scheut er sich vor der “Feuchtigkeit” der Wiederholung eines Parameters? Ich weiß es nicht. Ich finde es einfach nur überkandidelt – und zwar leider in einer Weise die symptomatisch ist für die Branche. Denn sein Vorgehen ist ja tragisch: Er will das Gute erreichen, verschlimmert die Situation aber. Er möchte einem Paradigma dienen, das für sich gepachtet zu haben scheint, dass es durch und durch gut sei – aber das Paradigma passt leider nicht zum Problem. Mit dem Hammer Objektorientierung wird die funktionale Schraube eingeschlagen. Autsch!

Hier dagegen meine Lösung:

public class VollkommeneZahlen

{

    public static bool IstVollkommen(int zahl)

    {

        return EchteTeilerVon(zahl)

              .ErgebenEineVollkommeneZahl(zahl);

    }

    …

Die Nutzung sieht so aus:

Console.WriteLine(VollkommeneZahlen.IstVollkommen(6));

Das halte ich sowohl in der Anwendung wie auch in der Implementation für intuitiv und angemessen. Egal, ob das nun speziell objektorientiert oder sonstwas ist. Der Anwender versteht es, weil eine Funktion als Funktion realisiert ist. Und der, der den Code liest, sieht sofort, wie das Ergebnis in zwei Schritten zustande kommt.

Unklare Verteilung von Verantwortung

Nicht nur ist aber die Objektorientierung für das Problem unangemessen, wie ich finde. Sie hat sogar einen negativen Effekt auf die Verständlichkeit und Flexibilität des Codes.

Vollkommene Zahlen sind solche, deren echte Teiler in Summe die Zahl ergeben. Die Teiler von 6 sind 1, 2, 3 und 6. Allerdings ist 6 kein echter Teiler. Die Summe ist deshalb nur aus 1, 2 und 3 zu bilden und die ergibt 6. Damit ist 6 eine Vollkommene Zahl.

In Neal Fords Code ist die besondere Behandlung der Zahl selbst als unechter Teiler an zwei Stellen codiert:

Er fügt die Zahl selbst als Teiler zunächst der Menge aller Teiler hinzu – und zieht sie am Ende wieder ab. Damit erfüllt auch seine Funktion calculateFactors() nicht mehr wirklich ihre Verantwortlichkeit, die Teiler der Zahl zu berechnen. Das trägt nicht zur Verständlichkeit der Algorithmusimplementierung bei.

Außerdem ist isPerfect() nicht nur von der Zahl als Zustand abhängig, sondern auch noch indirekt von der Menge der Teiler, die calculateFactors() berechnet und sumOfFactors() auswertet. Solcher Zustand erhöht immer die Komplexität einer Lösung. Und er macht die Wiederverwendung von Methoden in anderen Zusammenhängen schwieriger.

Meine Funktion IEnumerable<int> EchteTeilerVon(int zahl) hingegen ist von nichts abhängig und kann daher in jedem Zusammenhang, in dem nur die echten Teiler einer Zahl relevant sind, wiederverwendet werden.

Auch macht bool ErgebenEineVollkomeneZahl(this IEnumerable<int> teiler, int zahl) den Code selbstdokumentierender. Das Abstraktionsniveau der Bestandteile von IstVollkommen() ist einheitlich. Bei Neal hingegen liegen calculateFactors() und der Ausdruck zur Berechnung des Rückgabewertes auf unterschiedlichen Abstraktionsniveaus. Der Leser muss sich zusammenreimen, dass eine Zahl vollkommen ist, wenn die Summe von Teilern abzüglich einer Zahl gleich der Zahl ist. Zugegeben, das ist nicht so kompliziert, doch es ist ein spürbarer intellektueller Aufwand, der nicht Not tut. (Insbesondere verwunderlich ist sein Ansatz, da er in einem anderen Artikel das Single Level of Abstraction Prinzip lobt.)

Gesucht: Klares Vorgehen

Schließlich vermisse ich bei Neals Artikeln, dass er sein Vorgehen nicht weiter deutlich sichtbar systematisiert. Er tut schon das Richtige, in dem nicht mit TDD “reinspringt” und als erstes einen Test für isPerfect() schreibt, sondern mal einen Gedanken an den Algorithmus verschwendet. Er denkt also nach, bevor er codiert. Doch das hebt er nicht hervor. Einzig der “TDD workflow” wird als Handlauf für das Vorgehen wieder einmal thematisiert.

Schade. Denn zu TDD gehört mehr, denke ich. Hier mein Version eines Entwicklungsprozesses, in den TDD eingebettet sein sollte:

1. Verstehen
2. Nachdenken/planen
3. Unsicherheiten ausräumen
4. Codieren

Diese Schritte beziehen sich auf ein Problem bzw. auf die das Problem lösende Funktionseinheit. Sie sind daher rekursiv zu durchlaufen, sollte die Funktionseinheit in weitere zerfallen. Das ist ein wichtiger Punkt! Denn auf Zerlegungsebene eines Problem gilt es zuerst zu verstehen, dann zu planen usw.

Zu 1: Am Anfang der Entwicklung einer Softwarelösung – sei es Methode oder Klasse oder Komponente oder Anwendung – steht das Verstehen. Investieren Sie Zeit, das Problem oder gar den Kunden zu verstehen. Machen Sie sich klar, was die Anforderungen wirklich sind. Tragen Sie Fälle zusammen, die beschreiben, was die Eingaben/Parameter und der zugehörigen erwarteten Ausgaben/Ergebnisse sind. Das hört sich selbstverständlich an. In der Praxis ist aber schwierig und bedarf immer wieder Mut und Disziplin. Beide werden oft nicht ausgebracht. Schöner ist es, schnell den Code Colt zu ziehen und zu programmieren.

Leider ist ungenügendes Verständnis aber wohl eine der wesentlichen Ursachen für soviele Probleme der Softwareentwicklung. Wer ungenügend versteht, der implementiert zuviel. Wer ungenügend versteht, der implementiert das falsche oder inkorrekt.

Letztlich ist ungenügendes Verständnis zwar nie ganz zu vermeiden, doch ein wenig mehr Mühe darf es schon sein. Vor allem ist in den Prozess des Verständnisaufbaus der Kunde sehr aktiv mit einzubeziehen. Fragen Sie ihm Löcher in den Bauch! Dafür ist er da ;-) Lassen Sie ihn nicht aus seiner Verantwortung. Wenn er etwas von Ihnen will, dann soll er wirklich so genau wie möglich beschreiben, was das ist, wie es aussehen soll, wie es sich verhalten soll. Erbitten Sie von ihm sehr konkrete Abnahmetests.

Falls der Kunde sich bei solch “peinlichen Befragung” ziehrt, machen Sie ihm klar, dass das Ergebnis Ihrer Arbeit nur so gut sein kann wie seine Spezifikation. Garbage in, garbage out – das gilt auch hier. Wer nur ungenau spezifiziert, der kann auch nur ein ungenaues Ergebnis bekommen. Dann muss nachgebessert werden. Das macht niemandem Freude.

Da die meisten Kunden mit sehr genauer Spezifikation überfordert sein werden, gibt Ihnen das die Chance, ein agiles Vorgehensmodell “zu verkaufen”. Nutzen Sie die Chance! Aber nehmen Sie das nicht als Entschuldigung, ohne gründliches Verständnis mit dem Codieren zu beginnen.

Zu 2: Wenn Sie meinen, das Problem durchdrungen zu haben, sollten Sie noch nicht zur Tastatur greifen. Auch nicht, wenn Sie TDD betreiben wollen. Tun Sie sich den Gefallen und denken Sie zuerst über einen Lösungsansatz nach. Diese Phase fällt leider immer wieder zu kurz aus. Auch in wohlmeinenden Coding Dojos wird das nicht unbedingt praktiziert. TDD als Test-Driven Design verstanden soll es richten. Codieren kann Planung und Nachdenken aber nicht ersetzen, sondern allenfalls unterstützen. Eine Struktur für Ihre Software ergibt sich nicht einfach. Die will bewusst entworfen werden.

Das ist, was mir an Neals Artikel gefallen hat: Er hat über das Problem nachgedacht und einen kleinen Plan aufgestellt. Er ist auf zumindest drei Funktionseinheiten/Verantwortlichkeiten gekommen, aus denen eine Lösung für das Problem “Vollkommene Zahlen erkennen” besteht:

• Potenzielle Teiler einer Zahl erzeugen
• Feststellen, ob eine potenzieller Teiler tatsächlich ein Teiler ist
• Aufsummieren der tatsächlichen Teiler, um festzustellen, ob sie die Zahl ergeben

Das sind zugegeben kleine Funktionseinheiten. Macht aber nichts. Jede, die Sie beim Nachdenken finden, ist eine gute. Denn damit bekommen Sie “Bausteine” an die Hand, die sie separat testen können. Das ist immer gut. Und Sie können womöglich entscheiden, in welcher Reihenfolge Sie deren Umsetzung angehen.

Ein zunächst monolithisches Problem zerfällt so in kleinere Probleme und die womöglich wiederum in kleinere usw. Nachdenken hilft also bei der Komplexitätsbewältigung.

Zu 3: Allerdings mag es sich herausstellen, dass Sie sich mit der Umsetzung der einen oder anderen Funktionseinheit, auf die Sie beim Nachdenken gestoßen sind, nicht 100%ig wohlfühlen. Das ist ganz normal. Es mag an der Problemdomäne liegen oder an einer Technologie, die zum Einsatz kommen soll. Deshalb ist es wichtig, dass Sie vor dem Codieren noch einen Zwischenschritt machen.

Seien Sie sensibel für Ihre Unsicherheiten und räumen Sie sie aus. Das können Sie durch das Studium von Fachliteratur tun. Oder Sie befragen den Kunden nochmal. Oder Sie programmieren etwas. Rotzen Sie Code raus (Spike Solution), um sich z.B. mit dem neuen O/R Mapper vertraut zu machen, bevor Sie damit Produktionscode schreiben. Oder für das Problem der vollkommenen Zahlen könnten Sie sich Erweiterungsmethoden anschauen, die es möglich machen, die Funktion IstVollkommen() so lesbar zu gestalten.

Solange Sie noch unsicher sind, sollten Sie nicht mit der Codierung beginnen. Ansonsten entsteht schnell akzidenzielle Komplexität, d.h. Komplexität, die nicht nötig ist, die Sie letztlich auch nicht wollen.

Wenn Sie etwas programmieren, um Ihre Unsicherheit abzubauen, dann schmeißen Sie es am Ende besser weg. Nehmen Sie Erkenntnisse mit ins Codieren, aber keinen Code. Auch sind solche Spike Solutions keine Prototypen. (Allerdings können Sie offizielle Prototypen natürlich immer noch mit dem Kunden vereinbaren. Dann teilen Sie Ihre Unsicherheit mit dem Kunden.)

Zu 4: Erst wenn Sie genau verstehen, was der Kunde braucht, einen Plan haben, wie Sie ihm das geben können, nicht mehr unsicher sind, erst dann sollten Sie mit dem Codieren beginnen. Das gilt aus meiner Sicht auch für TDD. Oder gerade für TDD! Denn immer wieder sehe ich bei Entwicklern, die mit TDD beginnen, dass sie Schwierigkeiten haben, sich zuerst Tests vorzustellen, bevor sie etwas implementiert haben.

Das liegt meiner Meinung nach daran, dass sie das Problem noch nicht genügend gut durchdrungen haben bzw. der Kunde keine Akzeptanztestfälle geliefert hat. Und/oder es liegt daran, dass sie unsicher sind, was eigentlich zu implementieren ist. Denn wer davon keine Vorstellung hat, der tut sich schwer damit, Erwartungen zu formulieren.

Der Effekt ist dann oft, dass TDD mit trivialen Tests oder Sonderfalltests begonnen wird. Die für den Kunden viel wichtigeren “happy day” Szenarien werden dadurch auf die Lange Bank geschoben. Klarheit für deren Implementation ergibt sich auch nicht aus solchen Tests. Geschäftig mit Tests zu beginnen kann also auch ein subtiles Symptom von Prokrastination sein.

Zusammenfassung

TDD ist eine zentrale Praktik für professionelle Softwareentwicklung. Gerade deshalb ist es nötig, sich ihr ganz bewusst zu sein und immer wieder zu fragen, ob sie schon optimal betrieben wird. Ein systematisches Vorgehen hilft dabei – gerade am Anfang.

Vor dem falschen Programmierparadigma schützt TDD aber natürlich nicht. Wir tun also gut daran, auch seine Grenzen bewusst zu sehen. TDD produziert also immer nur Code auf dem fachlichen Wissensstand seines Anwenders. Deshalb ist es gut, immer wieder über den Tellerrand (der Objektorientierung) zu schauen und sich mit anderen auszutauschen.

Generiert – Architekturcompiler für Event-Based Components

Da hab ich ja was angerichtet: Event-based Components ziehen immer größere Kreise. Immer mehr Entwickler “wollen es tun”. Selten habe ich soviel direktes positives Feedback zu einem Konzept bekommen. Irgendwie scheine ich da einen Nerv getroffen zu haben.

Bei allem Wohlwollen haben EBCs aber natürlich auch noch Schwachstellen. Die kommen durch das Feedback und das “Herumspielen” mit dem Konzept ans Licht. Eines ist die Verdrahtung. Die ist zwar technisch simpel, aber nervig zu implementieren. Weil nicht nur wenige Komponenteninstanzen in andere zu injizieren sind, sondern viele Pins der Komponenteninstanzen mit denen anderer verbunden werden müssen, steigt der Aufwand für die Laufzeitintegration. Dem stehen zwar große Gewinne gegenüber – doch nervig bleibt die Verdrahtung.

Besser würde die Lage natürlich, gäbe es einen hübschen EBC Designer à la LabVIEW.

Soweit sind wir aber noch nicht. Das braucht noch etwas mehr Erfahrung mit EBCs, glaube ich. Und auch Zeit, denn einen Designer zu basteln, ist kein Pappenstil.

Geht´s denn nicht aber auch ohne Designer schon ein bisschen einfacher? Einen “automatischen Verdrahter” hatte ich ja schonmal gebastelt. Der funktioniert aber nur in sehr einfachen Szenarien ausreichend. Wenn es komplizierter wird, reicht “Verdrahtung nach Konvention” nicht mehr aus. Dann müssten zusätzliche Informationen her. Dann wären wir wieder bei einer Architekturbeschreibung.

Also habe ich mir gedacht: Warum nicht mit einer Architekturbeschreibung ohne Designer anfangen? Also habe ich mal “rumgesponnen”. Erst habe ich mir ne textuelle DSL überlegt. Doch dann dachte ich, dass es noch besser wäre, noch klarer zu entkoppeln. Also bin ich auf das gute alte XML gekommen.

Wie wir am Ende Architekturen entwerfen und formulieren, ist egal. Eine graphische oder auch textuelle Notation wird sich immer in ein XML-Format übersetzen lassen. Das kann die Konstante in der Mitte sein zwischen Entwickler und Code.

Deshalb habe ich mir mal ein ganz einfaches Format überlegt, mit dem man einfache EBC-Architekturen beschreiben kann. Als Beispiel eine Stopuhr-Anwendung. Zuerst die Architektur gemalt in Visio:

Und hier die Übersetzung in das XML-Format. Ich nenne es mal ebclang für EBC Language:

Die Komponenten sind für sich mit ihren Output- und Input-Pins beschrieben, anschließend die Verdrahtung. Ich denke, das ist recht einfach zu verstehen. Geschachtelte Komponenten habe ich einstweilen allerdings noch außen vor gelassen.

Nachdem ich so eine XML-Architekturbeschreibung hatte, habe ich die von Hand ganz systematisch in Codeartefakte übersetzt. Das funktionierte sehr einfach. Es lässt sich gut automatisieren.

Deshalb habe ich in einem Anfall von Lust am “mud wrestling” ;-) einen Übersetzer dafür gebastelt. Der ist aus dem Stand gleich zu sehr hübschem Brownfield Code geworden. Aber das macht nichts. Er ist als Spike Solution gedacht, nicht mehr. Ich wollte mit dem Code nur das Feld der Artefaktgenerierung explorieren, bevor ich eine “richtige” Version entwickle.

Der ebclang.compiler übersetzt eine XML-Architekturdefinition wie oben in Assemblies und Visual Studio Projekte. Das sind im Einzelnen:

• myapp.messages.dll und myapp.messages.csproj: Ein Projekt, das alle Nachrichtentypen implementiert. Der Compiler legt jeden Nachrichtentyp, der kein Standardtyp ist, darin als Klasse an.
• myapp.specifications.dll: Eine Assembly, die die Komponenten in Form von Interfaces spezifiziert.
• myapp.wiring.dll: Eine Assembly, die Komponenteninstanzen verdrahtet.

“myapp” steht für den Applikationsnamen wie im XML auf <MainBoard> angegeben. Die Spezifikation und das Wiring werden bewusst nur als Assemblies erzeugt, damit niemand auf die Idee kommt, sie zu verändern. Darin steckt die manifestierte Architektur. Die soll nur durch das XML veränderbar sein.

Die Nachrichtentypen jedoch müssen “nachgebessert” werden können. Deshalb darf man am messages-Projekt arbeiten. Der Compiler überschreibt Nachrichtentypquelldateien nicht.

Zusätzlich legt der Compiler noch Werkbänke für die Komponenten an. Das sind VS Projektmappen mit zwei Projekten, einem für die Komponentenimplementation und einem für deren Tests.

Das Vorgehen beim Entwurf einer EBC-Architektur ist mit dem Compiler wie folgt:

1. Anlegen eines Verzeichnisbaums für die Artefakte. Hier die Minimalstruktur:

Wurzelverzeichnis, darunter ein Verzeichnis lib/ mit nunit.framework.dll und weiteren für die Anwendung nötigen Bibliotheken. Und das Verzeichnis arc/, in dem die Architekturbeschreibung liegt. (Das Batch-File ruft den ebclang-Compiler für die XML-Datei auf.)

Nach Übersetzung der Architekturdefinition sieht der Artefaktbaum so aus:

Die .log-Dateien enthalten den C#-Compiler Output der Übersetzungen der myapp.* Projekte. Falls mal was schief gegangen sein sollte, darin nachschauen, bei welchem Generierungsschritt es gehakt hat. Der Compiler ist eine Konsolenanwendung und liefert auch noch Informationen während der Übersetzung.

Die Projekte *.specifications und *.wiring sollten nicht weiter beachtet werden. Der Compiler könnte sie genauso gut löschen. Ich habe sie bisher zur Fehlersuche aber noch drin gelassen. *.messagetypes enthält das Projekt, in dem die Nachrichtentypen “ausgefleischt” werden können.

Wichtig ist das bin-Verzeichnis in arc/:

Hier sind die Assemblies angekommen, die der Compiler erzeugt hat. Von hier müssen sie in allen weiteren Anwendungsprojekten referenziert werden. ebclang.basics.dll enthält bisher nur einen Nachrichtentypen für bidirektionale Kommunikation (Request<,>) und seine Erweiterungsmethoden.

Mehr ist eigentlich nicht nötig als Vorarbeit durch den Compiler. Auf der Basis der Assemblies kann man loslegen mit der Anwendungsimplementation. Die aufwändige Verdrahtung steckt ja in *.wiring.dll. Das EBC-Leben ist damit einfacher geworden.

Dennoch tut der Compiler etwas mehr. Er erzeugt auch noch Gerüstprojektmappen für die Komponenten im source/ Verzeichnis des Artefaktbaumes:

Diese Werkbänke geben den Rahmen vor, in dem Komponenten implementiert werden sollen. Erstens fokussieren sie den Blick, indem sie jede Komponente in eine eigene Projektmappe stellen. Zweitens geben sie vor, dass automatisiert getestet werden muss. Drittens setzen sie schon die Referenzen auf die generierten Assemblies und stellen den Output-Path auf ein globales bin-Verzeichnis.

Das mögen Kleinigkeiten sein. Doch in Clean Code Developer Seminaren, die viel mit Architektur zu tun haben, bemerken wir immer wieder, dass diese Kleinigkeiten viel Zeit kosten. Also habe ich versucht, hier eine erste Linderung zu bringen. Die ist noch nicht perfekt, weil z.B. keine Klasse für die Komponentenimplementation generiert wird, aber sie ist ein Anfang.

Was bleibt ist die Visualisierung von Architekturdefinitionen. Die soll ultimativ natürlich ein Designer übernehmen. Bis dahin wollte ich aber nicht warten. Also habe ich noch einen kleinen Visualisierer für die XML-Definitionen gebastelt. Den macht man einfach parallel zu Visual Studio oder einem anderen XML-Editor auf und lädt die Architekturdatei. Immer, wenn die sich verändert, aktualisiert man die Diagrammdarstellung und bekommt visuelles Feedback.

Die Visualisierung ist natürlich nicht interaktiv und auch nicht besonders hübsch. Aber sie erfüllt erstmal ihren Zweck, denke ich. Und der ist, dass – wer will – einen leichteren Einstieg in den Umgang mit Event-based Components bekommt.

Am Flipchart mit einer Architekturskizze beginnen, die in das XML-Format übersetzen und dabei die Übersetzung mit dem Visualisierer immer wieder überprüfen. Am Ende die Artefakte mit dem Compiler erzeugen und Nachrichtentypen sowie die Komponentenimplementationen in Visual Studio entwickeln.

Fehlt am Ende nur noch eines: Ein Programm, dass die ganzen Komponenten instanziert und die generierte Verdrahtung aufruft. So ein Programm – ich nenne es Host – generiert der Compiler noch nicht. Aber es ist schnell geschrieben. Dem Compiler-Download liegt es in der Nachher-Version der Beispielanwendung bei:

Mit einem DI Container wie Unity sieht ein Host z.B. so aus:

   19 static void Main()

   20 {

   21     Application.EnableVisualStyles();

   22     Application.SetCompatibleTextRenderingDefault(false);

   23 

   24     // Prepare Build

   25     IUnityContainer uc = new UnityContainer();

   26     uc.RegisterType<IPortal, FrmPortal>(new ContainerControlledLifetimeManager());

   27     uc.RegisterType<IStopuhr, Stopuhr>();

   28     uc.RegisterType<MainBoard, MainBoard>();

   29 

   30     // Build & Bind

   31     var mainboard = uc.Resolve<MainBoard>();

   32 

   33     // Run

   34     Application.Run((Form)uc.Resolve<IPortal>());

   35 }

Das Portal ist ein Singleton, damit es nicht zweimal instanziert wird. Einmal während der Injektion in das MainBoard und einmal am Schluss bei Run().

Wer diesen ersten Wurf für einen Architekturcompiler für EBCs interessant findet, der kann ihn hier herunterladen. Wie immer freue ich mich über Feedback.