Code Smells und Refactorings – Anwendungsentwickler-Podcast #147

Um Code Smells und ihre Behebung mittels Refactorings geht es in der einhundertsiebenundvierzigsten Episode des Anwendungsentwickler-Podcasts.

TL;DR

Bei meinen Code-Reviews geben mir Codesmells konkrete Hinweise darauf, welche Stellen ich überarbeiten sollte. Als IT-Azubi kannst du damit etwa mehrfach vorhandenen Code oder Methoden mit zu vielen Aufgaben erkennen und Probleme mit anderen Entwickler:innen präzise besprechen. Mit passenden Refactorings lässt sich der Code schrittweise verbessern, während er lauffähig bleibt. Ob du einen Smell behebst, hängt von seinen Folgen und dem Aufwand ab; eine bewusst beibehaltene Stelle verdient einen Kommentar, der den Grund erklärt.

Kapitelmarken

  • [00:00:01] Thema: Codesmells und Refactorings
  • [00:00:57] Codesmells als Hilfe bei Code-Reviews mit IT-Azubis
  • [00:02:04] Refactoring von Martin Fowler als Grundlage
  • [00:03:30] Was ist ein Codesmell?
  • [00:04:50] Einen Codesmell bewusst beibehalten
  • [00:05:50] Woher der Begriff Codesmell kommt
  • [00:07:47] Probleme erkennen und mit Entwickler:innen besprechen
  • [00:09:38] Codesmells mit Refactorings beheben
  • [00:10:44] Überblick über die klassischen Codesmells
  • [00:13:04] Duplicate Code: mehrfach vorhandenen Code zusammenführen
  • [00:16:17] Comments: verständliche Namen und begründete Kommentare
  • [00:19:56] Long Method: Methoden auf eine Aufgabe zuschneiden
  • [00:22:38] Large Class: Aufgaben auf passende Klassen verteilen
  • [00:24:48] Long Parameter List: Parameter reduzieren oder bündeln
  • [00:30:42] Wenn ein Refactoring einen anderen Smell erzeugt
  • [00:32:05] Feature Envy: Methoden zu ihren Daten verschieben
  • [00:34:01] Data Clumps: zusammengehörige Werte als Objekt abbilden
  • [00:35:29] DTOs als bewusst einfache Klassen
  • [00:36:27] Primitive Obsession: fachliche Werte in eigenen Klassen kapseln
  • [00:40:48] Switch Statements: wiederkehrende Fallunterscheidungen
  • [00:41:22] Divergent Change und Shotgun Surgery
  • [00:43:12] Parallel Inheritance Hierarchies
  • [00:43:56] Lazy Class
  • [00:44:32] Speculative Generality und YAGNI
  • [00:45:31] Temporary Field
  • [00:46:26] Message Chains und Law of Demeter
  • [00:47:54] Middle Man
  • [00:48:39] Inappropriate Intimacy
  • [00:49:20] Alternative Classes with Different Interfaces
  • [00:50:24] Incomplete Library Class
  • [00:50:54] Data Class
  • [00:51:42] Refused Bequest
  • [00:53:09] Codesmells in der täglichen Arbeit
  • [00:54:14] Literatur und weiterführende Links
  • [00:54:43] Kommentare und Feedback

Probeabo bei Audible (Affiliate)

Inhalt

  • Was ist ein Code Smell?
    • Smells sind Indikatoren für Code, der überarbeitungswürdig ist.
    • Man erkennt sie anhand verschiedener Muster (z.B. lange Methoden).
    • Die Smells können mit Refactorings überarbeitet und (hoffentlich) eliminiert werden.
    • Nicht alle Smells sind immer schlecht. Sie dienen nur als Anhaltspunkt, noch einmal über den Code nachzudenken.
  • Woher kommt der Name Code Smell?
    • Kent Becks Oma wird das Zitat „If it stinks, change it.“ zugesprochen, das sich auf das Wechseln von Windeln bei Babys bezieht.
    • Kent Beck hat diese Idee auf Code übertragen: Wenn der Code seltsam „riecht“, sollte man ihn anpassen.
  • Wobei helfen uns Code Smells?
    • Mit Code Smells können wir Stellen im Code aufdecken, die problematisch sind, und diese überarbeiten. Dadurch wird der gesamte Code insgesamt „besser“.
    • Die benannten Smells helfen uns durch eine gemeinsame Sprache bei der Diskussion mit anderen Entwicklern (ähnlich wie Design Pattern).
  • Was können wir gegen Code Smells tun?
    • Das Mittel gegen Code Smells sind die Refactorings.
    • Im Buch von Martin Fowler* gibt es eine übersichtliche Tabelle, welche Refactorings gegen welche Smells helfen können.
  • Sind Code Smells immer böse?
    • Code Smells sind nur ein Anhaltspunkt für Optimierungen. Der Entwickler muss selbst entscheiden, ob der Smell schlecht ist.
    • Einige Code Smells hängen zusammen und das Auflösen des einen (z.B. Introduce Parameter Object) führt zur Einführung eines anderen (z.B. Data Class).
  • Welche Code Smells gibt es?
    • Duplicate Code
      • Doppelter Code führt bei Änderungen schnell zu Fehlern, weil zu ändernde Stellen übersehen werden.
      • Refactorings: Extract Method, Pull Up Method
    • Comments
      • Kommentare können helfen, den Code zu verstehen, aber häufig sind sie überflüssig und können durch sprechendere Bezeichner komplett eliminiert werden.
      • Refactorings: Extract Method, Rename Method
    • Long Method
      • Lange Methoden sind schwieriger zu verstehen, zu testen und anzupassen.
      • Refactorings: Extract Method
    • Large Class
      • Zu große Klassen machen häufig mehr als sie sollen und verletzen das Single Responsibility Principle. Das macht sie u.a. schwer testbar.
      • Refactorings: Extract Class, Extract Subclass
    • Long Parameter List
      • Viele Parameter bei Methoden deuten darauf hin, dass diese zu viele Aufgaben übernehmen. Sie machen die Methoden schwer testbar und schwer verständlich. Außerdem müssen die Parameterlisten tendenziell oft angepasst werden.
      • Refactorings: Replace Parameter with Method, Introduce Parameter Object
    • Feature Envy
      • Wenn Methoden oder Klassen sich viele Informationen „besorgen“ müssen, bevor sie ihren Job machen können, ist das ein Zeichen dafür, dass die Komponenten besser an einer anderen Stelle aufgehoben wären.
      • Refactorings: Move Method
    • Data Clumps
      • Wenn verschiedene Daten immer zusammen herumgereicht werden (z.B. Startdatum und Endedatum), ist das ein Zeichen für eine fehlende Abstraktion (z.B. Zeitraum).
      • Refactorings: Introduce Parameter Object, Extract Class
    • Primitive Obsession
      • Die Scheu vor eigenen kleinen Klassen führt oft dazu, dass doppelter Code entsteht und eine gute Kapselung verhindert wird.
      • Refactorings: Replace Data Value with Object, Extract Class, Introduce Parameter Object
    • Switch Statements: Gleiche Fallunterscheidungen werden häufig an mehreren Stellen benötigt und führen zu doppeltem Code, der mit Polymorphie verhindert werden könnte.
    • Divergent Change: Einzelne Klassen müssen aufgrund von verschiedenen Änderungen angepasst werden.
    • Shotgut Surgery: Aufgrund einer einzelnen Änderung müssen verschiedene Klassen angepasst werden.
    • Parallel Inheritance Hierarchies: Sonderform von Shotgun Surgery, die das parallele Anlegen von Subklassen in verschiedenen Hierarchien erfordert.
    • Lazy Class: Zu kleine Klassen, die keinen erkennbaren Mehrwert haben, sollten abgelöst werden.
    • Speculative Generality: Anstatt alle möglichen zukünftigen Entwicklungen zu antizipieren, sollte besser das Prinzip You Ain’t Gonna Need It befolgt werden.
    • Temporary Field: Instanzvariablen sollten nicht nur während der Laufzeit einzelner Methoden verwendet werden.
    • Message Chains: Objekte, die Objekte aufrufen, die wieder Objekte aufrufen, wissen zu viel über die fremde Implementierung und sind damit stark gekoppelt. Das verletzt das Law of Demeter.
    • Middle Man: Zu viel Delegierung ist auch nicht gut.
    • Inappropriate Intimacy: Klassen sollten nicht zu viele Details anderer Klassen kennen.
    • Alternative Classes with Different Interfaces: Gleiche Dinge sollten auch gleich benannt sein.
    • Incomplete Library Class: Wenn Librarys nicht alles tun, was wir brauchen, sollten wir sie ergänzen, anstatt alles neu zu entwickeln.
    • Data Class: Die guten alten POJOs oder Java Beans. Sie verhindern häufig saubere Kapselung und haben bei fehlender Geschäftslogik evtl. gar keine Daseinsberechtigung.
    • Refused Bequest: Wenn Subklassen Teile ihres Vermächtnisses (geerbte Member) nicht nutzen wollen oder können, ist vielleicht die Hierarchie falsch gewählt.

Literaturempfehlungen

Eine sehr schöne Liste möglicher Code Smells und ihrer Auswirkungen gibt es im Klassiker Refactoring von Martin Fowler*.

Martin Fowler - Refactoring: Improving the Design of Existing Code (Affiliate)*

Links

Zusammenfassung

Codesmells im Code-Review

Bei meinen Code-Reviews mit IT-Azubis helfen mir Codesmells, konkrete Stellen zu erkennen, die ich überarbeiten sollte. An solchen Mustern kannst du beispielsweise erkennen, weshalb sich Code schwer lesen lässt oder beim Testen Probleme macht. Manche fallen schon durch den Umfang einer Methode auf, andere zeigen sich erst beim Blick auf einzelne Zeilen.

Wenn du die Namen der Smells kennst, kannst du dich mit anderen Entwickler:innen genauer über den Code austauschen. Ein Begriff wie Feature Envy beschreibt für jemanden, der ihn kennt, bereits das betreffende Problem. Ähnlich wie Design Patterns schaffen Codesmells damit eine gemeinsame Fachsprache.

Wann du einen Smell behebst

Bevor ich eine auffällige Stelle ändere, prüfe ich, welche Folgen sie hat und wie aufwendig es wäre, sie zu überarbeiten. Je nach Kontext kann es sinnvoll sein, einen Smell bewusst beizubehalten, etwa wenn der Umbau den Code schwerer verständlich machen würde. Mit einem Kommentar zum Grund ersparst du der nächsten Person, dieselbe Frage erneut durchzugehen.

Beim Refactoring überarbeitest du den Code schrittweise und hältst ihn dabei lauffähig. Für einen Smell kommen oft mehrere Refactorings infrage. Auch deren Folgen gehören zur Entscheidung: Wenn du etwa eine lange Parameterliste durch eine Klasse ersetzt, kann dabei eine Data Class entstehen, deren Aufbau du wiederum prüfen solltest.

Häufige Codesmells und passende Refactorings

Duplicate Code

Wenn identischer oder sehr ähnlicher Code an mehreren Stellen steht, musst du bei einer Änderung jede davon finden. Eine übersehene Stelle führt dazu, dass Teile des Programms unterschiedlich arbeiten. Das passiert beispielsweise, wenn mehrere Switch Statements dieselben Enum-Werte behandeln und ein neuer Wert hinzukommt.

  • Mit Extract Method ziehst du den gemeinsamen Code in eine Methode und rufst sie an den betreffenden Stellen auf. IDEs wie Eclipse können diesen Schritt automatisch ausführen.
  • Mit Pull Up Method verschiebst du eine gleiche Methode aus mehreren Subklassen in deren gemeinsame Basisklasse.

Comments

Bei Kommentaren, die lediglich den sichtbaren Code beschreiben, entsteht zusätzlicher Aufwand beim Lesen und Pflegen. Ändert jemand den Code und übersieht den Kommentar, kann dieser anschließend etwas Falsches behaupten. Das Beispiel i++ mit dem Kommentar "i wird um 1 erhöht" zeigt dieses Risiko, sobald aus dem Ausdruck i-- wird.

Durch verständliche Bezeichner lässt sich vieles direkt im Code ausdrücken. Mit Extract Method kannst du einen erklärungsbedürftigen Abschnitt in eine passend benannte Methode ziehen. Rename Method hilft, wenn der bisherige Name die Aufgabe ungenau beschreibt.

Wenn du eine bewusste Entscheidung begründen möchtest, ist ein Kommentar sinnvoll. Dazu gehört beispielsweise der Grund, weshalb du einen Codesmell an einer bestimmten Stelle beibehältst.

Long Method

Bei Methoden mit vielen Zeilen stecken häufig mehrere Aufgaben zusammen, sodass eine Änderung an einem Teil auch andere Teile beeinträchtigen kann. Für meine Code-Reviews habe ich mir als persönliche Daumenregel gesetzt, Methoden mit mehr als fünf Zeilen genauer anzusehen. Dabei gibt es Ausnahmen.

Nach dem Single Responsibility Principle sollte eine Methode möglichst eine Aufgabe haben. Mit Extract Method ziehst du zusammengehörige Abschnitte heraus. Die ursprüngliche Methode kann anschließend über verständliche Aufrufe den Ablauf zeigen, während die Details in den einzelnen Methoden stehen. Weil du als Entwickler:in Code häufiger liest als schreibst, spielt das beim täglichen Arbeiten eine große Rolle.

Large Class

Wenn eine Klasse viele Aufgaben und Abhängigkeiten enthält, wird es schwieriger, einzelne Teile isoliert zu testen. Enthält sie etwa sowohl Datenbankcode als auch Code für das Dateisystem, musst du beim Testen womöglich beide Abhängigkeiten bereitstellen.

Ab ungefähr 100 Zeilen schaue ich genauer hin; auch diese Zahl ist eine persönliche Orientierung. Mit Extract Class verteilst du zusammengehörige Aufgaben auf eigene Klassen. Extract Subclass kommt infrage, wenn die Aufgaben fachlich in eine Vererbungshierarchie passen.

Long Parameter List

Bei mehr als drei Parametern prüfe ich, ob eine Methode passend zugeschnitten ist. Viele Parameter erschweren es, sie aufzurufen und zu testen. Haben mehrere Parameter denselben Typ, kannst du außerdem ihre Reihenfolge verwechseln. Sobald sich die Liste ändert, müssen bestehende Aufrufe angepasst werden.

Ein boolescher Parameter verdient ebenfalls Aufmerksamkeit, weil er darauf hinweisen kann, dass eine Methode abhängig vom Wert unterschiedliche Aufgaben übernimmt.

  • Replace Parameter with Method: Die Methode beschafft sich einen benötigten Wert selbst, etwa über einen Getter. Dadurch entstehen weitere Abhängigkeiten, die du beim Testen berücksichtigen musst.
  • Introduce Parameter Object: Du fasst zusammengehörige Parameter in einer eigenen Klasse zusammen und übergibst ein Objekt. Beispielsweise lassen sich Startdatum und Enddatum als Zeitraum weiterreichen.

Wenn du eine solche Klasse lediglich mit frei zugänglichen Feldern oder Gettern und Settern ausstattest, solltest du auch den Smell Data Class prüfen.

Feature Envy

Wenn eine Methode viele Informationen aus einer anderen Klasse abfragt, um damit zu arbeiten, liegt ihre Aufgabe möglicherweise näher bei dieser Klasse. Im Beispiel beschafft sich ein Beitragsberechner zahlreiche Werte aus einem Versicherungsvertrag und schreibt das Ergebnis anschließend zurück.

Mit Move Method verschiebst du die Methode dorthin, wo die benötigten Daten liegen. Dort kann sie direkt mit den internen Werten arbeiten. Auch bei einer Klasse im unpassenden Package kann es sinnvoll sein, ihren Platz zu prüfen.

Data Clumps

Wenn bestimmte Werte immer gemeinsam auftreten, können sie ein eigenes fachliches Objekt bilden. Startdatum und Enddatum lassen sich beispielsweise mit Introduce Parameter Object oder Extract Class zu einem Zeitraum zusammenfassen.

Im Konstruktor dieses Zeitraums kannst du prüfen, ob das Enddatum mindestens dem Startdatum entspricht. Damit liegt die Geschäftsregel an einer zentralen Stelle und muss beim Weiterreichen einzelner Datumswerte nicht immer wieder geprüft werden.

Bei DTOs, also Data Transfer Objects, ist eine Klasse ohne Geschäftslogik bewusst vorgesehen. Sie transportiert etwa Daten an ein Webfrontend. Ein eindeutiger Name oder Kommentar macht diesen Zweck erkennbar.

Primitive Obsession

Wenn fachliche Werte überall als einfache Datentypen weitergereicht werden, verteilen sich ihre Geschäftsregeln leicht über das Programm. Bei einem Vornamen als String müsstest du beispielsweise wiederholt prüfen, ob der Wert leer oder null ist.

Mit einer eigenen Klasse kannst du solche Regeln beim Erzeugen des Objekts prüfen. Eine Klasse Alter kann etwa negative Werte ablehnen. Dadurch vermeidest du mehrfach vorhandene Prüfungen. Wenn du früh mit passenden fachlichen Klassen arbeitest, lassen sich spätere Regeln dort ergänzen; ein bereits verbreiteter Datentyp lässt sich aufwendiger austauschen.

Als Refactorings kommen Replace Data Value with Object sowie Extract Class infrage. Für zusammengehörige Werte passt auch Introduce Parameter Object.

Weitere Codesmells

  • Switch Statements: Wiederkehrende Fallunterscheidungen verteilen ähnliche Logik im Programm. Mit Polymorphie lassen sich neue Fälle über passende Subklassen abbilden.
  • Divergent Change: Eine Klasse muss angepasst werden, wenn sich verschiedene voneinander unabhängige Dinge ändern. Das weist auf zu viele Aufgaben in dieser Klasse hin.
  • Shotgun Surgery: Eine einzelne fachliche Änderung erfordert Eingriffe in mehreren Klassen. Die betreffende Logik ist über das Programm verteilt und sollte zusammengeführt werden.
  • Parallel Inheritance Hierarchies: Eine neue Subklasse in einer Hierarchie verlangt zusätzliche Subklassen in anderen Hierarchien, etwa bei einer Autofabrik und den zugehörigen Autos. Dadurch verteilen sich zusammenhängende Änderungen auf mehrere Stellen.
  • Lazy Class: Eine kleine Klasse hat kaum noch einen erkennbaren Zweck. Das kann nach einem Refactoring passieren, wenn ihre Aufgaben in andere Klassen gewandert sind. Eine übrig gebliebene Klasse ohne Mehrwert kannst du entfernen.
  • Speculative Generality: Für mögliche spätere Anforderungen werden zusätzliche Abstraktionen eingebaut, die den heutigen Code schwerer verständlich machen. Nach YAGNI, "You Ain’t Gonna Need It", programmierst du die Anforderungen, die aktuell gebraucht werden.
  • Temporary Field: Instanzvariablen dienen lediglich einzelnen Methoden als kurzfristiger Speicher. Solche Felder erschweren es, den Zustand der Klasse zu verstehen. Häufig passen lokale Variablen besser.
  • Message Chains: Verkettete Aufrufe wie vertrag.getPolice().getBeitrag().getMonatszahlung() verlangen, dass der aufrufende Code die interne Objektstruktur kennt. Ändert sie sich, müssen die betreffenden Aufrufe angepasst werden. Das Law of Demeter gibt einen Anhaltspunkt, solche Abhängigkeiten zu begrenzen.
  • Middle Man: Eine Klasse leitet ihre Aufrufe lediglich an ein anderes Objekt weiter und liefert dessen Antworten zurück. Wenn sie dabei keinen eigenen Zweck erfüllt, kannst du diese Zwischenstelle entfernen.
  • Inappropriate Intimacy: Klassen verlassen sich zu stark auf interne Details anderer Klassen, etwa auf private Elemente, die über Reflection erreicht werden. Dadurch entstehen Abhängigkeiten von Details, die sich ändern dürfen.
  • Alternative Classes with Different Interfaces: Klassen bieten gleichartige Funktionen unter unterschiedlichen Namen an. Einheitliche Begriffe helfen dir, Methoden wiederzufinden und ihren Zweck zu verstehen.
  • Incomplete Library Class: Einer Bibliothek fehlt eine benötigte Funktion. Dafür lässt sie sich gezielt ergänzen, während ihre vorhandenen Funktionen erhalten bleiben.
  • Data Class: Eine Klasse enthält hauptsächlich Daten sowie Getter und Setter. Bei Domänenklassen lohnt sich die Frage, welche Geschäftslogik zu diesen Daten gehört. Für DTOs kann dieser Aufbau zum vorgesehenen Zweck passen.
  • Refused Bequest: Eine Subklasse erbt Methoden, die für sie unpassend sind. Dann solltest du die Vererbungshierarchie prüfen, etwa die Basisklasse verkleinern oder Methoden in passende Subklassen verschieben.

Literatur zum Nachschlagen

Für die Codesmells und Refactorings orientiere ich mich an der ursprünglichen Ausgabe von "Refactoring" von Martin Fowler, deren Beispiele in Java geschrieben sind. Die im Podcast erwähnte neuere Ausgabe arbeitet mit JavaScript. Im Buch findest du die einzelnen Schritte der Refactorings sowie eine Tabelle, die passende Refactorings den Smells zuordnet.

Unter anwendungsentwicklerpodcast.de/147 habe ich weitere Links zu Beispielen für Codesmells und Refactorings gesammelt.

Transkription der gesamten Episode

Automatisch erzeugte Transkription der Episode

[0:01] Herzlich Willkommen zum Anwendungsentwickler-Podcast, dem Podcast rund um die Ausbildung zum Fachinformatiker

[0:09] für Anwendungsentwicklung. In dieser Episode geht es um Codesmells und Refactorings. Viel Spaß!

[0:20] Hallo und herzlich Willkommen zur 147. Episode des Anwendungsentwickler-Podcasts.

[0:27] Mein Name ist Stefan Macke und heute geht es nach einigen Ausflügen in die nicht ganz so programmierlastige Welt mal wieder zurück zum Code.

[0:37] Steckt sogar schon im Titel heute drin, nämlich Codesmells. Heute gibt es mal wieder was für die Programmierer da draußen.

[0:43] Und zwar Dinge, die in unserem Code vielleicht nicht so toll sind, die uns Anlass geben, den vielleicht zu überarbeiten und am besten natürlich zu verbessern und nicht zu verschlimmbessern.

[0:52] Das wäre natürlich noch schlimmer. Aber worum geht es heute? Also ich habe mir das Thema mal rausgesucht, Codesmells.

[0:57] Darüber habe ich vor einiger Zeit auch mit meinen Azubis schon mal so eine kleine Lehrzielkontrolle gemacht.

[1:02] Ich finde es immer ganz wichtig, wenn man Code sich anschaut, ob es jetzt der eigene ist oder der fremde, ist egal, dass man irgendwie einen Anhaltspunkt hat,

[1:09] worauf man eigentlich achten sollte, was man vielleicht verbessern kann. Wir machen bei uns in der Ausbildung ganz viele Code-Reviews.

[1:14] Ich review den Code von den Azubis, aber die Azubis reviewen auch untereinander ihren Code.

[1:19] Und dann ist immer die Frage, ja worauf soll ich denn jetzt achten, wenn ich mir den Code da angucke?

[1:23] Sieht der schön aus oder was heißt denn jetzt, dass der Code gut ist oder dass der schlecht ist und verbessert werden muss?

[1:29] Das ist immer schwer zu greifen. Und da gibt es doch sowas Schönes, wo es sogar schon ein dickes Buchzug gibt, was man sich angucken kann,

[1:35] was wenigstens so ein paar Anhaltspunkte sind, worauf ich achten kann.

[1:39] Und das sind die sogenannten Codesmells. Und diese Codesmells, die möchte ich heute mal durchgehen.

[1:45] Davon gibt es einige. Ich kann heute nicht alle durchgehen, aber einige, die ich immer wieder sehe und gerade auch bei meinem Azubi-Code quasi immer wieder finde

[1:52] und auf die ich auch immer achte, die wollen wir ein bisschen im Detail durchgehen.

[1:56] Und die restlichen, die nenne ich einfach nur. Und wenn du das dann vertiefen willst, dann guck am besten in die Literatur,

[2:01] die ich auch in den Shownotes natürlich verlinkt habe.

[2:04] Das zentrale Buch, an dem ich mich heute orientiere, ist Refactoring von Martin Fowler.

[2:08] Ein absoluter Klassiker. Hat schon ein paar Jahre, teilweise sogar Jahrzehnte schon auf dem Buckel.

[2:13] Ist aber immer noch absolut relevant und gerade vor kurzem tatsächlich auch in einer neuen Auflage rausgekommen.

[2:18] Die alte Auflage, da ging es rund um Java und Java-Code-Beispiele.

[2:21] In der neuen geht es um JavaScript, also auch sehr modern nochmal aufgemacht.

[2:25] Und heutzutage sind vielleicht auch ein bisschen andere Sachen wichtig, auf die man achten sollte.

[2:29] Und vor allem, wie man sie behebt, ist vielleicht in JavaScript auch ein bisschen anders als in Java oder anderen Sprachen.

[2:34] Und von daher, ich orientiere mich jetzt an der Originalauflage von früher, wo so die klassischen Refactorings drinstehen,

[2:41] aber eben auch die Codesmells, denn die Refactorings sind eigentlich nur dazu da, um diese Codesmells zu beseitigen.

[2:47] Also das, womit wir eigentlich anfangen in unserem Code, sind die Codesmells.

[2:50] Und wie wir die wegkriegen, das sind dann halt die Refactorings.

[2:53] Zum Thema Refactoring kann ich sicherlich nochmal eine eigene Episode machen, weil das ganze Buch dreht sich nur darum.

[2:59] Und das sind ein paar hundert Seiten, also das werde ich heute nicht erschöpfend behandeln.

[3:03] Mein Thema heute sind erstmal die Smells und warum die vielleicht schlecht sind und was man dagegen tun könnte.

[3:08] Aber ganz konkret, wie jetzt die Refactorings funktionieren, um die Dinger dann loszuwerden, die Smells, das können wir heute hier in dieser Episode nicht schaffen.

[3:15] Meine Idee ist, dass ich heute so eine kleine Liste durchgehe mit häufig anzutreffenden Codesmells,

[3:21] warum die eigentlich doof sind und was wir dann eventuell ganz allgemein dagegen tun können.

[3:26] Einen kurzen Ausflug da rein, was wir machen können, um den Code dann zu optimieren.

[3:30] Aber fangen wir vielleicht erstmal mit einer kurzen Definition an.

[3:33] Was ist denn überhaupt eigentlich ein Codesmell?

[3:36] Also Codesmells, das sind Indikatoren für Code, der überarbeitungswürdig ist.

[3:41] Was auch immer das jetzt heißt, ob der vielleicht nicht so gut lesbar ist, ob der nicht gut testbar ist,

[3:45] ob da irgendwie was Doppeltes drin ist, was rausgezogen werden muss, was auch immer.

[3:49] Irgendwas ist an dem Code komisch und da müssen wir Dinge dran verändern, damit der Code dann irgendwie besser wird.

[3:56] Was auch immer das dann heißt, das gucken wir uns dann im Konkreten mal an, wenn wir uns die einzelnen Codesmells anschauen.

[4:02] Grundsätzlich erkennt man die anhand verschiedener Muster, sage ich mal.

[4:06] Ein ganz einfaches Muster bei einem Codesmell ist, dass es eine Methode gibt, die sehr, sehr lang ist.

[4:11] Also wenn eine Methode viele Zeilen hat, ich sage jetzt einfach mal eine Hausnummer, 20 Zeilen oder vielleicht sogar noch länger,

[4:16] dann ist das ein Hinweis darauf zum Beispiel, dass diese Methode zu viel macht und überarbeitet werden sollte.

[4:21] Und davon gibt es jetzt verschiedene.

[4:23] Man kann jetzt also auf den Code draufschauen und eventuell sogar wirklich anhand dieser Muster schon erkennen,

[4:28] dass da irgendwas komisches ist, also lange Methoden, lange Klassen, solche Dinge.

[4:32] Es gibt aber auch Sachen, wo ich ins Detail reingucken muss, wo so ein Codesmell vielleicht wirklich nur in einer Zeile auffällt

[4:37] und der mir nicht direkt ins Gesicht springt, sage ich einfach mal.

[4:40] Aber grundsätzlich ist es schon so, dass man diese Muster, diese Smells im Code erkennen kann

[4:44] und dann ist das immer ein Anhaltspunkt, darüber nachzudenken, ob man hier was überarbeiten sollte.

[4:50] Wenn man einen Codesmell findet im Code, heißt das nicht, dass der sofort korrigiert werden muss

[4:54] und es gibt auch keine Alternative. Ich muss das machen.

[4:57] Da kommt quasi die Codesmell-Polizei und sagt, na, weg damit.

[5:00] Nein, so ist es nicht.

[5:02] Es kann auch Stellen im Code geben, wo der Codesmell vielleicht gar nicht schlimm ist

[5:07] oder vielleicht sogar beabsichtigt ist, um etwas anderes vielleicht einfacher zu machen oder so.

[5:11] Also Codesmells sind erstmal nur Anhaltspunkte und man muss sie nicht immer rücksichtslos eliminieren.

[5:18] Ich sage immer ganz gerne, wenn ich so einen Codesmell finde,

[5:21] da müsste ich mir Zeit nehmen, um einfach mal drüber nachzudenken, was das jetzt für eine Auswirkung hat.

[5:27] Und manchmal kann ich dann halt entscheiden, wenn ich darüber nachgedacht habe,

[5:30] Mensch, die Auswirkung, das alles umzustellen, ist, keine Ahnung,

[5:33] das dauert viel zu lange oder macht das Ganze noch schwieriger zu verstehen oder wie auch immer.

[5:37] Und dann würde ich mich bewusst dafür entscheiden, den Codesmell drin zu lassen.

[5:40] Dann sollte ich vielleicht kurz einen Kommentar daneben schreiben,

[5:42] damit jemand anderes, der den Codesmell dann findet, nicht das Gleiche überlegen muss.

[5:46] Aber grundsätzlich heißt es also nicht, Codesmells müssen immer eliminiert werden.

[5:50] Dann vielleicht noch, bevor wir weitermachen, dieser Name ist vielleicht etwas seltsam.

[5:54] Codesmell, also es riecht irgendwie komisch.

[5:57] Jetzt hat Code nun nicht unbedingt die Eigenschaft, dass er nach irgendwas riecht.

[6:00] Das ist ja ein rein virtuelles Konstrukt, ja.

[6:03] Woher kommt dieser komische Name?

[6:05] Das geht zurück auf eine Aussage oder ein Zitat von der Oma von Kent Beck.

[6:10] Kent Beck ist hier vielleicht ein Begriff.

[6:12] Das ist der Erfinder oder einer der Mitbegründer des Extreme Programming.

[6:15] Er hat viele gute Bücher geschrieben, zum Beispiel Test Driven Development by Example.

[6:18] Das heißt, er ist auch ein starker Verfechter von TDD.

[6:21] Er hat zum Beispiel auch JUnit mitentwickelt und so weiter.

[6:24] Also sehr gut unterwegs, gerade was das Testen angeht.

[6:27] Und Martin Fowler und er haben öfter mal so ein bisschen sich ausgetauscht

[6:30] über guten Code und Programmierung als Ganzes und so weiter.

[6:33] Und da kam einmal zu Tage quasi, dass die Oma von Kent Beck angeblich gesagt hat,

[6:39] wenn es um die Kindererziehung geht oder nicht nur die Erziehung,

[6:42] sondern auch quasi die Pflege von Kindern und Kleinkindern.

[6:45] Bei Babys hat sie dann immer davon gesprochen, if it stinks, change it.

[6:49] Damit war natürlich die Windel gemeint.

[6:52] Also wenn die Windel voll ist und man merkt schon, dass es anfängt zu riechen,

[6:55] dann sollte man sich darum kümmern und die Windel wechseln.

[6:57] Das heißt, das, was gerade nicht so ganz okay ist, nämlich die vollgemachte Windel,

[7:02] ersetzen durch eine neue, eine frische Windel.

[7:04] Und damit alles wieder besser ist als vorher, sagen wir auf jeden Fall.

[7:08] Und jetzt hat der Kent Beck diese Idee übernommen und das auf Code übertragen.

[7:12] Das heißt, wenn der Code irgendwie komisch riecht, hat er bewusst natürlich diese Analogie genommen.

[7:17] Man muss natürlich letztlich sagen, der Code sieht komisch aus.

[7:20] Also man guckt auf den Code drauf und man findet da irgendwie, dass das was seltsam ist.

[7:24] Dann hat er das eben Codesmell genannt, weil das natürlich ein griffigerer Begriff ist

[7:31] als irgendwie Stellen im Code, die komisch aussehen oder so.

[7:34] Also Codesmell, das kommt daher.

[7:36] Und dann ist eben genau die Idee, wenn das schon komisch riecht,

[7:40] dann sollte man darüber nachdenken, da mal was zu optimieren, da mal was zu verbessern.

[7:44] Ja, und genau das ist jetzt auch die Idee von Codesmells.

[7:47] Die helfen uns also dabei, genau die Stellen im Code zu finden, wo wir dran müssen.

[7:51] Denn vielleicht ist es auch häufig so, du entwickelst eine Software und denkst dir irgendwie,

[7:54] die ist irgendwie komisch oder ich fühle mich nicht so ganz wohl.

[7:57] Ich weiß aber nicht genau, woran das liegt.

[7:59] Das ist mehr so ein Gefühl oder so ein Bauchgefühl.

[8:02] Oder wenn ich Anpassungen mache, dann fällt mir das immer schwer.

[8:05] Ich baue immer viele Fehler ein, solche Dinge.

[8:07] Und dann ist es sehr schwer greifbar zu sagen, ja, ich muss jetzt hier an dieser Stelle was ändern.

[8:11] Und diese Codesmells helfen uns jetzt genau dabei.

[8:13] Ich kann mir jetzt also den Code angucken und quasi nach diesen Codesmells so ein bisschen scannen, wenn ich mal will.

[8:18] Und dann finde ich sehr schnell Stellen, an denen ich potenziell aktiv werden könnte.

[8:23] Wie gesagt, ich muss es nicht, aber ich könnte es.

[8:25] Und vor allem, wenn ich jetzt so ein Codesmell gefunden habe und weiß, wie der heißt quasi,

[8:30] weil ich den in diesem Buch Refactoring zum Beispiel nachgelesen habe,

[8:33] dann kann ich mit meinen Entwicklerkollegen auch viel besser über den Code diskutieren.

[8:36] Wenn ich zum Beispiel sage, hier, an dieser Stelle haben wir aber Feature Envy,

[8:40] dann müssten alle Kollegen, die wissen, was Feature Envy ist, weil sie das Buch gelesen haben,

[8:44] sofort wissen, was Sache ist.

[8:46] Und ich muss denen nicht noch eine halbe Stunde lang erklären, was eigentlich gerade das Problem mit diesem Code ist.

[8:49] Das heißt, ähnlich wie bei den Designpattern, die ja auch eine Kommunikationsaufgabe haben,

[8:55] ist das bei den Codesmells genauso.

[8:57] Wenn ich weiß, welche Codesmells es gibt und wie die heißen,

[8:59] dann kann ich mit einem Begriff meinen Entwicklerkollegen sagen, was hier gerade das Problem ist

[9:03] und muss es eben nicht umschreiben, was wieder dazu führt, dass man es vielleicht falsch versteht,

[9:07] dass es lange dauert und so weiter.

[9:09] Also, genauso wie wenn ich sage, hier, den Code können wir mit einem Designpattern besser machen,

[9:13] und zwar mit einem Singleton.

[9:15] Dann müsste jeder Entwickler, der einen Singleton kennt, wissen, was zu tun ist.

[9:18] Und genau so ist es auch bei den Codesmells.

[9:21] Und du wirst feststellen, bei der Liste, die wir gleich durchgehen werden,

[9:24] sind bestimmt ein paar Sachen dabei, die du schon mal so gehört hast.

[9:27] Und ich habe jetzt gerade zum Beispiel FeatureN wie gesagt.

[9:30] Hast du vielleicht schon mal irgendwo gehört.

[9:31] Das ist inzwischen so ein wirklich feststehender Begriff, sage ich mal.

[9:34] Aber das ist ursprünglich ein Codesmell gewesen, der halt in dem Buch drin steht.

[9:38] So, und letzte Frage, bevor wir mit der Liste loslegen.

[9:41] Was machen wir denn jetzt gegen Codesmells?

[9:43] Also, wir haben jetzt irgendwie Codesmells gefunden.

[9:45] Ja, jetzt, was können wir tun?

[9:47] Und da ist natürlich die Antwort Refactorings.

[9:49] Das heißt, wenn ich ein Codesmell finde, dann kann ich jetzt in dieses Buch zum Beispiel reinschauen,

[9:52] von Herrn Fauler, und da steht dann ganz hinten sogar so eine coole Tabelle drin,

[9:55] wo genau drin steht, für den Codesmell helfen diese 1, 2, 3, 4, 5 Refactorings,

[10:00] die man da anwenden kann.

[10:01] Und genau darum geht es ja auch in dem Buch.

[10:03] Er zeigt immer den Code, der nicht so gut ist.

[10:05] Der also zum Beispiel auch so einen Codesmell hat.

[10:07] Und dann schaut er, wie wir Schritt für Schritt den Codesmell eliminieren

[10:11] und durch was Besseres ersetzen.

[10:12] Und dieses Vorgehen dabei, dass der Code auch weiterhin lauffähig ist,

[10:16] das ist eben das Refactoring.

[10:17] Und davon gibt es auch eine ganze Reihe.

[10:19] Also es gibt noch viel mehr Refactorings, als es Codesmells gibt.

[10:22] Daraus besteht ja im Prinzip dieses Buch.

[10:24] Und jetzt ist aber ja die interessante Frage, welche Refactorings nutze ich,

[10:28] um welchen Codesmell zu beheben.

[10:30] Und dafür gibt es halt so eine sehr schöne Tabelle.

[10:32] Kann man einfach nachschlagen und sieht dann, aha, Feature Envy.

[10:34] Und dann findet man 1, 2, 3 Refactorings, die man ausführen kann.

[10:37] Dann kann man zu dem Refactoring im Buch mal hinspringen und gucken, was man da tun muss.

[10:40] Und dann kann man hoffentlich diesen Codesmell eliminieren.

[10:44] So, dann ist es jetzt auch endlich Zeit für die Codesmells.

[10:48] Ich würde sagen, ich gehe mal einmal die Liste durch und lese die kurz vor.

[10:51] Ich würde sie auch gerne auf Englisch einmal vorlesen,

[10:53] weil diese Fachbegriffe immer auf Deutsch zu übersetzen, finde ich sehr schwierig.

[10:56] Und wenn du dich irgendwie mit irgendeiner Literatur beschäftigst,

[10:59] wirst du automatisch auf diese englischen Begriffe stoßen.

[11:01] Also ich finde es jetzt nicht so sinnvoll, die alle einzeln zu übersetzen.

[11:03] Die sind nicht bekannt auf Deutsch.

[11:06] Deswegen nehmen wir mal die englischen Begriffe.

[11:08] Und danach gehe ich die mal der Reihe nach durch.

[11:10] Und bei den ersten paar, die ich quasi jetzt handverlesen ausgesucht habe,

[11:14] gehen wir mal ein bisschen ins Detail.

[11:16] Die restlichen ganz am Ende, da erkläre ich kurz, worum es geht.

[11:19] Aber gehe da nicht zu sehr ins Detail, sonst sprengt das hier heute den Rahmen.

[11:22] Also die Auswahl ist von mir subjektiv getroffen.

[11:25] Im Buch werden alle Codesmells analog behandelt,

[11:29] werden vorgestellt, auch im Detail und so weiter und so fort.

[11:31] Hier treffe ich so ein bisschen eine Auswahl,

[11:34] damit wir uns mehr auf die Sachen beschränken können,

[11:37] die in der Praxis zumindest ich, die ich da häufig antreffe.

[11:40] Und damit das hier einfach nicht zu lang wird.

[11:42] Also ich lese erst mal alle Smells vor, die es im Buch gibt,

[11:45] dass du die schon mal gehört hast.

[11:46] Es gibt Duplicate Code, Comments, Long Method, Large Class,

[11:53] Long Parameter List, Feature Envy, Data Clumps, Primitive Obsession,

[12:00] Switch Statements, Divergent Change, Shotgun Surgery,

[12:06] Parallel Inheritance Hierarchies, Lazy Class, Speculative Generality,

[12:13] Temporary Field, Message Chains, Middleman, Inappropriate Intimacy,

[12:20] Alternative Classes with Different Interfaces, Incomplete Library Class,

[12:26] Data Class, Refused Bequest.

[12:30] Das sind alle Smells, die im Buch stehen.

[12:33] Ich bin mir ziemlich sicher, Du hast ein oder zwei davon schon mal gehört.

[12:36] Sowas wie Shotgun Surgery vielleicht, Primitive Obsession,

[12:39] Feature Envy hatte ich schon gesagt.

[12:41] Das sind so Sachen, die könnte man mal hin und wieder irgendwo gehört haben.

[12:44] Und jetzt gucken wir uns mal an, was es damit auf sich hat.

[12:46] Ich gehe die mal genau in dieser Reihenfolge durch.

[12:48] Und ich glaube so ungefähr ziemlich bei der Hälfte oder kurz vorher

[12:51] wechsle ich dann in eine oberflächlichere Betrachtung,

[12:54] weil die Reihenfolge ist nicht so, wie sie im Buch ist.

[12:57] Und ich habe die schon selber ein bisschen umgestellt,

[12:59] damit wir uns erst mal um die interessanten Sachen kümmern können.

[13:02] Also fangen wir mal ganz oben an.

[13:04] Und zwar bei meinem absoluten Lieblings-Codesmell.

[13:06] Das ist tatsächlich auch der erste, der im Buch steht.

[13:08] Und zwar Duplicate Code.

[13:10] Also doppelter Code übersetze ich das immer ganz gern,

[13:13] obwohl ich würde eigentlich mehrfacher Code, ja, finde ich eigentlich besser.

[13:17] Weil es geht nicht immer nur darum, dass man Sachen doppelt hat,

[13:20] sondern es gibt auch dreifach, vierfach, fünfmal das Gleiche irgendwo im Code.

[13:23] Und das ist natürlich genauso schlecht, beziehungsweise sogar noch schlechter.

[13:26] Also worum geht es dabei?

[13:27] Doppelter Code heißt, ich habe Code sehr, sehr ähnlich oder sogar identisch

[13:32] an mehreren Stellen in meinem Programm irgendwo verstreut.

[13:35] Ein Beispiel wäre zum Beispiel ein Switch-Statement.

[13:38] Da kommen wir später ja nochmal drauf.

[13:40] Diese Switch-Statements, wenn ich zum Beispiel ein Enum habe

[13:43] und ich mache ein Switch auf alle Enum-Werte,

[13:45] dann ist es sehr wahrscheinlich, dass ich diesen Switch irgendwo an mehreren Stellen

[13:48] in meinem Code wieder brauchen werde.

[13:50] Weil ganz häufig an diesem Enum eben nicht nur eine Funktionalität hängt,

[13:53] die da entschieden wird, sondern, was weiß ich,

[13:56] nehmen wir die Zahlweise vielleicht bei einem Versicherungsvertrag oder so.

[13:59] Das brauche ich sicherlich einmal bei der Polizierung,

[14:02] weil ich sagen muss, dann und dann wird zum ersten Mal bezahlt.

[14:04] Wird aber auch zum Beispiel jedes Mal beim Monatslauf sicherlich angefragt,

[14:07] um zu gucken, wann zahlt er denn jetzt nochmal.

[14:09] So, das heißt zwei Stellen im Code, die beide mit diesem gleichen Enum zum Beispiel arbeiten

[14:13] und da werde ich ganz wahrscheinlich, sage ich mal, immer ein Switch drauf machen.

[14:17] Und das ist halt sehr, sehr ähnlich oder sogar identisch an mehreren Stellen im Code

[14:21] und das ist nicht gut.

[14:23] Denn, was ist jetzt, wenn sich daran irgendetwas ändert an dieser Logik?

[14:26] An Beispiel des Enums vielleicht, es kommt ein Enum-Wert hinzu,

[14:30] den ich auch noch behandeln muss.

[14:32] Dann muss ich an mehreren Stellen im Code da was einbauen oder ergänzen

[14:35] und wenn ich eine davon vergesse, dann habe ich ein Problem,

[14:38] weil dann habe ich einen Fehler im Code und das ist sehr, sehr schwer, den zu finden.

[14:41] Von daher, doppelter Code, das sage ich immer ganz gerne meinen Azubis,

[14:45] ist so das aller, aller Schlimmste, was dem Entwickler passieren kann.

[14:48] Weil das führt ganz häufig zu Fehlern,

[14:50] einfach weil ich als Mensch Dinge übersehen kann

[14:53] und dann habe ich halt quasi 90% des Codes einheitlich und 10% aber nicht

[14:58] und das ist ein Problem, weil das dann rauszufinden und den Fehler auszufinden

[15:01] und zu fixen vor allem, ist sehr, sehr schwierig.

[15:03] Von daher, das sollten wir immer verhindern.

[15:05] Das Schöne ist, dass sich das ganz, ganz einfach verhindern lässt in den meisten Fällen

[15:09] und dazu können wir zwei Refactorings nehmen.

[15:11] Eins davon, sage ich mal, in 99% der Fälle und zwar Extract Method.

[15:16] Extract Method bedeutet einfach, dass ich einen Teil des Codes in eine einzelne Methode auslager.

[15:22] Das kann ich in IDEs, wie zum Beispiel Eclipse,

[15:24] sogar mit Rechtsklick, Refactor, Extract Method direkt machen,

[15:27] ohne dass ich selber tätig werden muss.

[15:29] Im Buch wird jetzt beschrieben, wie genau man dann davor geht,

[15:31] damit der Code auch weiterhin funktioniert.

[15:33] Aber es geht einfach darum, ganz blöd gesagt,

[15:35] ich habe jetzt hier vier Zeilen Code, die ich an drei Stellen benutze,

[15:38] dann extrahiere ich einmal eine Methode draus und rufe an den drei Stellen diese Methode jeweils auf,

[15:42] habe den Code wiederverwendet, habe ihn aber nur noch an einer Stelle und kann ihn da anpassen

[15:46] und muss nicht an drei Stellen rumdoktern, wenn irgendwas kaputt ist.

[15:49] Und das nächste Refactoring wäre Pullup Method.

[15:52] Wenn ich eine Hierarchie habe, eine Vererbungshierarchie,

[15:55] und in mehreren Subklassen zum Beispiel die gleiche Implementierung habe,

[15:59] dann kann ich diese Methode einfach in die Basisklasse hochziehen.

[16:02] Dadurch wird sie ja an die Subklassen vererbt und dann können alle die aufrufen,

[16:05] anstatt alle nochmal das gleiche zu programmieren.

[16:08] Im Prinzip geht es hier aber einfach darum, Code wiederverwendbar zu machen.

[16:11] Das ist das zentrale Mittel, um doppelten Code zu verhindern

[16:14] und das Standardmittel dafür wäre eben eine Methode zu bauen.

[16:17] Ja, der nächste Codesmell, das sind Kommentare.

[16:21] Comments auf Englisch.

[16:23] Und Kommentare sind jetzt nicht immer schlecht.

[16:25] Kommentare ist ja das, was vom Compiler ignoriert wird,

[16:27] also Slash, Slash zum Beispiel oder Slash, Sternchen, Sternchen, Slash, alles was dazwischen steht.

[16:31] Die Idee ist, dass nur Menschen diese Kommentare lesen,

[16:34] weil der Compiler sie ja nun mal ignoriert.

[16:36] Und das kann jetzt helfen, den Code verständlicher zu machen.

[16:39] Also wenn ich da jetzt neben schreibe, warum ich etwas tue in meinem Code,

[16:42] dann ist das sicherlich gut für den Menschen, der das liest.

[16:44] Wenn ich aber einfach nur dahin schreibe, was der Code gerade genau tut,

[16:47] mein Lieblingsbeispiel ist i++ und daneben steht i wird um 1 erhöht.

[16:52] Das sind völlig überflüssige Kommentare, die nicht zum Verständnis beitragen.

[16:55] Im Gegenteil, ich muss diesen Kram auch noch lesen,

[16:57] obwohl i++ eigentlich für sich selber stehen sollte.

[17:00] Als vernünftiger Entwickler müsste ich wissen, was das tut.

[17:02] Und das viel größere Problem ist, je länger ich warte und mein Code sich weiterentwickelt,

[17:07] umso wahrscheinlicher ist es auch, dass die Kommentare irgendwann anfangen zu lügen.

[17:11] Das heißt, angenommen i++, daneben steht der Kommentar i wird um 1 erhöht,

[17:15] und irgendwer ändert jetzt den Code und macht aus i++ i minus minus, warum auch immer,

[17:20] und passt aber den Kommentar nicht an,

[17:22] weil der Kommentar hat ja keinerlei Auswirkungen auf die Ausführung des Programms.

[17:26] Es wird nichts verändert am Verhalten des Programms, wenn ich den Kommentar anpasse.

[17:30] Also kann man das leicht übersehen, den mit anzupassen.

[17:32] Dann steht da auf einmal i minus minus und daneben i wird um 1 erhöht.

[17:36] Das passt natürlich dann nicht mehr.

[17:38] Und da muss der Mensch immer überlegen, äh, was ist denn jetzt richtig?

[17:41] Das ist offensichtlich, weil das ist der Code, der Kommentar wird ja ignoriert.

[17:44] Aber irgendwie vertrauen wir den Aussagen von Menschen,

[17:47] die ja in Form von Kommentaren da hingeschrieben werden, schon immer noch ein bisschen.

[17:51] Und deswegen denke ich drüber nach und stelle fest, das ist irgendwie ein Fehler hier,

[17:55] das passt nicht zusammen und das kostet mich Zeit und erschwert das Verständnis.

[17:59] Von daher am besten auf solche Kommentare verzichten und stattdessen vernünftige Bezeichner benutzen.

[18:04] Das ist eigentlich so das Standardmittel gegen Kommentare,

[18:07] also vernünftige Variablennamen, Klassen- und Methodennamen wählen

[18:10] und nicht irgendwie i als Variablenname, sondern vielleicht Alter der Person in Jahren.

[18:15] Ist jetzt ein Extrembeispiel, ja, aber sicherlich besser verständlich als i.

[18:19] Auch hier ist das Refactoring Extract Method sehr häufig gern gesehen.

[18:25] Das heißt, wenn ich ein Stückchen Code habe, den ich erklären muss,

[18:28] dann kann ich diesen Code einfach in eine Methode extrahieren und dieser Methode einen schönen Namen geben,

[18:33] der genau beschreibt, was der Code macht, und schon kann ich mir den ganzen Kommentar sparen.

[18:38] Und das Schöne ist, Methodennamen als Bezeichner, die kann ich refaktorisieren,

[18:42] also zum Beispiel umbenennen später, ja, und das macht die IDI automatisch überall.

[18:46] Der Kommentar, wo das nicht geht, weil er ja kein Teil des Codes ist,

[18:49] der kann irgendwann lügen, der Methodenname im besten Fall nicht mehr.

[18:52] Von daher habe ich mir da sogar noch die Verständlichkeit erhöht dadurch.

[18:56] Und was man auch machen kann, ist sowas wie Rename Method.

[19:00] Das heißt, wenn eine Methode nicht so ganz genau das beschreibt, was sie tut,

[19:03] ja, dann benenne ich sie um, dann spare ich mir nämlich den Kommentar über der Methode,

[19:06] der erklärt, was sie eigentlich tut.

[19:08] Also, das ist irgendwie unsinnig.

[19:10] Wir versuchen einfach, den Code so schön zu benennen, dass er für sich selber stehen kann,

[19:14] dass er selbsterklärend ist, und dann kann ich mir auch die begleitenden Kommentare sparen.

[19:19] Das heißt nicht, dass ich gar keine Kommentare mehr schreiben soll.

[19:22] Es gibt immer noch begründete Stellen, wo Kommentare sinnvoll sind.

[19:26] Denken wir mal hier im Kontext von Codesmells an genau eine Stelle, wo vielleicht ein Codesmell drinsteht.

[19:31] Wenn ich mich jetzt als Entwickler aber dafür entscheide, den drin zu lassen,

[19:34] weil die Alternative noch schlechter ist, dann könnte ich das vielleicht in den Kommentar schreiben.

[19:38] So nach dem Motto, ich nehme hier den doppelten Code bewusst in Kauf, weil sonst …

[19:45] Das erklärt dem Menschen, warum etwas passiert ist und nicht, was da gerade passiert ist.

[19:49] Das sieht man im Code viel besser.

[19:51] Also, Kommentare, Codesmell, auflösen mit Methoden.

[19:56] Wenn wir jetzt schon mit Methoden arbeiten, gucken wir uns gleich den nächsten Codesmell an, der sich darauf bezieht, und zwar Long Method.

[20:01] Also, ich habe eine ganz lange Methode. Und ganz lang ist jetzt schwer zu definieren. Was heißt das jetzt?

[20:06] Mein Gefühl oder meine Daumenregel, die ich über die Jahre so entwickelt habe, ist, alles, was länger ist als fünf Zeilen, ist tendenziell zu lang.

[20:16] Es gibt Ausnahmen davon, ja, ich weiß, aber eine gute Daumenregel, glaube ich, ist das schon.

[20:21] Die Methoden sollten eher klein und schnucklig sein und nicht lang und schwer zu verstehen.

[20:26] Das ist nämlich genau das Problem. Wenn ich eine ganz lange Methode habe, macht die tendenziell ganz, ganz, ganz viele Dinge hintereinander.

[20:31] Und dadurch wird sie viel, viel schwieriger zu verstehen, auch viel schwieriger zu testen und auch viel schwieriger anzupassen.

[20:38] Wir überlegen einfach mal, wenn wir eine Methode haben mit 100 Zeilen, da passieren 37 Dinge, Datenbank aufmachen, Datei schreiben, Businesslogik, wie auch immer.

[20:46] Da muss ich ja ganz viele Änderungen vielleicht in dieser Methode irgendwo einbauen.

[20:50] Wenn sich irgendwo etwas ändert, wie zum Beispiel die Datenbank, wird ausgetauscht, da muss ich an diese Methode ran und habe dabei natürlich auch die Möglichkeit, da Fehler einzubauen,

[20:58] was natürlich irgendwie ungünstig ist für den Rest, der noch in der Methode steht.

[21:02] Das heißt, wenn vielleicht meine Businesslogik auf einmal beeinträchtigt ist, nur weil ich eine Datenbanklogik angepasst habe, das ist nicht gut.

[21:09] Das heißt, wir wollen es hinkriegen, dass unsere Methoden kurz und knackig sind, am besten eine einzige Aufgabe haben.

[21:15] Stichwort Single Responsibility Principle.

[21:18] Und dann können wir die auch viel, viel einfacher testen und nachher anpassen und vor allem verstehen.

[21:22] Das ist viel wichtiger.

[21:24] Also als Entwickler lesen wir viel, viel häufiger Code, als wir ihn selber schreiben.

[21:27] Und daher ist es wichtig, dass wir den Code so schreiben, dass er, wenn er gelesen werden muss, was sehr, sehr häufig ist, schnell und gut verständlich ist.

[21:36] Auch hier wäre das Refactoring der Wahl wieder Extract Method.

[21:40] Das werden wir, glaube ich, heute noch häufiger hören.

[21:42] Extract Method ist eines der einfachsten Refactorings.

[21:45] Einfach aus ein bisschen Code eine Methode machen.

[21:47] Löst aber ganz, ganz, ganz, ganz viele Probleme.

[21:49] Ist jetzt hier schon der dritte Codesmell, bei dem das hilft.

[21:51] Warum?

[21:52] Weil ich kann einfach die Teile aus der Methode in einzelne Methoden ausgliedern, die zusammengehören.

[21:56] Mal ein Beispiel von eben.

[21:58] Datenbanklogik, Geschäftslogik und Dateischreiben oder so.

[22:01] Da mache ich einfach drei Methoden draus.

[22:03] Und in der gemeinsamen Methode, wo die Sachen vorher drin standen, haben wir jetzt nur noch drei Methodenaufrufe hintereinander.

[22:08] Nämlich, was auch immer, lies Datenbank, mach Geschäftslogik, schreib Datei.

[22:12] Und so hat diese eine Methode, die vorher 100 Zeilen lang war, auf einmal nur noch drei.

[22:16] Ist dafür aber sehr, sehr viel einfacher zu verstehen.

[22:18] Hat ein höheres Abstraktionsniveau.

[22:20] Ich muss nicht mehr in die Details der Datenbankabfrage gehen, sondern steht einfach lies Datenbank aus.

[22:24] Fertig.

[22:25] Und wenn ich die Details sehen will, gehe ich in die andere Methode.

[22:27] Das heißt, ich habe meinen Code jetzt viel besser modularisiert.

[22:30] Die Methoden haben alle nur noch eine Aufgabe.

[22:33] Sind kurz und knackig und gut zu verstehen.

[22:35] Also wunderbar.

[22:36] Das sollten wir auf jeden Fall machen.

[22:38] Nächster Smell wäre die Large Class.

[22:41] Also eine sehr, sehr große Klasse.

[22:43] Analog zur langen Methode mit mehreren Zeilen ist eine große Klasse.

[22:46] Auch eine Klasse, die viele Zeilen hat.

[22:48] Und hier reden wir jetzt vielleicht von, schwer zu sagen, ich sag mal alles über 100 Zeilen vielleicht.

[22:53] Könnte man schon drüber nachdenken, ob die vielleicht ein bisschen zu groß ist.

[22:56] Was ist das Problem dabei?

[22:58] Genau wie bei den Methoden, die Klassen, die lang sind, haben wahrscheinlich viel zu viele Aufgaben.

[23:02] Die machen nicht nur eine Sache, sondern machen mehrere Sachen.

[23:05] Und das führt wieder dazu, dass ich vielleicht diese eine Klasse anpassen muss,

[23:08] wenn sich fünf Sachen ändern, die eigentlich gar nichts miteinander zu tun haben.

[23:12] Die muss ich alle in dieser Klasse ändern.

[23:14] Und außerdem hat die Klasse dann sehr wahrscheinlich viele Abhängigkeiten auf unterschiedliche Dinge.

[23:17] Das macht sie wieder sehr schwer testbar.

[23:19] Ein Beispiel von eben.

[23:21] Habe ich in einer Klasse die Datenbank-Logik und das Dateisystem,

[23:24] dann habe ich zum einen die Abhängigkeit auf beides.

[23:27] Aber um die Datenbank zu testen, brauche ich jetzt auf einmal auch ein Dateisystem.

[23:30] Und umgekehrt. Weil die Klasse braucht ja beides.

[23:33] Und das ist irgendwie unsinnig.

[23:35] Warum muss ich ein Dateisystem bereitstellen, wenn ich eigentlich nur die Datenbank-Logik testen will?

[23:38] Das ist nicht gut. Das macht den Code wieder schwer verständlich und eben schwer zu testen.

[23:41] Und das wollen wir nicht.

[23:43] Und hier haben wir jetzt noch ein paar neue Refactorings, die wir anwenden können.

[23:46] Und zwar Extract Class und Extract Subclass.

[23:51] Was machen wir jetzt also hier?

[23:53] Hier ziehen wir nicht einfach nur eine Methode raus.

[23:55] Das würde ja nicht helfen in der großen Klasse.

[23:57] Ja gut, dann habe ich halt 57 Methoden.

[23:59] Die machen aber auch alle wieder unterschiedliche Dinge.

[24:01] Das passt dann auf Ebene der Klasse auch wieder nicht.

[24:03] Das heißt, ich sollte hierher gehen und eine komplett neue Klasse extrahieren.

[24:06] Und das kann man erstaunlich oft.

[24:08] Das Beispiel von eben wäre, ich hätte jetzt anstatt der einen Klasse die Datenbank und Dateisystem macht, einfach zwei.

[24:13] Einmal die Datenbank-Klasse, einmal die Dateisystem-Klasse.

[24:15] Die wird natürlich insgesamt dann viel, viel kleiner.

[24:17] Und ich kann sie isoliert testen und auch besser verstehen, weil sie kürzer ist.

[24:21] Alternativ wäre, ich führe eine Vererbungs-Hierarchie ein und ziehe Subklassen raus.

[24:26] Also wenn die Klasse viele ähnliche Dinge tut und das passt in eine Vererbungs-Hierarchie, dann kann ich auch das machen.

[24:33] Also ich muss die Klassen nicht, sag ich mal, in die Breite auseinanderziehen, sodass sie nichts miteinander zu tun haben.

[24:38] Sondern wenn es sich anbietet und wenn es passt, wenn ich Code wiederverwenden kann, kann ich auch eine Vererbungs-Hierarchie einführen.

[24:44] Und das ist quasi das Extract-Subclass.

[24:48] Nächster Smell wäre die Long-Parameter-List.

[24:52] Also eine lange Parameter-Liste.

[24:54] Was bedeutet das? Ich habe eine Methode, die hat einfach viele Parameter.

[24:58] Und mit viele meine ich jetzt auch meine persönliche Daumenregel wieder irgendwie mehr als drei.

[25:03] Mehr als drei Parameter in einer Methode sind schon sehr, sehr viel.

[25:07] Warum? Was ist das Problem dabei?

[25:09] Viele Parameter deuten wieder darauf hin, dass die Methode viele Dinge tut, die sie eigentlich nicht tun sollte.

[25:14] Stichwort kleine Methoden.

[25:16] Sie machen sie aber auch sehr schwer testbar und schwer verständlich.

[25:19] Mein Lieblingsbeispiel ist, ich habe eine Methode mit vier String-Parametern.

[25:23] Wenn ich da von draußen drauf gucke, kann ich die Strings eigentlich nicht unterscheiden, weil es der Datentyp String.

[25:28] Die Namen sind ja letztlich Schall und Rauch.

[25:30] Das heißt, die IDE sagt mir, hey, diese Methode braucht vier Strings.

[25:33] Jetzt die Frage, was ist an welcher Position?

[25:36] Kann ich da Dinge durcheinander bringen?

[25:38] Das ist alles sehr schwer verständlich von draußen.

[25:41] Alternative ist, ich habe eine Methode mit zehn verschiedenen Parametern.

[25:44] Da muss ich jedes Mal, wenn ich die aufrufen will, diese zehn Parameter auch alle füllen.

[25:47] Das heißt, ich muss alles vorrätig haben.

[25:49] Ich kann die Methode also nicht so gut wiederverwenden, wenn ich vielleicht nur Teile der Parameter zur Verfügung habe.

[25:53] Nein, ich muss immer alle zehn Parameter reingeben.

[25:56] Irgendwas wird die Methode ja auch mit diesen zehn Dingern tun.

[25:59] Wenn wir jetzt einfach mal überlegen, aus der Kombinatorik, wie viele Möglichkeiten durch meinen Code,

[26:04] also Wege durch meinen Code sich ergeben aus zehn verschiedenen Parametern.

[26:07] Da kann ich überlegen, da wird es ja Millionen von verschiedenen Wegen geben.

[26:10] Einfach nur, wenn der eine Wert null ist.

[26:12] Der andere ist null.

[26:14] Und dann kommt eine zwei.

[26:15] Und dann kommt eine minus fünf.

[26:16] Und dann kommt ein leerer String.

[26:17] Und dann kommt dies und das und jenes.

[26:18] Diese ganzen möglichen Kombinationen, die da auftreten, machen die Methode sehr, sehr, sehr, sehr, sehr schwer testbar.

[26:25] Also auf jeden Fall verhindern, viele Parameter in Methoden reinzugeben.

[26:29] Mein Liebling ist außerdem auch noch eine boolsche Variable als Parameter.

[26:33] Das ist immer ganz heiß, denn das heißt eigentlich schon automatisch, dass die Methode zwei Sachen macht.

[26:38] bool ist immer true oder false.

[26:40] Das heißt, irgendwas wird die Methode wohl anders machen.

[26:43] Je nachdem, ob es auf true oder false steht.

[26:45] Das heißt, per Definition macht die schon mal zwei Sachen.

[26:47] Und das sollte sie eigentlich nicht.

[26:48] Also das sollten wir verhindern, wenn das irgendwie geht.

[26:53] Außerdem haben wir ein Problem, wenn wir ganz, ganz viele Parameter irgendwo da rein geben,

[26:56] dann ist die Chance sehr, sehr hoch, dass da auch noch einer irgendwann mal dazukommen muss.

[27:00] Oder einer war zu viel und fällt wieder raus.

[27:02] Das heißt, diese Liste wird wahrscheinlich häufig angepasst.

[27:04] Und das ist immer ein echtes Problem.

[27:07] Ich kann natürlich inzwischen Mittel der IDI benutzen, die das dann für mich machen.

[27:11] Aber überlegen wir uns einfach mal, wenn sich so eine Parameterliste ändert,

[27:14] dann muss ich ja tendenziell alle Aufrufer dieser Methode, die es schon gibt, anpassen.

[27:18] Weil die jetzt andere Parameter reingeben müssen.

[27:20] Das heißt, es ist sehr, sehr aufwendig, das anzupassen.

[27:23] Und zusätzlich noch schwer verständlich und testbar.

[27:26] Also bitte nicht machen.

[27:28] Und meine persönliche Daumenregel, ich sage es nochmal, drei Parameter, das ist okay.

[27:32] Mehr als drei muss man wirklich schon gut überlegen, ob das noch sinnvoll ist oder ob man es aufteilen sollte.

[27:37] Und hier gibt es jetzt verschiedene Refactorings.

[27:39] Ich habe mal zwei rausgenommen.

[27:40] Nummer eins, replace parameter with method und introduce parameter object.

[27:46] Das erste ist, wenn die Methode einen Parameter von draußen benötigt, kann man schauen, ob sie sich den nicht auch selber holen kann.

[27:54] Also anstatt, dass ich ihn reingebe, zum Beispiel als Parameter, String, was auch immer, Name,

[27:59] könnte die Methode, wenn sie die Möglichkeit hat, sich selbst zum Beispiel über einen Getter bei einer anderen Klasse diesen Namen holen, sich selbst den besorgen.

[28:07] Das heißt, ich muss als Aufrufer nicht so viele Sachen bereitstellen, sondern die Methode holt sich etwas.

[28:13] Jetzt kann man hier vortreffig darüber streiten, ob das jetzt besser ist oder nicht.

[28:17] Das wird ja noch schwerer testbar, weil dann muss ich auch die ganzen Abhängigkeiten, die für dieses Holen benutzt werden, ja irgendwie im Test zum Beispiel bereitstellen.

[28:23] Also das hat alles jetzt Vor- und Nachteile.

[28:25] Aber wenn wir erkannt haben, dass viele Parameter ein Problem sind, dann können wir darüber nachdenken,

[28:30] ob wir wirklich alle reingeben müssen oder ob sich die Methode nicht selber welche holen kann.

[28:35] Aber Achtung, auch das kann wieder andere Probleme nach sich ziehen.

[28:38] Also das ist jetzt nicht die Patentlösung dafür.

[28:40] Alternative, wenn ich viele Parameter habe, dann kann ich ein eigenes Objekt, also eine eigene Klasse programmieren, die diese Parameter quasi in sich kapselt.

[28:50] Geht auch so ein bisschen einher mit einem anderen Refactoring, was wir uns gleich angucken, nämlich Data Clumps.

[28:55] Mein Lieblingsbeispiel, ich habe irgendwie Startdatum und Endedatum und da muss ich irgendwas dazwischen berechnen.

[29:00] Ja, was weiß ich, ob es jetzt ein Stundenplan ist oder ein Versicherungsvertrag oder irgendwas.

[29:03] Es gibt Start und Ende.

[29:04] Dann gibt es bei sehr, sehr, sehr, sehr vielen Methoden wahrscheinlich immer diese Start- und Endedaten in Kombination.

[29:11] Das heißt, eine Methode wird immer beide Parameter haben.

[29:14] Und damit ich das nicht hoffnungslos doppelt und dreifach überall mache, kann ich einfach eine Klasse bauen, die dann zum Beispiel Zeitraum heißt

[29:21] und die diese beiden Start- und Endedaten als Instanzvariablen hat.

[29:25] Und genau das gleiche mache ich hier bei dieser Long Parameter List.

[29:28] Dann baue ich mir einfach eine Klasse, wo alle diese Parameter als Instanzvariablen drin sind, baue mir Getter-Setter dafür zum Beispiel

[29:34] und dann kann ich dieses eine Objekt durchreichen und muss nicht sieben verschiedene Parameter durch die Gegend reichen.

[29:40] Stellen wir uns ein Beispiel vor, ich habe irgendwie eine Methode, die Namen einer Person formatieren soll.

[29:45] Da geht aktuell Vorname, Nachname rein und dann stelle ich irgendwann fest, es gibt ja auch noch Leute, die haben so ein Middle Name.

[29:51] Also was weiß ich, so ein Mittelinitial oder sonst irgendwas.

[29:54] Das brauche ich ja auch noch.

[29:55] Da muss ich die Methode anpassen und alle Aufrufe anpassen und so weiter und so fort.

[29:58] Ich könnte aber auch einfach sagen, Mensch, ich mache aus Vorname, Nachname und Mittelname ein eigenes Objekt, meinetwegen einfach nur Name.

[30:07] Und dann gebe ich ab jetzt diese Objekte durch die Gegend, wo alle diese drei Teil-Informationen drin sind.

[30:13] Das heißt, die Methode kriegt einen einzigen Parameter.

[30:16] Das macht sie natürlich viel, viel einfacher testbar.

[30:18] Und die Aufrufe müssen nicht angepasst werden, wenn jetzt irgendwo noch ein neues Attribut dazu kommt.

[30:23] Weil es wird nur das Objekt durch die Gegend gereicht.

[30:25] Ob jetzt eines der sieben Attribute da drin nicht gesetzt ist oder nicht, interessiert mich jetzt erstmal nicht.

[30:30] Ich muss es auf jeden Fall nicht explizit an die Methode übergeben.

[30:33] Das wäre also auch eine Möglichkeit, lange Parameterlisten abzulösen.

[30:38] Einfach eine Klasse einführen, die die alle in sich kapselt.

[30:42] Hierzu vielleicht gleich nochmal ganz kurz die allgemeine Aussage zu Codesmails.

[30:46] Ich hatte es schon eingangs erwähnt.

[30:47] Die sind nicht immer schlecht, diese Codesmails.

[30:50] Und das hier ist jetzt ein sehr schönes Beispiel, woran man das mal kurz durchgehen kann.

[30:53] Wenn ich jetzt so ein Parameterobjekt erstelle, einführe, mein Beispiel von eben, Name.

[30:59] Dann habe ich jetzt eine Klasse geschaffen, die eigentlich ziemlich dämlich ist.

[31:02] Das ist eigentlich nur eine Hülle für diese drei Vorname, Nachname, Mittelname-Werte.

[31:08] Das heißt, ich habe gerade eine dumme Klasse erzeugt.

[31:11] Und diese dumme Klasse ist aber auch wieder ein Codesmail.

[31:14] Das Ding heißt dann DataClass.

[31:16] Da werden wir auch gleich noch drauf eingehen.

[31:18] Und das ist eigentlich eine Klasse, die die Kapselung komplett aufbricht.

[31:22] Stellen wir uns wirklich eine ganz dumme Klasse vor, die nur Getter und Setter für alle Attribute hat,

[31:26] um genau diesen Namen durch die Gegend zu reichen.

[31:28] Das wäre in sich schon wieder ein Codesmail, weil dieser Name einfach dumm ist und die Kapselung aufbricht,

[31:35] weil er für alle seine Attribute Setter anbietet, zum Beispiel.

[31:38] Also wenn man das ganz naiv so lösen würde, alle Parameter raus, eine Klasse anlegen,

[31:42] wo quasi Public-Felder drin sind für alle diese Dinger,

[31:45] dann handle ich mir einen anderen Codesmail damit ein.

[31:48] Ich muss mir also gut überlegen, welchen von beiden will ich denn jetzt nehmen?

[31:51] Beziehungsweise vielleicht finde ich noch eine dritte Lösung, wo ich beides mit abdecken kann.

[31:56] Also die Codesmails sind nicht per Definition immer schlecht,

[31:59] sondern man muss wirklich von Fall zu Fall gucken, was mache ich hier am besten,

[32:03] um mein Problem mit dem Code zu lösen.

[32:05] Der nächste Codesmail heißt FeatureEnvy.

[32:08] Das hast du vielleicht auch schon mal gehört.

[32:10] Envy ist ja so Neid auf Englisch.

[32:12] Und wenn eine Klasse neidisch ist auf eine andere Klasse,

[32:15] dann heißt das, dass die sich ganz viel von dieser Klasse holen will.

[32:18] Die andere Klasse weiß irgendwie ganz viele Sachen,

[32:21] hat zum Beispiel ganz viele Getter für irgendwelche Informationen.

[32:23] Und die Klasse, in der wir eigentlich uns gerade befinden,

[32:25] die muss sich ganz viele Informationen von der anderen Klasse beschaffen,

[32:28] um dann damit irgendetwas zu tun.

[32:30] Stellen wir uns mal was vor, wieder aus dem Bereich Versicherung.

[32:32] Da habe ich so eine Klasse Versicherungsvertrag beispielsweise

[32:35] und ich habe irgendwie eine andere Klasse Beitragsberechner.

[32:39] Und wenn dieser Beitragsberechner, um sich den Beitrag zu berechnen,

[32:42] von dem Versicherungsvertrag erstmal 27 verschiedene Werte holen muss,

[32:45] damit dann irgendwas rumrechnet

[32:47] und am Ende dann dem Vertrag auch noch sagt,

[32:49] du hast jetzt folgende Prämie,

[32:51] dann läuft da irgendwie was falsch.

[32:53] Weil der Versicherungs-, oder wie habe ich ihn jetzt benannt,

[32:55] der Berechner, der braucht so viele Informationen von der anderen Klasse,

[32:58] dass er eigentlich gar nicht selbstständig irgendwie sinnvoll arbeiten kann.

[33:01] Von daher wäre das ein Hinweis darauf,

[33:03] dass vielleicht diese Berechnermethode eigentlich in die andere Klasse gehört,

[33:06] nämlich in den Vertrag selbst.

[33:08] Ich kann diese Methode nämlich auf alle Instanzvariablen direkt zugreifen

[33:11] und muss sich nicht erstmal über eine andere Klasse tausend Informationen besorgen.

[33:15] Das ist damit gemeint FeatureEnv.

[33:17] Und das ist eben ein Zeichen dafür,

[33:19] dass eine Komponente besser woanders untergebracht wäre.

[33:23] Also Komponente wäre sowas wie eine Methode zum Beispiel,

[33:25] aber auch eine Klasse.

[33:26] Eine Klasse, die in einem anderen Package liegt zum Beispiel,

[33:28] die gehört vielleicht an eine andere Stelle,

[33:30] weil sie da besser auf die Informationen zugreifen kann

[33:32] oder sie eher einfach schon vorliegen.

[33:34] Und das Refactoring, was man jetzt anwenden könnte,

[33:37] das wäre MoveMethod.

[33:39] Das heißt, man nimmt einfach die Methode aus der einen Klasse

[33:41] und packt sie in die andere Klasse.

[33:43] Und schwupp, ist das Problem schon gelöst.

[33:45] Aber dann haben wir genau das gelöst,

[33:47] dass die Methode sich erstmal von dem anderen Objekt Dinge holen muss,

[33:49] sondern sie kann dann zum Beispiel einfach

[33:51] über die internen Instanzvariablen der Klasse,

[33:53] in die sie jetzt gerade verschoben wurde,

[33:55] direkt damit arbeiten und muss sich halt nicht

[33:57] etwas Fremdes reinholen, um ihren Job zu machen.

[34:01] Ja, nächstes Teacodes-Mail ist DataClumps.

[34:05] Das ist das, worüber wir gerade schon geredet haben.

[34:07] Startdatum und Endedatum zum Beispiel werden immer gesammelt,

[34:10] durch die Gegend gereicht und nie einzeln.

[34:12] Da könnten wir dann mit den Refactorings

[34:15] IntroduceParameterObject,

[34:17] was wir gerade schon kennengelernt haben,

[34:19] und ExtractClass haben wir auch schon kennengelernt.

[34:21] Ich baue eine eigene Klasse einfach aus diesen beiden Eigenschaften.

[34:25] Das könnten wir damit beheben.

[34:27] Und das ist in vielen Fällen auch sinnvoll.

[34:29] Mein Beispiel Startdatum, Endedatum,

[34:31] das würde ich sofort extrahieren

[34:33] und einen ganzen Zeitraum daraus machen,

[34:35] weil die einfach sinnvoll zusammengehören

[34:37] und ich aber da zum Beispiel auch Businessregeln hinterlegen kann.

[34:40] Ein Zeitraum, wo das Enddatum vor dem Startdatum liegt zum Beispiel,

[34:43] den darf es eigentlich nicht geben.

[34:45] Das kann ich aber bei zwei Parametern,

[34:47] Startdatum, Enddatum, nicht prüfen,

[34:49] beziehungsweise muss es redundant immer wieder prüfen,

[34:51] weil es ja nicht eine einzige Stelle gibt,

[34:53] wo das geprüft werden kann,

[34:55] sondern es sind einfach zwei einzelne Attribute,

[34:57] die durch die Gegend gereicht werden.

[34:59] Packe ich die in eine Klasse,

[35:01] zum Beispiel im Konstruktor,

[35:03] das geprüft wird,

[35:05] Enddatum muss immer größer gleich Startdatum sein.

[35:07] Also ich kann daraus eine echte Geschäftsklasse machen,

[35:09] die auch sinnvoll ist

[35:11] und die auch Logik enthält und die auch Prüfungen enthält.

[35:13] Ich kann es aber auch falsch machen

[35:15] und einfach Startdatum, Enddatum in eine neue Klasse packen

[35:17] und Getter und Setter dafür bauen und bin fertig.

[35:19] Aber dann habe ich mir den nächsten Kurs mal eingehandelt,

[35:21] über den wir gerade schon geredet haben

[35:23] und zwar eine absolut dumme Klasse.

[35:25] Und das ist nicht das, was dabei rauskommen sollte.

[35:27] Wird aber häufig gemacht,

[35:29] zum Beispiel ans Frontend,

[35:31] wenn wir so klassisches MVC vielleicht haben

[35:33] und ich habe im Webfrontend ganz viele Werte,

[35:35] die da dargestellt werden,

[35:37] dann gibt es ganz häufig solche DTOs,

[35:39] Data Transfer Objects.

[35:41] Das sind wirklich absolut dumme Klassen,

[35:43] die nur Getter und Setter haben,

[35:45] die nur dafür da sind, Daten von A nach B zu schubsen.

[35:47] Die auch gar keine Businessregeln enthalten sollen oder dürfen.

[35:49] Die sind gar nicht dafür gedacht.

[35:51] In diesem Fall muss ich natürlich wissen,

[35:53] dass das jetzt keine Data Class im klassischen Sinne ist,

[35:55] die ich eliminieren muss,

[35:57] und da müsste ich dann vielleicht als Entwickler

[35:59] auch mal einen Kommentar reinschreiben

[36:01] oder das über den Namen eindeutig machen.

[36:03] Also wenn ich so etwas habe wie Name DTO,

[36:05] kann man jetzt auch darüber streiten,

[36:07] ob der Name so toll ist mit DTO im Namen,

[36:09] aber davon ist mal abgesehen.

[36:11] Angenommen, das Ding heißt wirklich so,

[36:13] dann sollte jedem Entwickler klar sein,

[36:15] okay, hier geht es nicht um eine Businessklasse,

[36:17] das ist wirklich eine dumme Datentransferklasse,

[36:19] also lasse ich die so, wie sie ist

[36:21] und refaktorisiere sie nicht und mache sie,

[36:23] keine Ahnung, businessfähig oder so.

[36:25] Das ist hier nicht sinnvoll, das wollen wir nicht.

[36:27] So, letzter Smell,

[36:29] den wir ein bisschen detaillierter durchsprechen,

[36:31] ist Primitive Obsession.

[36:33] Das finde ich deswegen so schön,

[36:35] weil wir da gerade beim Global Day of Code Retreat

[36:37] dieses Jahr eine schöne Aufgabe zu hatten,

[36:39] und zwar haben wir eine Iteration

[36:41] genau mit der Vorgabe gemacht,

[36:43] keine primitiven Datentypen zu verwenden.

[36:45] Und jetzt gehen wir mal drauf ein, was das bedeutet.

[36:47] Häufig haben Entwickler so ein bisschen

[36:49] eine kleine Scheu davor,

[36:51] eigene kleine Klassen zu bauen.

[36:53] Also anstatt eine Klasse Name zu bauen,

[36:55] werden einfach Strings durch die Gegend gereicht,

[36:57] weil Namen sind doch Strings.

[36:59] Aber ganz häufig

[37:01] stellen wir halt irgendwann später dann mal fest,

[37:03] oh, der Name hat aber irgendwie auch noch

[37:05] Geschäftsregeln. Also gehen wir jetzt mal

[37:07] vom Namen weg mit drei Unterteilen,

[37:09] Vorname, Nachname, Mittelname, sondern einfach

[37:11] nehmen wir mal nur den Vornamen zum Beispiel.

[37:13] Der Vorname, den könnte ich einfach als String

[37:15] überall durch mein Programm durchreichen,

[37:17] was per se vielleicht auch in Ordnung ist,

[37:19] aber irgendwann stelle ich dann vielleicht fest,

[37:21] dass es Geschäftsregeln gibt, die an diesem Namen hängen.

[37:23] Zum Beispiel ist ein Vorname, der leer ist,

[37:25] eigentlich ungültig. Und ein Vorname, der null ist,

[37:27] auch. Wenn ich aber überall Strings durch die Gegend

[37:29] reiche, dann wird das nicht geprüft,

[37:31] beziehungsweise ich muss es überall dort prüfen,

[37:33] wo der Name verwendet wird, was wieder zu doppeltem Code führt.

[37:35] Habe ich stattdessen eine eigene Klasse

[37:37] Name, die nichts anderes ist als

[37:39] ein Wrapper um einen String,

[37:41] dann kann ich dieser Klasse aber Geschäftsregeln verpassen

[37:43] und zum Beispiel im Konstruktor sagen,

[37:45] Mensch, wenn der Name, den du mir gerade gibst, leer ist

[37:47] oder ungültige Zeichen zum Beispiel enthält

[37:49] oder sonst irgendwas oder nur eine Zahl

[37:51] oder ich weiß nicht, was da vielleicht ungültig sein könnte,

[37:53] dann wird das einfach nicht erlaubt. Das kann ich

[37:55] bei einem String nicht machen, jedenfalls nicht direkt

[37:57] in der Klasse String. Dann muss ich mir wieder Hilfsmethoden

[37:59] anlegen, die das prüfen. Das muss ich überall machen.

[38:01] Wenn ich das einfach rausziehe in meine eigene

[38:03] Klasse, dann wird direkt bei der

[38:05] Instanziierung der Klasse geprüft, ob der Name

[38:07] gültig ist. Und wenn ich ein Objekt dieser

[38:09] Klasse habe, kann ich immer sicher sein, dass es

[38:11] auch ein gültiger Name ist. Und das

[38:13] erspart mir ganz, ganz viele redundante

[38:15] Prüfungen. Und

[38:17] wenn ich von Anfang an mit solchen kleinen

[38:19] Klassen arbeite, habe ich es auch

[38:21] deutlich leichter, später solche Sachen einzuführen.

[38:23] Fange ich erstmal immer mit

[38:25] Int und String und Double an,

[38:27] dann wird das später ganz, ganz

[38:29] schwierig, das auszutauschen. Denn dann

[38:31] ändert sich ja wirklich ein Datentyp und das können

[38:33] einige IDEs auch

[38:35] automatisiert machen, ja. Aber ganz häufig

[38:37] ist es wirklich manuelle Arbeit

[38:39] und das möchte ich

[38:41] vermeiden. Von daher

[38:43] weg von diesen primitiven Datentypen

[38:45] hin zu vernünftigen

[38:47] Geschäftsklassen,

[38:49] Geschäftsobjekten, die auch Logik

[38:51] enthalten, damit ich eben so einen doppelten

[38:53] Code vermeiden kann.

[38:55] Das Refactoring oder die, die ich hier anwenden

[38:57] kann, sind zum Beispiel

[38:59] replaceDataValueWithObject.

[39:01] Das ist genau das, was ich gerade beschrieben habe.

[39:03] Statt einem String irgendwo reinzugeben, nehme ich halt

[39:05] eine Klasse Name oder Vorname.

[39:07] Oder statt Integer

[39:09] nehme ich eine Klasse Alter.

[39:11] Auch ein schönes Beispiel. Alter darf zum Beispiel nie

[39:13] negativ sein. Ein Integer erlaubt

[39:15] aber negative Werte. Also, wenn ich das nicht überall prüfen

[39:17] will, mache ich eine Klasse Alter,

[39:19] die im Konstruktor direkt prüft, ob der Wert negativ

[39:21] ist und in diesem Fall vielleicht eine Exception wirft.

[39:23] Nächstes Refactoring wäre

[39:25] ein ExtractClass. Das heißt,

[39:27] es ist auch genau das, was ich gerade beschrieben

[39:29] habe. Anstatt einen String zu benutzen,

[39:31] baue ich halt eine Art Wrapper-Klasse drumherum

[39:33] und introduceParameterObject.

[39:35] Auch das kann ich wieder benutzen,

[39:37] wenn zum Beispiel meine Methode

[39:39] drei verschiedene Parameter kriegt.

[39:41] Int und String und Double, meinetwegen.

[39:43] Dann kann ich da wieder ein Objekt draus machen, was

[39:45] diese Eigenschaften kapselt

[39:47] und dann vielleicht auch Geschäftsregeln darauf anwendet.

[39:49] Der Double-Betrag darf zum Beispiel vielleicht nicht negativ sein

[39:51] oder was auch immer. Das heißt, diese drei Refactorings

[39:53] kann ich da gut machen und Ziel von

[39:55] allen dreien ist halt, eine eigene

[39:57] Klasse zu bauen, in der alles gekapselt

[39:59] wird, was die Geschäftsregeln

[40:01] dieser

[40:03] Attribute eigentlich ausmacht.

[40:06] Also, vielleicht ein ganz guter Tipp, weg von primitiven Datentypen, hin zu eigenen, geschäftsrelevanten Klassen.

[40:12] So, die andere Hälfte der Codesmails gehen wir mal nur grob jetzt durch.

[40:17] Also die, die ich bislang beschrieben habe, die habe ich selber schon in viel Code gefunden,

[40:22] sowohl bei mir selbst, da nehme ich mich nicht aus, als auch insbesondere bei den Azubis.

[40:25] Und ich finde, viele von den Sachen sind auch einfach zu verstehen.

[40:28] Und man sieht auch, wo der Mehrwert ist, wenn man die Smails ablöst.

[40:31] Bei anderen ist das vielleicht nicht ganz so einfach oder ich habe sie nicht häufig gefunden.

[40:34] Deswegen kommt jetzt noch eine Reihe der letzten Codesmails, die auch im Buche stehen.

[40:39] Die gehen wir aber nicht im Detail durch.

[40:40] Und vor allem gehe ich auch nicht darauf ein, wie man das jetzt refactoren kann oder wie auch immer,

[40:43] sondern ich erkläre einfach kurz, was es überhaupt mit dem Smail auf sich hat und was vielleicht das Problem dabei ist.

[40:48] Und da fangen wir mal an mit Switch-Statements.

[40:50] Da bin ich vorhin schon kurz drauf eingegangen.

[40:52] Häufig ist es so, dass sich diese Switch-Statements über den Code immer, ich sage mal, weiter verbreiten.

[40:58] Man hat mal hier einen Switch gemacht und ein sehr, sehr, sehr ähnliches oder gleiches Switch brauche ich in der anderen Klasse dann auch nochmal.

[41:03] Und das führt wieder dazu, dass wir doppelten Code haben, den wir vermeiden wollen.

[41:06] Und das, ja genau, das ist das Ziel.

[41:09] Was kann ich da machen?

[41:09] Ganz häufig kann ich mit Polymorphie arbeiten, also anstatt irgendwie ein Switch zu machen.

[41:13] Und wenn das, dann macht das andere.

[41:15] Kann ich Polymorph arbeiten, neue Subklassen zum Beispiel einführen, wenn neue Fälle hinzukommen,

[41:19] anstatt überall die Switch-Statements erweitern zu müssen.

[41:22] Dann haben wir noch einen schönen Smail, der heißt Divergent Change.

[41:26] Wenn du jetzt englisch nicht mehr ganz so fit unterwegs bist, was heißt Divergent?

[41:30] Das heißt so etwas wie divergierend, super, heißt es auf Deutsch, ja, oder abweichend oder auseinanderlaufend.

[41:37] Und das ist, glaube ich, die beste Übersetzung dafür an der Stelle.

[41:40] Das heißt, wenn ich in einer Klasse aufgrund verschiedener Änderungen irgendwas anpassen muss,

[41:46] dann macht diese Klasse zu viel und das sollte ein Hinweis sein, dass ich da was tun muss.

[41:50] Deswegen Code Smail.

[41:52] Vielleicht erkläre ich das kurz in Zusammenhang mit dem nächsten Smail, nämlich Shotgun Surgery.

[41:56] Dann wird das vielleicht noch ein bisschen klar, was hier der Unterschied ist.

[41:58] Und zwar bei Shotgun Surgery, da geht es darum mit der Shotgun, also mit der Schrotflinte,

[42:03] die ja per Definition nicht eine Kugel irgendwo gut ins Ziel platziert,

[42:07] sondern einfach Schrot in die Menge verteilt und irgendeine Kugel wird schon treffen, so nach dem Motto.

[42:12] Da geht es darum, dass ich eine einzelne Änderung in verschiedenen Klassen durchführen muss.

[42:17] Beispiel, ich ändere irgendwas in der Datenbank und auf einmal muss ich in sieben verschiedenen Klassen irgendwas anpassen.

[42:24] Das Divergent Change ist quasi genau umgekehrt.

[42:26] Da muss ich in einer Klasse was anpassen, wenn sich verschiedene Dinge ändern.

[42:30] Das heißt, die Datenbank ändert sich oder das Dateisystem ändert sich.

[42:34] In beiden Fällen muss ich in dieser einen Klasse was machen.

[42:37] Das deutet darauf hin, dass diese eine Klasse einfach zu viel macht und das ist schlecht.

[42:42] Und das Shotgun Surgery geht genau in die andere Richtung.

[42:44] Ich habe Logik über das gesamte Programm so verstreut und verteilt, dass ich es eventuell gar nicht wiederfinden kann.

[42:50] Und das sagt eigentlich, dass diese Logik zusammengezogen werden sollte in eine einzelne Klasse.

[42:56] Die beiden Sachen hängen also so ein bisschen zusammen.

[42:58] Ganz kurz zusammengefasst, Divergent Change, einzelne Klasse muss aufgrund verschiedener Änderungen angepasst werden.

[43:05] Shotgun Surgery, einzelne Änderung erfordert Änderungen in verschiedenen Klassen.

[43:12] Dann haben wir noch Parallel Inheritance Hierarchies.

[43:15] Das ist jetzt so eine Art Sonderform der Shotgun Surgery.

[43:17] Deswegen habe ich die jetzt danach angeordnet.

[43:19] Und da geht es jetzt darum, wenn ich etwas ändere, Shotgun Surgery, wir erinnern uns, ich muss an mehreren Stellen eine Änderung durchführen.

[43:26] Wenn das sogar dazu führt, dass ich zusätzliche Subklassen in unterschiedlichen Vererbungs Hierarchien anlegen muss.

[43:33] Beispiel, ich habe eine neue Autofabrik Subklasse, dann muss ich auch eine neue Autosubklasse anlegen zum Beispiel.

[43:41] Dann ist das die Parallel Inheritance Hierarchie.

[43:45] Und das ist auch nicht gut, weil das heißt wieder, dass ich anscheinend meine Änderungen, die ich gerade machen will, auf das Programm irgendwo verstreut habe und nicht an einer einzigen Stelle das anpassen kann.

[43:56] So, dann haben wir die Lazy Class.

[43:59] Das ist eine winzig kleine Klasse, die kaum einen Mehrwert hat.

[44:02] Das könnte zum Beispiel so ein Parameter Object sein, das wir eingeführt haben.

[44:07] Das muss nicht schlecht sein.

[44:09] Heißt aber auch, manchmal, wenn ich Refactorings durchführe, bleibt in einzelnen Klassen gar nicht mehr so viel übrig, weil ich das alles irgendwo woanders hingestreut habe.

[44:16] Zum Beispiel angenommen, ich hatte eine riesengroße Klasse und habe die jetzt zerlegt in viele kleine, dann bleibt vielleicht am Ende von der ursprünglichen Klasse gar nicht mehr viel übrig.

[44:23] Und wenn diese Klasse dann wirklich keinen erkennbaren Mehrwert mehr hat oder überhaupt gar keinen Inhalt mehr hat, dann sollten wir sie wegschmeißen, einfach ablösen.

[44:32] Ja, dann haben wir Speculative Generality.

[44:36] Das ist quasi das You-Ain't-Gonna-Need-It-Prinzip umgekehrt.

[44:41] Und zwar, wenn ich mein Code immer so schreibe, dass ich an alles denke, was eventuell irgendwann mal passieren könnte.

[44:46] Irgendwann würden wir vielleicht mal die Datenbank austauschen.

[44:49] Das sind so Aussagen.

[44:50] Ja, das ist schön, wenn wir das irgendwann mal machen müssen in zehn Jahren.

[44:53] Aber wenn ich heute meinen Code so baue, dass der absolut, ja, Generality, also absolut generell, generisch quasi, funktioniert, dann mache ich mir ganz, ganz viel kaputt, weil ich ganz viele Abstraktionsebenen einführen muss, die am Ende kein Mensch mehr versteht, nur um eine absolute Eventualität noch mit abdecken zu können.

[45:10] Und das You-Ain't-Gonna-Need-It sagt sehr genau umgekehrt, wir sollen eben nur genau das programmieren, was wir auch wirklich brauchen und nicht das, was wir glauben, irgendwann mal brauchen zu können.

[45:20] So sollten wir nicht entwickeln.

[45:21] Und der Codesmell ist also, ich habe eine absolut generische Lösung, wo eigentlich eine konkrete Lösung locker ausgereicht hätte, die viel, viel einfacher zu verstehen wäre.

[45:31] Nächster Smell, TemporaryField.

[45:34] Wenn ich eine Klasse habe mit ganz vielen Instanzvariablen und viele davon werden nur temporär benutzt, daher der Name.

[45:41] Also Beispiel, ich rufe eine konkrete Methode auf und nur diese eine Methode nutzt diese Variablen eigentlich und merkt sich da drin auch nichts fürs nächste Mal, sondern es ist wirklich eine Art temporärer Speicher, wo sie Werte drin ablegt.

[45:53] Dann würde ich mich immer erst mal fragen, warum macht ihr das nicht mit lokalen Variablen?

[45:56] Aber gut, das ist jetzt mal dahingestellt.

[45:59] Wenn ich so eine Klasse habe und diese Variablen wirklich nur für einzelne Methoden so benutzt werden, dann sollte ich das nicht tun.

[46:06] Denn dann gucke ich mir die Klasse an und gucke mir als erstes meistens die Instanzvariablen an, um verstehen zu können, was diese Klasse eigentlich macht, was da drin ist.

[46:13] Und wenn ich dann viel Zeug finde, was eigentlich nur temporär benutzt wird, dann erschwert das wieder das Verständnis.

[46:18] Das heißt, das sollten wir aufbrechen und vielleicht wirklich als lokale Variablen in die Methode reinpacken, zum Beispiel.

[46:26] Nächster Smell, MessageChains.

[46:28] Das kann man wunderbar mit so einem kleinen Programmiergesetz in Verbindung bringen, und zwar mit dem Law of Demeter.

[46:33] Das hast du vielleicht schon mal gehört.

[46:35] Was ist hier das Problem bei diesen MessageChains?

[46:38] Das ist ein Objekt, was ein anderes Objekt aufruft, das dann wieder ein anderes Objekt aufruft, und von dem kommt noch ein Objekt zurück, an dem ich wieder was aufrufe.

[46:45] Also mein Beispiel, keine Ahnung, Versicherungsvertrag.getPolice.getBeitrag.getMonatszahlung.irgendwas.

[46:54] Das heißt, ich habe Objekte, Objekte, Objekte hintereinander gekettet, deswegen MessageChain, also Methode, die wieder eine andere Methode aufruft, die wieder eine andere Methode aufruft.

[47:02] Und das Problem dabei ist, dass der Aufrufer diese ganze komische Verkettung der Objekte kennen muss, also die interne Struktur der Objekte.

[47:10] Der Aufrufer muss wissen, an dem Versicherungsvertrag, da gibt es die Police, und die Police hat dann den Beitrag, und der Beitrag hat dann das und das und das.

[47:18] Und wenn sich irgendwas an diesem internen Aufbau ändert, dann steht der Aufrufer doof da.

[47:22] Das muss nämlich dann überall angepasst werden.

[47:24] Das heißt, der Aufrufer weiß viel zu viel über den internen Aufbau der Objekte.

[47:28] Das soll er gar nicht wissen, wir wollen ja abstrakt arbeiten können, um das austauschen zu können, und deswegen wollen wir das nicht haben.

[47:35] Und das Law of Demeter zum Beispiel, das sagt dann, dass ich am besten in einer Zeile Code nur einen einzigen Punkt haben darf, wenn der Punkt der Operator ist, um Methoden aufzurufen.

[47:44] Und das führt dann dazu, dass wir eben diese interne Struktur nicht mehr kennen müssen und sich der Code dadurch viel einfacher anpassen lässt später mal.

[47:54] Dann haben wir den SmellMiddleMan.

[47:57] Gerade haben wir gesagt, Delegieren ist gut, Abstraktionen einführen ist gut, das können wir aber auch übertreiben, und zu viel des Guten ist meistens dann wiederum schlecht.

[48:05] Das heißt, wenn ich zum Beispiel mit einem Objekt spreche und der jeden Methodenaufruf gar nicht selber beantwortet, sondern irgendwie an einen anderen delegiert,

[48:14] dann ist das genau dieses Prinzip MiddleMan.

[48:17] Ich rede eigentlich mit jemandem, der mir aber eigentlich gar keine Antwort geben kann, sondern der meine Anfragen einfach nur weiterleitet,

[48:22] und die Ergebnisse, die der dann zurückliefert, mir wiederum weiterleitet.

[48:25] Also der wirklich einfach nur in der Mitte dazwischen steht, und das ist unsinnig, das ist Overhead, das ist schwer zu verstehen, und das sollten wir eliminieren.

[48:33] Also, MiddleMan rausnehmen und direkt mit dem Objekt reden, was mir die Antworten auch geben kann.

[48:39] Auch das kann man aber wiederum zu weit führen, da kommen wir dann vielleicht wieder zum nächsten Smell.

[48:43] Inappropriate Intimacy, also Intimität, die nicht angebracht ist.

[48:48] Die Klassen, mit denen wir arbeiten, sollten nicht zu viele Details der anderen Klassen kennen, mit denen sie zusammenarbeiten.

[48:55] Also, wenn ich mich auf die interne anderer Klassen verlasse, irgendwelche, keine Ahnung, privaten Sachen aufrufe, am besten noch über Reflection oder sonst irgendwas,

[49:03] das ist keine gute Idee, private Sachen sind aus gutem Grund privat, die können sich ändern, die dürfen sich ändern,

[49:09] und wenn ich mich darauf verlasse, dann mache ich den Fehler und nicht die Klasse, die sich verändert hat.

[49:13] Also, darauf sollte ich achten, nicht zu viele Interna aus anderen Klassen mir irgendwie zu beschaffen.

[49:20] Dann Alternative Classes with Different Interfaces.

[49:24] Ich fasse das mal so zusammen, gleiche Dinge sollten auch gleich benannt werden.

[49:28] Ich sage meinen Azubis immer, wir sind keine Schriftsteller, wir sind Programmierer.

[49:32] Das heißt, wir brauchen für das gleiche Ding den gleichen Begriff.

[49:36] Wir nennen nicht eine Methode ErzeugeAntrag und die nächste Methode KreiereAntrag.

[49:42] Wir wollen hier nicht kreativ tätig werden, sondern Dinge, die das gleiche machen, müssen den gleichen Namen haben, damit ich sie wiedererkenne,

[49:49] damit ich den Code besser verstehen kann und nicht immer überlegen muss, warum es in Klasse A so heißt und in Klasse B anders heißt.

[49:57] Das macht auch die, wie heißt es auf Englisch schön, die Explorability, also die Erforschbarkeit meines Codes, ganz schwer.

[50:05] Denn wenn ich überall sowas wie Kreiere benutze und an einer Stelle heißt es aber Erzeuge,

[50:11] dann ist es natürlich ganz schwer für mich, das überhaupt rauszufinden.

[50:13] Warum heißt das da anders? Und ich finde die Methode vielleicht noch nicht mal, weil ich erwarte, dass sie mit K anfängt und nicht mit E.

[50:19] Also, gleiche Dinge, gleich benennen, ganz wichtig für das Verständnis des Codes.

[50:24] Dann haben wir noch ein Smell, IncompleteLibraryClass.

[50:28] Da geht es darum, wenn wir Bibliotheken benutzen, ich sag jetzt zum Beispiel mal JUnit, so eine beliebte Bibliothek für Tests,

[50:34] und wenn die jetzt irgendwas nicht hat, was wir brauchen, dann sollte das nicht ein Ansatz sein, das Ding komplett neu zu entwickeln,

[50:41] weil wir diese eine kleine Funktionalität in JUnit vermissen, bauen wir quasi JUnit 2.

[50:45] Nein, das ist keine gute Idee, sondern wir sollten diese Bibliothek dann um das ergänzen, was uns fehlt,

[50:50] und nicht alles nochmal neu entwickeln.

[50:54] Dann haben wir DataClass, da haben wir jetzt schon ein paar Mal drüber geredet.

[50:57] Also, die guten alten POJOs aus Java oder POCOs aus .NET, also die Plain Old Java Objects oder C-Sharp Objects oder was auch immer.

[51:04] Oder in Java auch die gerne genommenen Java Beans.

[51:07] Das sind immer so Klassen, wie der Name sagt, Data Classes, die haben keinerlei Logik,

[51:11] also die enthalten außer Getter und Setter eigentlich gar nichts an Methodik, also an Algorithmik,

[51:18] sondern sind eigentlich nur dafür da, um Daten durch die Gegend zu schieben.

[51:21] Und das kann ein Codesmell sein, wir haben vorhin schon drüber geredet, dass das auch mal nicht so sein kann,

[51:26] aber häufig, gerade wenn meine Domänenklassen so aufgebaut sind, ist das definitiv ein Codesmell.

[51:31] Also, wenn ich in der Versicherung einen Versicherungsvertrag habe, der einfach nur 27 Eigenschaften hat und sonst keinerlei Logik enthält,

[51:37] dann ist das sehr wahrscheinlich eine Data Class, die wir verändern sollten.

[51:42] Und als allerletztes heute der Smell Refused Bequest.

[51:47] Das bringe ich immer irgendwie bei Bequest und Refused, denke ich immer an Request, aber das hat tatsächlich nichts damit zu tun.

[51:53] Also, wenn du hier auch englisch nicht mehr ganz so fit bist, oder ich muss zugeben, den Begriff habe ich jetzt auch noch nicht so häufig benutzt,

[51:58] Bequest heißt Vermächtnis oder Nachlass.

[52:03] Und das deutet schon darauf hin, dass wir uns hier irgendwie bei der Vererbung bewegen.

[52:07] Und Refused Bequest ist also ein Nachlass, der abgelehnt wird.

[52:13] Also, wenn du irgendwas erbst und sagst, nö, will ich aber nicht, dann ist das ein Refused Bequest.

[52:18] Und jetzt übertragen wir das mal auf Klassen.

[52:19] Wenn eine Subklasse von ihrer Basisklasse etwas vererbt bekommt, was sie nicht haben will,

[52:25] also Beispiel eine Methode, die sie gar nicht benutzen will oder im Gegenteil, gar nicht benutzen darf oder soll oder wie auch immer,

[52:33] dann haben wir ein Problem, weil das können wir nach Vererbung nicht einschränken.

[52:36] Wir können nicht sagen, so, an diese eine Klasse wird aber die Methode nicht vererbt.

[52:39] Nein, entweder ganz oder gar nicht.

[52:41] Wenn das aber so ist, dass wir einzelne Methoden vielleicht nicht brauchen,

[52:45] dann sollte ich mal darüber nachdenken, ob diese Vererbungshierarchie hier noch passend ist.

[52:48] Oder ob ich da vielleicht die Basisklasse ein bisschen schmaler machen muss

[52:51] und die Methode, die ich nicht vererben will, dann in eine andere Subklasse packe, die die braucht zum Beispiel.

[52:57] Also, sollte zum Nachdenken anregen, ob die Vererbungshierarchie vielleicht das geeignete Mittel hier ist

[53:02] oder ob ich einfach einzelne Klassen mache, die am Ende gar nichts miteinander zu tun haben.

[53:06] Das ist der Denkanstoß hier.

[53:09] So, jetzt haben wir heute alle klassischen Codesmails, die aus dem Buch Refactoring von VLOG kommen, hier mal durchgesprochen.

[53:16] Ungefähr die Hälfte etwas im Detail, auch was man dagegen tun kann,

[53:19] und die andere Hälfte so ein bisschen oberflächlicher.

[53:22] Ich hoffe, dass wenigstens die Begriffe jetzt verständlicher sind.

[53:25] Wenn du sie vielleicht vorher noch nie gehört hast, kennst du sie jetzt.

[53:27] Und wenn du sie schon mal gehört hast, aber nicht genau wusstest, was in der steckt,

[53:30] hast du sie jetzt hoffentlich auch verstanden.

[53:32] Das war mein Ziel für heute.

[53:34] Und nochmal zusammenfassend, Codesmails sind ganz, ganz wichtig in meiner täglichen Arbeit.

[53:39] Wenn ich mir fremden Code, aber auch meinen eigenen angucke,

[53:41] dann muss ich die im Kopf haben und überlegen, irgendwie ist das hier Mist, da muss ich nochmal ran.

[53:46] Und im besten Fall kenne ich dann sogar noch die Refactorings, die dazu führen, um die Codesmails aufzulösen.

[53:51] Und dann kann ich auch in meiner täglichen Arbeit meinen Code wirklich optimieren, verständlicher machen

[53:57] und somit dazu beitragen, dass er auch langfristig noch wartbar bleibt.

[54:01] Und das ist ja auch unser Job.

[54:02] Wir programmieren meistens nicht nur einmal was drunter,

[54:04] sondern wir pflegen diesen Code dann ja auch über die nächsten Jahre.

[54:07] Und damit machen wir uns selber das Leben einfacher,

[54:09] wenn wir diese Codesmails tatsächlich auflösen und durch was Besseres ersetzen.

[54:14] Literaturempfehlung, ich habe es jetzt schon ein paar Mal genannt,

[54:17] das klassische Buch Refactoring von Martin Fowler,

[54:20] alternativ in einer neuen Auflage zum Thema JavaScript, gerade vor kurzem erst erschienen.

[54:25] Ich habe da noch ein paar Links zusammengesammelt, gibt ein paar schöne Websites,

[54:27] wo alle Refactorings und auch alle Codesmails nochmal mit schönen Beispielen erklärt.

[54:31] Dargestellt werden, gerne mal reinschauen.

[54:33] Die Shownotes findest du wie immer unter anwendungsentwicklerpodcast.de

[54:37] slash 147, denn das hier heute war die 147. Episode.

[54:43] Ich würde mich freuen, wenn du mir auch einen Kommentar da lässt,

[54:46] wenn du noch irgendwas zu ergänzen hast, vielleicht noch ein paar Links oder andere Bücher

[54:48] oder vielleicht noch ein paar schöne Beispiele, wie auch immer.

[54:51] Schreib mir gerne einen Kommentar in die Shownotes,

[54:53] dann sehen auch andere Leute das, wenn sie auf die Website gehen.

[54:55] Ansonsten freue ich mich natürlich auch über Feedback in Form von Rezensionen

[54:59] oder einfach Sternebewertungen bei iTunes oder wo auch immer du das hier gerade hörst.

[55:02] Vielleicht auch gerne, wenn das geht, ich weiß es gar nicht,

[55:05] bei Spotify zum Beispiel ist mein Podcast ja auch schon seit langem verfügbar.

[55:09] Also ich freue mich auf jeden Fall über deinen Feedback.

[55:10] Du findest sicherlich eine Möglichkeit, wie du das los wirst.

[55:14] Ansonsten hoffe ich, dass du dir heute ein bisschen was mitnehmen konntest

[55:16] und wir mal wieder ein bisschen tiefer in die Programmierthematik abtauchen konnten.

[55:21] Ich glaube, das kommt dir entgegen als Hörer des Anwendungsentwickler-Podcasts.

[55:25] Und ja, also ich hoffe, du konntest ein bisschen was mitnehmen.

[55:28] Ich sage vielen Dank fürs Zuhören und bis zum nächsten Mal. Tschüss!

Polyglot Clean Code Developer
About the Author
Ausbildungsleiter für Fachinformatiker:innen Anwendungsentwicklung, IHK-Prüfer und ehemaliger Hochschuldozent für Programmierung und Software-Engineering.

2 comments on “Code Smells und Refactorings – Anwendungsentwickler-Podcast #147”

  1. Anton sagt:

    Servus Stefan, ich bin vor ca. einem halben Jahr durch Zufall auf dein Podcast gestoßen und mir mittlerweile bestimmt über 50 Folge angehört. Vor allem abstrakte Themen wie Pattern oder spezielle Themen wie „Zeichensätze“ oder allgemeine Tipps rund um CleanProgramming waren für mich echt wertvoll. Gerade beim Thema CleanProgramming ist man eigentlich nie ausgelernt – da kann man vom neuen Wissen nur profitieren.

    Großen Dank für deine Inhalte! Ich freue mich auf neue Folgen

    Viele Grüße
    Anton

  2. Stefan Macke sagt:

    Hallo Anton, danke für dein Feedback. Das freut mich! 🙂

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert