Clean Code Development: Die Tugenden

‍Um die Grundwerte von Clean Code Development zu erreichen, gibt es eine Reihe von Tugenden, die während dem Entwicklungsprozess zu beachten sind. Diese sollten regelmäßig in Erinnerung gerufen werden, um verinnerlicht zu werden, bis sie automatisch bei Verstößen gedanklich auf sich aufmerksam machen. 

Die Clean Code Development Tugenden in der Übersicht

‍

Schätze Variation (Value Variation)

Diese Tugend steht dem häufigen Streben nach Konsolidierung, Vereinheitlichung und Standardisierung entgegen. Die Variationen sind zwingend Ergebnisse kontinuierlicher Verbesserung und sollten geschätzt werden, weil sie die Flexibilität und Widerstandsfähigkeit erhöhen. Diese Tugend zahlt auf die Werte Wandelbarkeit und Kontinuierliche Verbesserung ein. 

‍

‍

Tue nur das Nötigste (Do Only What´s Neccessary)

Clean Code Developer sollen auf vorzeitige Optimierungen verzichten, um nicht unnötige Codeteile zu optimieren, welche später vielleicht nicht mehr relevant sind. Optimierungen kosten immer viel Aufwand. Wer vorsichtig ist, spart oft wertvolle Ressourcen für das, was für den Kunden wirklich nützlich ist. Clean Code Developer schreiben keine Codefragmente, die nicht wirklich gebraucht werden. Wer mehr tut als das Einfachste, lässt den Kunden warten und macht die Lösung unnötig kompliziert. Daher gilt es, immer die einfachsten Lösungen zu finden. Diese Tugend zahlt auf die Werte Produktionseffizienz und Wandelbarkeit ein. 

‍Exemplarische Prinzipien dafür sind:

• Vorsicht vor Optimierungen! (Prinzip des roten Grads)
• You Ain´t Gonna Need It (YAGNI) (Prinzip des blauen Grads)
• Keep it simple, stupid (KISS) (Prinzip des roten Grads) 

‍

Isoliere Aspekte (Isolate Aspects)

Wenn Clean Code Developer während der täglichen Arbeit Aspekte isolieren, vermeiden sie ungünstige Programmstrukturen, die Verständnis und Weiterentwicklung später erschweren würden. Die Tugend „Isoliere Aspekte“ zahlt auf den Wert Evolvierbarkeit ein. 

‍Exemplarische Prinzipien dafür sind:

• Don‘t Repeat Yourself (DRY) (Roter Grad)
• Separation of Concerns (SoC) (Orangener Grad)
• Single Level of Abstraction (SLA) (Orangener Grad)
• Single Responsibility Principle (SRP) (Orangener Grad)
• Interface Segregation Principle (ISP) (Gelber Grad)
• Implementation spiegelt Entwurf (Blauer Grad)
• Integration Operation Segregation Principle (IOSP) (Roter Grad) 

‍

Minimiere Abhängigkeiten (Minimize Dependencies)

Unnötige Abhängigkeiten zwischen einzelnen Komponenten eines Systems können das Verständnis und die Weiterentwicklung erschweren. Aus diesem Grund nutzen Clean Code Developer die Tugend „Minimiere Abhängigkeiten“, wodurch eine Komponente weniger von ihrer Umgebung abhängt. Schnittstellen zwischen Komponenten müssen so einfach wie möglich gestaltet werden. Diese Tugend zahlt wie seine Vorgänger auf den Wert Evolvierbarkeit ein.

‍Exemplarische Prinzipien dafür sind:

• Dependency Inversion Principle (Gelber Grad)
• Information Hiding Principle (Gelber Grad)
• Law of Demeter (Grüner Grad)
• Open Closed Principle (Grüner Grad)
• Tell, don‘t ask (Grüner Grad)
• Interface Segregation Principle (ISP) (Gelber Grad)
• Integration Operation Segregation Principle (IOSP) (Roter Grad)

‍

Halte Versprechen ein oder Minimize Surprises (Honor Pledges)

Code sollte so wenige Überraschungen wie möglich enthalten, wozu auch zählt, dass die Implementierung den Entwurf widerspiegelt.  Eine Komponente bietet über ihre äußere Schnittstelle Funktionalität an. Gemäß dem Liskovschen Substitutionsprinzip dürfen auch davon abgeleitete Komponenten nicht widersprechen. Diese Tugend zahlt auch auf den Wert Evolvierbarkeit ein.

‍Exemplarische Prinzipien dafür sind:

• Liskov Substitution Principle (Gelber Grad)
• Principle of Least Astonishment (Gelber Grad)
• Implementation spiegelt Entwurf (Blauer Grad)
• Favour Composition over Inheritance (FCoI) (Roter Grad)

‍

Umarme Unsicherheit (Embrace Uncertainty)

Softwareentwicklung im Voraus bis in letzte Details zu planen, ist praktisch unmöglich. Statt sich vor dem stetigen Wandel zu fürchten, heißen wir ihn willkommen und stellen uns auf ihn ein. Wir speichern alle Entwicklungsstände in einem Versionsverwaltungssystem, sodass wir jederzeit zu älteren Versionen zurückkehren oder neue Entwicklungslinien abzweigen können. Die nötige Sicherheit geben uns viele automatisierte Tests. Diese Tugend zahlt auf die Werte Evolvierbarkeit und Kontinuierliche Verbesserung ein.

‍Exemplarische Prinzipien dafür sind:

• Ein Versionskontrollsystem einsetzen (Roter Grad)
• Automatisierte Integrationstests (Orangener Grad)
• Automatisierte Unit Tests (Gelber Grad)
• Mockups (Testattrappen) (Gelber Grad)
• Continuous Integration (Grüner Grad)
• Inversion of Control Container (Grüner Grad)

Fokussiere (Focus)

Durch die Komponentenorientierung, den Test-first-Ansatz und die Begrenzung der parallel bearbeiteten Aufgaben konzentrieren sich Clean Code Developer auf das wesentliche Problem und arbeiten dadurch effizienter. Diese Tugend zahlt auf den Wert Produktionseffizienz ein.

‍Exemplarische Prinzipien dafür sind:

• Komponentenorientierung (Blauer Grad)
• Test first (Blauer Grad)
• Limit WIP

‍

Wertschätze Qualität (Value Quality)

Die Ansprüche an hohe Qualität können nur durch automatisierte Tests, gegenseitige Reviews und statischer Codeanalyse sichergestellt werden. Diese Tugend zahlt wie die Vorgängertugend auf den Wert Produktionseffizienz ein. 

Exemplarische Prinzipien dafür sind:

• Akzeptiere nur hohe Qualität
• Automatisierte Unit Tests (Gelber Grad)
• Reviews (Orangener Grad)

Mach fertig (Get Things Done)

Software ist nicht einsetzbar, wenn sie nicht vollendet ist. Deshalb wird in kleinen Schritten entwickelt, um regelmäßig Ergebnisse ausliefern zu können. Diese Tugend zahlt ebenfalls auf den Wert Produktionseffizienz ein. 

Exemplarische Prinzipien dafür sind:

• Iterative Entwicklung (Blauer Grad)
• Continuous Delivery (Blauer Grad)
• Limit WIP

Halte Ordnung (Stay Clean)

Gemäß der Pfadfinderregel aus dem roten Grad, sollte der Platz immer sauberer hinterlassen werden, als er vorgefunden wurde. Kleine Verbesserungen werden an Ort und Stelle direkt vorgenommen und nicht verschoben. Angewendet auf die Softwareentwicklung bedeutet das, dass Code umgebaut wird, wenn er dadurch besser wird, bevor der Clean Code Developer zur nächsten Codestelle übergeht. Diese Tugend zahlt auf die Werte Evolvierbarkeit, Korrektheit und Produktionseffizienz ein.

Exemplarische Prinzipien dafür sind:

• Die Pfadfinderregel beachten (Roter Grad)
• Einfache Refaktorisierungsmuster anwenden (Roter Grad)
• Komplexe Refaktorisierungen (Gelber Grad)
• Statische Codeanalyse (Metriken) (Grüner Grad)
• Code Coverage Analyse (Gelber Grad)
• Source Code Konventionen (Orangener Grad)

Bleib am Ball (Keep Moving) 

Clean Code Developer entwickeln sich über die Zeit und über viele Übungen hinweg immer weiter. Der ewige Kreislauf des Lernens und Verbessern hat kein Endpunkt. Der Anreiz entsteht durch neu geschriebenen Code von allein. Diese Tugend zahlt auf den Werte Kontinuierliche Verbesserung ein.

Exemplarische Prinzipien dafür sind:

• Lesen, Lesen, Lesen (Orangener Grad)
• Teilnahme an Fachveranstaltungen (Gelber Grad)
• Erfahrung weitergeben (Grüner Grad)
• Täglich reflektieren (Roter Grad)
• Root Cause Analysis (Roter Grad)
• Messen von Fehlern (Grüner Grad)
• Issue Tracking (Orangener Grad)
• Regelmäßige Retrospektiven

‍