Wenn der Code müffelt Code Smells vermeiden und beheben

Code Smells konterkarieren die Clean-Code-Idee. Wenn der Code stinkt, bedeutet das, dass er unsauber und unelegant geschrieben ist. Dagegen hilft nur ein sogenanntes Refactoring, das Umwandeln des Codes nach den Clean-Code-Prinzipien.

Wann immer etwas schlechten Geruch verbreitet, kann man davon ausgehen, dass es schmutzig oder sogar faul ist. Unerwünschte Dreingaben – Bazillen, Pilze, Insekten – sorgen für Fäulnisprozesse, die den Mief verbreiten. Das ist in der Programmierung nicht anders.

Code kann unsauber oder von Bugs befallen sein. Entwickler und Entwicklerinnen sprechen dann von Code Smells. Der Code ist nicht in Ordnung – und müffelt, natürlich nur virtuell. Grund ist aber immer, dass der Code unsauber ist, keine gute Qualität aufweist und dementsprechend nicht nach den Clean-Code-Prinzipien entwickelt wurde.

Code Smells: Das sind die Ursachen

Wenn der Code müffelt, kann es dafür natürlich viele Gründe geben. Einer der Hauptgründe sind sogenannte „Bloaters“: Code, Methoden und Klassen, die unnötig groß sind und dementsprechend den Code aufblähen. Das können zum Beispiel schlecht eingeteilte Klassen oder lange Methoden und Listen sein. Es gibt aber auch Entwickler, die zum Beispiel zu Primitives greifen, obwohl sich kleine Objekte anböten, oder schlicht sehr einfache Konstanten einsetzen.

Doch es gibt auch andere Gründe für den Code-Mief, etwa missbräuchliche Nutzung von Objekt-Orientierung durch fehlerhafte Klassen, Statements und Objekte. Auch sogenannte „Change Preventers“ – Code-Fragmente, die bei Änderung sehr viel Klein-Klein-Nachbearbeitung erfordern, tragen zum unsauberen Coding bei. Zudem gibt es „Dispensables“ – Dinge, die einfach nichts im Code zu suchen haben, weil sie überflüssig sind, sowie „Couplers“, die ein Übermaß an Klassen-Kopplung enthalten und damit das Prinzip der sauberen Trennung unterlaufen.

Code Smells sind oft Folge von Zeitnot oder Bequemlichkeit

Kurzum – Code Smells sind Inhalte, die unerwünscht, überflüssig und die Software unnötig aufblasen. Die dadurch entstehende Komplexität macht es anderen Entwicklern nicht nur schwer, Code zu verstehen, sondern kann natürlich auch die Ursache vielfältiger Bugs und Probleme mit der Software sein.

Unsauberer Code entsteht oft, wenn Entwickler „nur mal eben“ etwas ausprobieren, das funktioniert – und sich dann anderen Baustellen widmen. Der unsaubere Code arbeitet wie gewünscht, also bleibt er bestehen. Einmal angefangen, staut sich so etwas aber auf. Der unsaubere Code verursacht ein Verhalten, das möglicherweise mit dem nächsten unsauberen Code-Schnipsel geändert oder schlimmer – bis der Code von der „Fäule“ durchsetzt ist.

Arbeiten mehrere Entwickler an dem Code, multipliziert sich das Problem. Das Resultat sind unnötiger Umfang, eine unangemessene Rechenlast durch das Software-Produkt sowie Schwierigkeiten beim Ergänzen, Aktualisieren oder Optimieren der Code-Basis.

Code Smells durch Clean Coding vermeiden

Das Problem ist, dass es sich dabei um eine Art natürlichen Prozess handelt. Der Code beginnt erst nach und nach zu stinken, ohne dass es dafür einen offensichtlichen Grund gibt. Es handelt sich beinahe um Code-Entropie, eine unvermeidbare Zunahme an Chaos.

Dagegen hilft nur, schon früh im Entwicklungsprozess Clean-Code-Prinzipien zu übernehmen und diese auch einzuhalten. Das geringe Plus an Arbeit durch die Einhaltung und Überprüfung der Clean Code Prinzipien, egal ob es sich nur um Basis-Prinzipien wie KISS und DRY oder um detaillierte Clean-Code-Philosophie wie bei Robert C. Martin handelt.

Das Problem liegt daher auch eher bei Code, der bereits „stinkt“, weil die Prinzipien eben nicht von Beginn an eingehalten wurden. Die Feststellung, dass ein Code Smell vorliegt, ist dabei relativ einfach, wenn die oben genannten Probleme auftreten. Unsauberen Code loszuwerden ist dafür aber umso komplexer. Denn um Code Smells zu bereinigen, muss mitunter ein großer Teil der Code-Basis – oder sogar der gesamte Code – umgeschrieben und optimiert werden.

Refactoring: Unsauberen Code bereinigen

Möglich wird das mit Hilfe des sogenannten Refactoring. Hierbei handelt es sich um eine Methode, vorhandenen Code zu säubern, ohne dabei die Funktionalität zu ändern. Es werden dabei weder Funktionen hinzugefügt, noch entfernt – es sei denn, diese sind zwingend notwendig oder schlicht überflüssig. Es gibt neben der Entfernung des Code Smells mehrere Anlässe, um über eine Refakturierung nachzudenken:

• Verbesserung der Software-Performance

• Update auf neue Technologien

• Vorbereitung auf neue Features

In aller Regel bietet sich das Refactoring aufgrund des vergleichsweise hohen Aufwands vor allem bei Hauptversion-Upgrades an, nicht so sehr im Rahmen von Wartungsupdates. Reguläre Updates können aber natürlich dazu verwendet werden, den Code zumindest an den betroffenen Stellen zu optimieren, sofern das an dieser Stelle sinnvoll ist.

Refactoring durchführen: Es gibt mehrere Methoden

Vor der Durchführung des eigentlichen Refactoring steht natürlich zunächst die Analyse: Wie schlimm ist ein Code Smell? Wie dringend muss er entfernt werden? Und an welchen Stellen befindet er sich? Grundsätzlich ist es in diesem Zusammenhang sinnvoll, vom Größten zum Kleinsten vorzugehen: Gibt es zum Beispiel aufwändige Bibliotheken oder Klassen, die getrennt werden können? Wo gibt es Dopplungen im Code? Was kann abstrahiert, zusammengefasst oder sogar ersatzlos gestrichen werden? Es ist sinnvoll, sich dabei von Innen nach Außen vorzuarbeiten: Je essenzieller ein Code-Bestandteil ist, desto größer der Effekt bei einer Refakturierung.

Methoden zur Refakturierung in der Übersicht

1. Abstraktion und Trennung

Die Abstraktion ist die Aufspaltung vorhandener Funktionalität in kleinere Unterfunktionen, Methoden und Klassen. Dadurch kann Code-Redundanz reduziert und Wiederverwendbarkeit erhöht werden. Zudem kann die Abstraktion die Rechenlast deutlich mindern.

2. Zusammenführung

Bei der Zusammenführung werden vorhandene Lösungen, die jedoch verdoppelt vorliegen – etwa weil zwei Entwickler an verschiedenen Stellen die gleiche Funktion entwickelt haben – zusammengeführt.

3. Vereinfachung

Bei der Vereinfachung wird die vorhandene Code-Basis darauf überprüft, ob sich der vorliegende Code vereinfachen lässt. Das kann zum Beispiel auch im Rahmen einer Modernisierung erfolgen. Überflüssige oder redundante Elemente werden auf diese Weise ausgemerzt und bei Bedarf zusammengeführt oder abstrahiert.

4. Organisation

Um den Code neu zu organisieren, ist es sinnvoll, die Abhängigkeiten zu überprüfen und herauszufinden, wie sehr Elemente voneinander abhängen. In einem zweiten Schritt sollten diese Elemente dann getrennt und verschlankt werden, um am Ende einen schlankere und effizientere Code-Basis zu erzielen.

5. Datenorganisation

Wo immer Daten verschoben werden, kann ineffizienter Code nicht nur Ineffizienz, sondern auch Sicherheitsprobleme verursachen. Diese können durch Auslagerung von Daten in Klassen oder Objekte sowie deren Verbindung und Trennung deutlich zuverlässiger und sauberer gestaltet werden.

Code Smell von Grund auf bekämpfen

Entwicklerinnen und Entwickler, die von Vornherein vermeiden möchten, dass es zu einem aufwändigen und kostspieligen Refactoring kommt, sollten – neben der Befolgung vorhandener Regeln – auf ihre eigenen Gewohnheiten achten. So gibt es Developer, die einen Code-Schnipsel, der für eine bestimmte Anwendung gut funktioniert hat, einfach übernehmen – obwohl dieser an der gewünschten Stelle eben nicht unbedingt gut funktioniert.

Falsch verstandene oder auch fremdkopierte Code-Schnipsel können ebenfalls zu Code-Smells beitragen. Auch wer gerne „Spaghetti-Code“ produziert oder Objekte am liebsten riesengroß gestaltet, sollte an dieser Stelle in sich gehen – und einfach seine Gewohnheiten ändern. Dann neigt der Code auch nicht so schnell zum Stinken.

(ID:49868850)