Zwei verschiedene Eigenschaften
Es gibt Code, den ich ziemlich schlecht finden würde, wenn er Teil eines größeren Systems wäre – und vollkommen in Ordnung, wenn er in einem kleinen Skript steckt.
Nicht weil für Skripte andere Regeln der Programmierung gelten. Sondern weil ich etwas anderes von ihnen erwarte.
Ein Skript soll Dateien umbenennen, Daten migrieren oder einen Report erzeugen. Wenn es das zuverlässig macht, hat es seinen Zweck erfüllt.
Bei Software, an der ein Team über Jahre arbeitet, reicht mir das nicht.
Ein gutes Skript
Ein gutes Skript muss nicht besonders schön sein. Es soll Dateien umbenennen, Daten migrieren oder einmal im Monat irgendeinen Report erzeugen. Wenn es das zuverlässig macht, hat es seinen Zweck erfüllt.
Natürlich kann man auch dort über schöne Abstraktionen, saubere Schichten und ein ordentliches Domainmodell nachdenken. Man kann aber auch irgendwann Feierabend machen.
Denn niemand erwartet, dass drei Entwickler in zwei Jahren gleichzeitig neue Features in dieses Skript einbauen. Vielleicht läuft es zehnmal und verschwindet danach wieder. In diesem Kontext ist seine wichtigste Eigenschaft ziemlich eindeutig: Es funktioniert.
Mit einem Prototyp ist es ähnlich. Er soll eine Frage beantworten. Funktioniert die Idee? Ist der Algorithmus schnell genug? Versteht jemand diesen Ablauf?
Auch hier darf der Code Dinge tun, bei denen man in einem langlebigen System langsam nervös würde. Vielleicht wird er später aufgeräumt. Vielleicht komplett neu geschrieben. Vielleicht stellt sich nach zwei Tagen heraus, dass die Idee sowieso nicht funktioniert und das Repository kann wieder dahin zurück, wo es herkam.
Die Struktur ist in diesem Moment nicht das eigentliche Problem.
Und dann bleibt der Prototyp
Interessant wird es, wenn aus diesem Code irgendwann Software wird.
Dafür braucht es keinen großen technischen Moment. Meistens kommt einfach eine weitere Anforderung. Dann noch eine. Jemand baut eine zweite Variante ein. Ein neuer Kollege arbeitet zum ersten Mal an der Stelle. Drei Monate später soll sich etwas ändern, das beim ersten Entwurf niemand vorgesehen hatte.
Der Code funktioniert dabei möglicherweise immer noch genauso gut wie am ersten Tag. Aus Sicht der Funktionalität ist überhaupt nichts passiert.
Trotzdem haben sich die Anforderungen an ihn verändert.
Plötzlich möchte ich wissen, wo eine neue Regel hingehört. Welche Klasse für etwas verantwortlich ist. Ob eine Annahme nur für diesen einen Fall gilt oder für das ganze System. Und wenn ich eine Methode ändere, wäre es ganz angenehm zu wissen, welche drei anderen Dinge ich damit gerade versehentlich kaputtmachen könnte.
Darauf gibt mir die Funktionalität keine Antwort.
Wofür Struktur da ist
Ich glaube, genau deshalb wird Struktur in Software manchmal falsch diskutiert.
Sie ist keine Dekoration für Entwickler, die ihren Code gerne ordentlich haben. Sie macht ein Programm auch nicht automatisch besser. Ein perfekt strukturiertes Programm, das die falsche Rechnung erstellt, bleibt ziemlich nutzlos.
Struktur löst ein anderes Problem.
Sie hilft Menschen dabei, ein System zu verstehen und zu verändern.
Wenn Verantwortlichkeiten klar sind, weiß ich eher, wo eine Änderung hingehört. Wenn Begriffe aus der Domäne auch im Code auftauchen, muss ich weniger übersetzen. Wenn Grenzen bewusst gezogen wurden, kann ich innerhalb einer davon arbeiten, ohne jedes Mal das halbe System im Kopf zu laden.
Der Compiler braucht davon erstaunlich wenig. Er ist auch mit einem 4.000-Zeilen-Service einverstanden, solange die Syntax stimmt.
Wir sind da etwas anspruchsvoller.
Gespeichertes Verständnis
Vielleicht ist das die Eigenschaft von Struktur, die ich lange unterschätzt habe: Struktur ist gespeichertes Verständnis.
Jemand hat einmal entschieden, dass diese beiden Dinge zusammengehören und jene beiden nicht. Dass diese Regel zur Domäne gehört und nicht zum Controller. Dass hinter zwei ähnlich aussehenden Abläufen tatsächlich unterschiedliche Konzepte stecken.
Gute Struktur konserviert solche Entscheidungen im Code.
Das heißt nicht, dass jede Abstraktion automatisch wertvoll ist. Im Gegenteil. Eine Struktur, deren Idee niemand mehr versteht, speichert nicht besonders viel Verständnis. Sie erzeugt hauptsächlich Fragen mit Interfaces.
Aber wenn sie funktioniert, muss der nächste Entwickler nicht wieder bei null anfangen. Ein Teil dessen, was frühere Entwickler über das System verstanden haben, steckt bereits in seiner Form.
Das Feature funktioniert doch
Vielleicht kommen daher auch manche Diskussionen, bei denen zwei Entwickler auf denselben Code schauen und zu völlig unterschiedlichen Urteilen kommen.
Der eine sieht das Feature und sagt: Es funktioniert doch.
Der andere sieht dieselbe Stelle und denkt daran, wie die nächste Änderung aussehen wird.
Beide können recht haben.
Wenn dieser Code nur einmal laufen muss, ist eine große Aufräumaktion wahrscheinlich verschwendete Zeit. Wenn er die nächsten fünf Jahre jeden Monat verändert wird, sieht dieselbe Rechnung plötzlich anders aus.
Die Frage ist dann nicht, ob Funktionalität oder Struktur wichtiger ist. Die Frage ist, welche Eigenschaften diese Software für ihr weiteres Leben braucht.
Ein Skript darf einfach funktionieren. Ein Prototyp darf eine Frage beantworten und danach sterben. Von einem System, an dem ein Team über Jahre arbeitet, erwarte ich mehr.
Nicht weil langlebige Software schöner sein muss.
Sondern weil morgen wieder jemand daran arbeiten muss.
Zwei verschiedene Fragen
Funktionalität beantwortet eine ziemlich offensichtliche Frage:
Kann die Software das?
Struktur beantwortet eine andere:
Können wir mit dieser Software weiterarbeiten?
Bei kleinen oder kurzlebigen Programmen reicht die erste Antwort oft vollkommen aus. Je länger Software lebt und je häufiger sie verändert wird, desto wichtiger wird die zweite.
Das Programm muss dafür nichts Neues können.
Nur wir müssen morgen noch verstehen, wie wir ihm etwas Neues beibringen.