Single Responsibility Principle (SRP) – Wissenshäppchen #3

This entry is Teil 3 von 8 in the series Wissenshäppchen

Mein drittes Wissenshäppchen hat das Single Responsibility Principle zum Thema.

TL;DR

Das Single-Responsibility-Principle (SRP) ist das erste SOLID-Prinzip: Eine Klasse soll genau eine Aufgabe und damit einen Grund haben, geändert zu werden. Ich übertrage diesen Gedanken auch auf Methoden und andere Komponenten, damit du ihren Code leichter verstehen und getrennt testen kannst. Dabei brauchst du einen passenden Ausgleich zwischen hoher Kohäsion und geringer Kopplung, weil viele kleine Komponenten zusätzliche Abhängigkeiten erzeugen und das Gesamtsystem schwerer überschaubar machen können.

Kapitelmarken

  • [00:00:26] SRP als erstes SOLID-Prinzip
  • [00:01:37] Kohäsion: Zusammenhang von Methoden und Attributen
  • [00:02:45] Fehler durch mehrere Aufgaben in einer Klasse
  • [00:03:37] SRP für Variablen und Methoden
  • [00:04:33] Datenbankzugriff und E-Mail-Versand getrennt testen
  • [00:06:30] SRP auf Architekturebene und bei Microservices
  • [00:08:01] Mehrere Aufgaben an Namen erkennen
  • [00:08:48] Allgemeine Klassennamen und Repository-Methoden
  • [00:10:31] Architekturschichten und Wiederverwendung
  • [00:11:59] Legacy-Software und automatisierte Tests
  • [00:13:42] Die Gott-Klasse als Anti-Pattern
  • [00:15:00] Verständlicher Code und isolierte Tests
  • [00:17:35] Überblick über viele kleine Komponenten behalten
  • [00:20:06] Zusätzliche Abhängigkeiten durch kleine Klassen
  • [00:22:11] Hohe Kohäsion und geringe Kopplung abwägen
  • [00:23:12] Fachbegriffe: Cohesion und Coupling
  • [00:23:50] Kleine Komponenten früh voneinander trennen
  • [00:25:42] Weiterführende Links und Feedback

Probeabo bei Audible (Affiliate)

Inhalt

Das SRP ist das erste der sogenannten SOLID-Prinzipien. Robert „Uncle Bob“ Martin definiert es so:

There should never be more than one reason for a class to change.

Jede Klasse sollte genau einen einzigen Grund haben, um geändert zu werden. Man kann das Prinzip aber auch auf anderen Ebenen (z.B. Variablen, Methoden oder ganze Komponenten) berücksichtigen.

Erklärung

  • Nur Dinge, die zusammengehören, werden auch zusammen abgebildet. Jedes Ding (Variable, Methode, Klasse, Komponente) darf nur eine Aufgabe haben. Die Kohäsion der Dinge sollte hoch sein.
  • Verletzung ist erkennbar an Wörtern wie und oder oder. Unklare Namen wie z.B. Manager oder Verwaltung sind auch häufig ein Anzeichen für die Verletzung des Prinzips.
  • Wenn viele Abhängigkeiten und Dinge, die nichts miteinander zu tun haben, in einer Klasse zusammengefasst werden, kann beim Anpassen einer (Teil-)Implementierung eventuell eine damit gar nicht in Zusammenhang stehende Implementierung negativ beeinträchtigt werden.
  • Praxisbeispiel: Klasse, die Daten aus der Datenbank liest und diese direkt in der Oberfläche anzeigt. Klasse hat nicht nur eine Aufgabe, sondern drei verschiedene: Geschäftslogik, Datenzugriff, Anzeige. Ein Test der Logik ohne Datenbank und/oder Oberfläche ist nun unmöglich. Die Wiederverwendbarkeit der Klasse leidet auch, da die Logik nun nicht mehr ohne Datenbank und/oder Oberfläche aufgerufen werden kann. Das ist oft ein großes Problem in Legacy-Anwendungen.
  • Ein krasses Gegenbeispiel/Antipattern zum SRP wäre eine Gott-Klasse, die alles Mögliche macht.

Vorteile

  • Die Klassen, Methoden und Variablen sind insgesamt kürzer und besser verständlich.
  • Entwickler können Anpassungen durchführen, ohne dabei Fehler an anderer Stelle einzubauen.
  • Komponenten sind einfacher testbar. Das Test-Setup ist kleiner, weil unnötige Abhängigkeiten nicht bereitgestellt werden müssen. Probleme bei der Testbarkeit und Verständlichkeit entstehen häufig, wenn zu viel auf einmal passiert. Zu wenig ist meistens kein Problem.

Nachteile

  • Durch viele kleine Methoden und Klassen leidet evtl. die Übersicht über das Gesamtsystem und man findet sich schwieriger zurecht. Dem kann man aber entgegenwirken und es ist erstmal nicht schlimm, viele kleine Klassen anzulegen, anstatt eine große. Dateien kosten nichts. Dateien/Klassen können in IDEs mit Shortcuts schnell gefunden/geöffnet werden. Wenn auf eine vernünftige (einheitliche) Benennung geachtet wird, sind Klassen auch so gut auffindbar. Weitere Konventionen (z.B. die Einordnung in Package-Strukturen) helfen auch bei der Organisation.
  • Wenn Klassen nur eine einzige Aufgabe haben dürfen, steigt automatisch die nötige Kopplung zu anderen Klassen, weil deren Funktionalität benötigt wird, um die Gesamtaufgabe zu erfüllen. Hier gilt es, einen guten Mittelweg zu finden, der eine möglichst hohe Kohäsion bei gleichzeitg geringer Kopplung ermöglicht.

Literaturempfehlungen

Wie zu fast jedem Wissenshäppchen kann ich jeder/m Anwendungsentwickler/in nur wärmstens Clean Code* von Uncle Bob ans Herz legen. Das SRP wird hier auch erklärt und gleich praktisch angewendet.

Robert C. Martin - Clean Code: A Handbook of Agile Software Craftsmanship (Affiliate)*

Links

Zusammenfassung

Eine Aufgabe pro Komponente

Robert C. Martin, auch als Uncle Bob und Autor von Clean Code bekannt, beschreibt das Single-Responsibility-Principle (SRP) über den Grund, eine Klasse zu ändern: Für jede Klasse soll es genau einen solchen Grund geben. Wenn du ihre Aufgabe anpasst, änderst du den dazugehörigen Code.

Ich übertrage dieses erste SOLID-Prinzip auch auf Variablen und Methoden sowie auf ganze Programme. Jede dieser Einheiten soll eine klar abgegrenzte Aufgabe erfüllen.

Wie gut gehört der Code zusammen?

Wenn du prüfst, welche Attribute die Methoden einer Klasse verwenden, bekommst du Hinweise darauf, wie eng ihre Bestandteile zusammengehören. Der Fachbegriff dafür ist Kohäsion, auf Englisch Cohesion. Über Softwaremetriken lässt sich dieser Zusammenhang messen.

Greifen verschiedene Methoden jeweils auf völlig getrennte Attribute zu, lohnt sich ein genauerer Blick auf die Aufgaben der Klasse. Darin können mehrere Verantwortlichkeiten stecken.

Wenn ich in einer solchen Klasse ein Attribut ändere, kann das eine weitere Funktion beeinflussen, die ebenfalls darauf zugreift. Solche Fehler erschweren es dir, den Code zu pflegen und ihre Ursache nachzuvollziehen.

Beispiel: Daten speichern und eine E-Mail verschicken

Bei einer Registrierung gehören das Speichern eines neuen Kontos und das Verschicken einer Bestätigungs-E-Mail zum selben fachlichen Ablauf. Technisch sind es eigenständige Aufgaben.

Ich verteile sie auf getrennte Methoden. Die Methode für den Datenbankzugriff kann Ergebnisse liefern, die anschließend als Parameter an die Methode für den E-Mail-Versand gehen. Eine übergeordnete Komponente verbindet die Schritte.

Dadurch kannst du den Datenbankzugriff separat testen. Enthält eine Methode beide Aufgaben, hängt ihr Test zusätzlich vom E-Mail-Versand ab. Ein fehlender Mailserver kann dann einen Test scheitern lassen, der das Speichern prüfen soll.

Auch eine boolesche Variable kann mehrere Aussagen bündeln, etwa "Person ist über 18 und bekommt einen Nachlass". Später lassen sich die einzelnen Prüfergebnisse daraus schwer wieder gewinnen. Wenn du die Bedingungen an dieser Stelle immer gemeinsam brauchst, kann ein gemeinsamer Wert sinnvoll sein.

Hinweise auf mehrere Verantwortlichkeiten

Beim Lesen von Namen und Tests kannst du nach folgenden Anzeichen suchen:

  • "Und" oder "oder" im Namen: Eine Methode wie "Speichere Konto und verschicke Bestätigungs-E-Mail" beschreibt mehrere Aufgaben.
  • Allgemeine Klassennamen: Begriffe wie "Manager" oder "Verwaltung" können darauf hinweisen, dass die eigentliche fachliche Aufgabe noch unklar ist. Hier fehlt häufig eine passende Abstraktion, etwa eine getrennte Klasse zum Lesen oder Schreiben von Objekten.
  • Aufwendige Tests: Wenn du für eine kleine Funktion viele Abhängigkeiten bereitstellen musst, solltest du die Verantwortlichkeiten der Klasse prüfen. Besonders verschachtelte Mocks und Stubs können ein Hinweis sein.

Bei einem Repository sollten die CRUD-Aktionen mindestens eigene Methoden bekommen. Eine einzige Methode, die über einen Aktionsparameter und einen großen Switch entscheidet, was sie tun soll, übernimmt mehrere Aufgaben. Bei einer strengen Auslegung des SRP lassen sich Lesen und Schreiben auch auf eigene Klassen verteilen.

Architektur und Wiederverwendung

Wenn Geschäftslogik fest mit einer Weboberfläche verbunden ist, erschwert das ihren Einsatz in einer Konsolenanwendung. Eine fest eingebaute Datenbankabhängigkeit bindet sie außerdem an diese Datenquelle.

Aus meinem Alltag mit Legacy-Software kenne ich Komponenten, die innerhalb einer Datenbankschleife Geschäftslogik ausführen und Ergebnisse direkt auf einer Oberfläche anzeigen. Um die Logik zu testen, brauchst du dann die Datenbank samt passenden Daten. Wartet die Oberfläche auf Eingaben, muss zusätzlich eine Person eingreifen, was automatisierte Tests behindert.

Die Gott-Klasse ist ein Anti-Pattern, bei dem nahezu das gesamte Programm in einer Klasse steckt. Ein Fehler kann große Teile des Programms beeinträchtigen. Einzelne Funktionen lassen sich wegen der vielen verbundenen Aufgaben schwer isoliert prüfen.

Auf Architekturebene lässt sich derselbe Gedanke bei Microservices wiederfinden: Ein Service bildet eine abgegrenzte Fachlichkeit ab. Änderungen innerhalb dieses Bereichs bleiben dadurch zunächst auf die betreffende Komponente begrenzt. Gemeinsam zugängliche Datenfelder können dagegen dazu führen, dass weitere Komponenten Werte verändern, die fachlich zu einem anderen Bereich gehören.

Was kleine Komponenten erleichtern

Wenn eine Komponente eine klar umrissene Aufgabe erfüllt, enthält sie meist weniger Code. Du kannst sie schneller verstehen und die passende Stelle für eine Änderung leichter finden. Getrennte Verantwortlichkeiten erleichtern außerdem, vorhandenen Code erneut einzusetzen.

Für mich spielt besonders das isolierte Testen eine Rolle. Externe Abhängigkeiten lassen sich dabei durch Mocks oder Stubs ersetzen. Je kleiner der Bereich ist, den du prüfst, desto weniger musst du für den Test vorbereiten.

Überblick und Abhängigkeiten

Durch viele kleine Klassen kann es schwieriger werden, das Zusammenspiel des Gesamtsystems zu verstehen. Ich ordne zusammengehörige Komponenten deshalb über Packages in Java oder Namespaces in .NET. Eine passende Ordnerstruktur hilft dir beim Suchen.

Mit ausgeschriebenen, aussagekräftigen Namen und festen Namenskonventionen findest du Komponenten auch über die Suche deiner IDE. Als Beispiel dient in Eclipse Strg + Umschalt + T, um einen Typ direkt zu öffnen.

Wenn mehrere kleine Komponenten eine Gesamtaufgabe erfüllen, entstehen Abhängigkeiten zwischen ihnen. Diese Kopplung kann zusätzliche Mocks oder Stubs für Tests erforderlich machen. Bei der Registrierung braucht es beispielsweise eine Komponente, die den Datenbankzugriff mit dem E-Mail-Versand verbindet.

Als Softwareentwickler:in entscheidest du, wie du hohe Kohäsion und geringe Kopplung miteinander vereinbarst. Dabei zählt sowohl die abgegrenzte Aufgabe einer Klasse als auch die Zahl ihrer Abhängigkeiten.

Beim Entwickeln früh trennen

Ich beginne mit kleinen, eigenständigen Komponenten und fasse sie bei Bedarf auf einer höheren Ebene zusammen. Aus meiner Erfahrung mit Legacy-Software ist es aufwendig und fehleranfällig, eng verflochtene Aufgaben nachträglich auseinanderzunehmen.

Ein frei zugängliches Buchkapitel von Uncle Bob zum SRP ist in meinen Shownotes unter anwendungsentwicklerpodcast.de/WH3 verlinkt.

Transkription der gesamten Episode

Automatisch erzeugte Transkription der Episode

[0:00] Herzlich willkommen zu den Wissenshäppchen beim Anwendungsentwickler-Podcast. In dieser

[0:09] Episode geht es um das Single-Responsibility-Principle. Viel Spaß!

[0:20] Hallo und herzlich willkommen zum dritten Wissenshäppchen hier im Anwendungsentwickler-Podcast.

[0:26] Mein Name ist Stefan Macke und heute geht es um das erste der sogenannten SOLID-Prinzipien,

[0:32] das Single-Responsibility-Principle oder auch SRP abgekürzt. Das ist das erste auf der Liste

[0:39] der SOLID-Prinzipien, weil es auch eines der wichtigsten ist, vielleicht sogar das wichtigste,

[0:43] nämlich ein Ding, eine Aufgabe. So kann man es eigentlich relativ kurz zusammenfassen. Oder auch

[0:50] wie der, ja ich will nicht sagen Schöpfer des Prinzips, aber derjenige, der es wohl zum ersten

[0:55] Mal aufgeschrieben hat und ihm einen Namen gegeben hat, nämlich Uncle Bob Robert Martin, der Autor

[0:59] von Clean Code, der hat es so definiert, there should never be more than one reason for a class

[1:05] to change. Also eine Klasse soll aus genau einem einzigen Grund geändert werden dürfen und nicht

[1:13] aus mehreren. Also darum geht es. Eine Klasse soll genau eine Aufgabe haben, denn das bedeutet, wenn

[1:18] ich diese eine Aufgabe ändern will, dann muss ich die Klasse ändern. Aber nicht, wenn ich, keine

[1:22] Ahnung, was in meiner Datenbank ändere, muss ich auf einmal meine Klasse anpassen, die mit dieser

[1:27] Datenbank gar nichts zu tun hat. Darum geht es im Prinzip, dass die Klasse in sich konsistent ist,

[1:31] dass sie nur Dinge enthält, die zueinander gehören und eben nicht noch andere Dinge, die eigentlich

[1:37] gar nicht dazugehören. Und dieses, die Dinge in der Klasse gehören zusammen, das nennt man auch

[1:43] Kohärenz und das bezieht sich insbesondere auf die Attribute und Methoden in dieser Klasse. Die

[1:48] Kohärenz, das ist eigentlich eine Softwaremetrik, mit der man misst, wie gut die Methoden und die

[1:54] Attribute einer Klasse zusammen passen und zusammengehören. Was bedeutet das? Man misst

[1:58] zum Beispiel, wie viele Attribute der Klasse in den jeweiligen Methoden überhaupt benutzt werden.

[2:04] Und wenn es zum Beispiel Methoden gibt in einer Klasse, die gar nicht alle Attribute benutzen oder

[2:09] noch schlimmer, die nur ein einziges Attribut benutzen dieser Klasse und andere Methoden, die

[2:13] ein ganz anderes Attribut der Klasse nutzen, warum gehören die dann zusammen? Denn diese zwei

[2:18] Attribute haben augenscheinlich nichts miteinander zu tun, wenn zwei völlig unterschiedliche Methoden

[2:23] die jeweils nur benutzen. Und das ist quasi die formelle Definition der Kohärenz. Das kann man

[2:28] jetzt messen, wie viele Methoden, wie viele quasi prozentual Attribute dieser Klasse nutzen und dann

[2:34] kommt man zu dieser Kohärenz. Und das ist eine Aussage darüber, wie gut die Bestandteile dieser

[2:39] Klasse zusammengehören. Und im Prinzip geht es beim SRP genau um das, um die Kohärenz der Klasse.

[2:45] Das heißt, gehört das alles zusammen oder hat eine Klasse zum Beispiel mehrere Aufgaben? Und das

[2:50] würde ja bedeuten, wenn ich die eine Aufgabe anpassen muss, habe ich eventuell auch bei der

[2:55] zweiten Aufgabe, die diese Klasse übernimmt, einen Fehler eingebaut. Denn es ist ja die gleiche Klasse,

[3:00] der gleiche Code, den ich da aufgemacht habe. Und wenn ich jetzt zum Beispiel in einer Methode irgendein

[3:04] Attribut ändere und gar nicht weiß, dass in der gleichen Klasse noch eine ganz andere Funktionalität

[3:08] vielleicht das gleiche Attribut benutzt, dann habe ich quasi diese Funktionalität kaputt gemacht,

[3:13] obwohl ich ja eigentlich eine ganz andere anpassen wollte. Und das ist natürlich schlecht für die

[3:17] Änderbarkeit, für die Wagbarkeit und auch um Fehler nachvollziehen zu können, die ich da eingebaut

[3:22] habe. Denn eigentlich wollte ich ja was ganz anderes machen und auf einmal fällt irgendwo hinten

[3:26] rechts ein, keine Ahnung, irgendwie ein Sack um. Obwohl ich eigentlich ganz vorne links irgendwas

[3:30] gemacht habe. Das soll natürlich nicht passieren, denn das führt ja dazu, dass ich selber gar nicht

[3:33] mehr verstehe, was ich da gemacht habe und warum jetzt auf einmal was kaputt gegangen ist. Man kann

[3:37] aber dieses Single Responsibility, und das mache ich auch ganz gerne, auch auf andere Komponenten

[3:42] beziehen als auf eine Klasse. Also für mich gehören zum Beispiel auch Variablen, Methoden oder

[3:47] sogar ganze Komponenten oder sogar ganze Programme mit zu diesem Single Responsibility Principle.

[3:52] Denn alle diese Dinge sollten eigentlich nur eine einzige Aufgabe haben. Man kann einer Variablen

[3:57] zum Beispiel auch mehrere Aufgaben quasi zuteilen. Stellen wir uns mal eine Buhlsche Variable vor, die

[4:03] dann zum Beispiel das Prüfergebnis von mehreren Abfragen enthält. Ja, was weiß ich, Person ist

[4:09] über 18 und kriegt einen Nachlass zum Beispiel. Dann könnte ich ja diese Abfrage über 18 und

[4:15] bekommt Nachlass in einer Buhlschen Variablen ablegen. Und schon hat diese Variable zwei Aufgaben

[4:20] und das führt dann dazu, dass ich später diese eine Abfrage, die ich da gemacht habe, gar nicht

[4:25] mehr auseinander rupfen kann. Wenn das sinnvoll ist, weil ich das dann an der einen Stelle immer

[4:29] zusammen brauche zum Beispiel, ist das natürlich okay. Ja, das war jetzt auch nur ein Beispiel, aber

[4:33] häufiger hat man es in Methoden zum Beispiel. Wenn ich da anfange irgendwas zu programmieren, dann

[4:37] könnte ich da noch mal eben schnell diese Kleinigkeit auch noch mitmachen. Da könnte

[4:42] doch diese Methode nicht nur das Ding in der Datenbank speichern, sondern auch noch eine

[4:45] Bestätigungs-Mail an den Benutzer schicken zum Beispiel. Und dann sieht man sich ganz schnell

[4:49] damit konfrontiert, dass so eine Methode halt auf einmal viel, viel, viel mehr macht, als sie

[4:53] eigentlich mal machen sollte. Und dann wird es ganz schwierig, diese Methode zum Beispiel zu

[4:57] testen. Denn man kann in dem Beispiel von eben nicht das Speichern in der Datenbank losgelöst

[5:03] von dem Mail-Versand testen. Das heißt, jedes Mal, wenn ich gucke, ob die Methode auch was in

[5:08] der Datenbank ablegt, muss ich so ganz nebenbei auch noch eine Mail verschicken. Und wenn ich

[5:12] zum Beispiel für diesen Test aktuell gar keinen Mail-Server hier rumstehen habe, meinetwegen,

[5:16] dann habe ich auf einmal eine Abhängigkeit, die ich nicht auflösen kann und der Test schlägt

[5:19] viel. Zum Beispiel. Ja, das ist jetzt bewusst übertrieben, das Beispiel. Aber es gibt natürlich

[5:23] in ganz vielen Bereichen so die Möglichkeit, Dinge, die eigentlich nichts miteinander zu tun

[5:28] haben, mal eben schnell in der gleichen Methode unterzubringen. Beispiel jetzt beim Speichern,

[5:32] wäre jetzt vielleicht ein Prozess, wo ein neuer Benutzer sich registriert. Da muss dieser Benutzer

[5:37] natürlich in der Datenbank abgelegt werden und so eine Bestätigungs-Mail vielleicht auch noch

[5:40] verschickt werden. Das gehört zum gleichen Use-Case. Aber die Aufgabe Mail-Versand und

[5:45] Datenbankzugriff, die haben natürlich technisch überhaupt nichts miteinander zu tun. Und wenn ich

[5:50] jetzt aus Versehen beim Datenbankzugriff irgendwie einen Fehler mache, führt das eventuell später

[5:54] dann dazu, dass die Mail einen falschen Inhalt hat. Obwohl eigentlich beides voneinander getrennt

[5:59] sein sollte, losgelöst voneinander sein sollte und sich nicht gegenseitig irgendwie beeinflussen

[6:03] sollte. Zumindest nicht negativ. Kann ja sein, dass die Mail Inhalte aus der Datenbank braucht.

[6:07] Okay. Aber selbst dann würde ich das beides nicht in einer Methode verwursten, sondern eine Methode

[6:12] macht den Datenbankzugriff und irgendwelche Sachen, die da rauskommen, werden dann als Parameter

[6:16] meinetwegen an eine zweite Methode, die nur den Mail-Versand macht, dann übergeben meinetwegen.

[6:21] So habe ich dann beide technischen Sachen auseinandergehalten und kann zum Beispiel

[6:26] den Datenbankzugriff anpassen, ohne die Mail zu zerstören. Also man kann das auf beliebigen

[6:30] Ebenen definieren. Ich kann mir angucken, ob eine Klasse in sich konsistent ist, eine Methode,

[6:35] aber auch eine ganze Komponente oder ein ganzes Programm. Ein Programm, was einfach ganz viele

[6:39] verschiedene Aufgaben hat, ist vielleicht nicht ganz so gut. Und das sieht man ja heutzutage

[6:43] sogar bei der Architektur. Da wird es heute immer interessanter, mit diesen Microservices

[6:48] zu arbeiten. Und das ist ja im Prinzip genau das Gleiche auf Ebene eines ganzen Moduls,

[6:53] eines ganzen Programms. Ich habe einen einzelnen Microservice, der eine gewisse Fachlichkeit abbildet

[6:59] und die komplette andere davon losgelöste Fachlichkeit wird halt in anderen Microservices

[7:04] definiert und umgesetzt. Das heißt, hier habe ich also im Prinzip das gleiche Prinzip nur auf

[7:08] einer höheren Ebene, auf einer Architekturebene umgesetzt. Und was hat das für einen Vorteil?

[7:12] Wenn sich in dem einen Microservice was ändert, weil zum Beispiel irgendwo bei einem Datum ein

[7:17] Feld hinzukommt, dann hat das erstmal gar keine Auswirkungen auf irgendeine andere Komponente.

[7:21] Während ich, wenn ich zum Beispiel einen riesengroßen Monolithen habe, also ein Softwarekonstrukt,

[7:26] wo alles drin ist, ich dieses Feld in allen anderen Komponenten auf einmal auch zur Verfügung habe,

[7:31] obwohl die das vielleicht gar nicht brauchen. Oder noch schlimmer, sie brauchen es vielleicht

[7:36] nicht, aber dann fangen sie auf einmal an, daran rumzumanipulieren. Oder sie setzen irgendwie

[7:40] falsche Werte da rein, weil sie das Feld gar nicht kennen oder weiß der Geier was. Und auf

[7:44] einmal habe ich ein Feld in mein System eingeführt, weil ein Teilsystem das braucht. Es kann aber auch

[7:49] in allen anderen Komponenten auf einmal manipuliert werden. Und damit wird es natürlich

[7:53] wieder sehr, sehr fehleranfällig, was ich da gebaut habe. Und auch sehr schwer nachzuvollziehen,

[7:57] wenn dann irgendwie Fehler auftreten. Wie kann man jetzt erkennen, ob man dieses Single

[8:01] Responsibility Principle verletzt? Das kann man ganz pragmatisch einfach an Wörtern tatsächlich

[8:07] erkennen. Wenn ich zum Beispiel in Methodennamen oder in Variabennamen oder Klassennamen die

[8:12] Wörtchen und oder oder zum Beispiel benutze, dann macht das Ding offensichtlich mehr als es soll.

[8:18] Beispiel, wie würden wir die Methode von eben nennen mit dem Speichern und Mail-Versand?

[8:22] Wahrscheinlich speichere neuen Benutzer in Datenbank und verschicke Bestätigungs-Mail.

[8:28] Dann haben wir schon zwei Aufgaben in dieser Methode. Und das erkennen wir einfach an dem

[8:33] Wort und. Wohingegen, wenn ich das trennen würde, vielleicht in eine Methode speichere

[8:38] neuen Benutzer und das zweite informiere über neuen Benutzer oder sonst irgendwas,

[8:43] dann haben wir es sauber getrennt und es ist halt nicht mehr in einer Methode verwurstet.

[8:48] Bei Klassen findet man häufig andere Namen, anhand derer man das festmachen kann,

[8:52] wie zum Beispiel so ganz allgemeine generische Begriffe wie Manager oder Verwaltung. Das heißt,

[8:59] man hat eigentlich nicht so richtig eine Ahnung, was die Klasse alles macht. Manager oder vielleicht

[9:03] sogar, wenn man sich so ein bisschen an den Pattern orientiert, ein Repository. Repository

[9:08] hat eigentlich die Aufgabe, Entitäten in der Datenbank zu speichern oder daraus zu lesen.

[9:13] Aber wenn man es mal ganz hart nimmt, könnte man durchaus sagen, dass das Lesen von Objekten

[9:18] was ganz anderes ist, als das Speichern oder das Löschen. Das könnte man theoretisch auf

[9:23] mehrere Klassen verteilen. Aber es sollte mindestens für diese CRUD-Operationen jeweils

[9:27] eine Methode geben. Also nicht einfach eine Methode, wo man das Ding reinschmeißt und dann

[9:32] auch noch sagt, hier, das ist die Aktion, die du machen sollst. Am besten noch als String. Und dann

[9:36] macht die Methode einen riesen Switchcase und entscheidet, was sie tun soll. Da macht sie

[9:39] definitiv zu viel. Also wenn man sowas wie ein Repository hat, dann wenigstens auf Methodenebene

[9:44] die Aktionen voneinander trennen und nicht einfach alle eine Methode, die alles macht. Das ist keine

[9:50] gute Idee. Das heißt, wenn ich solche Namen in Klassen habe, Manager, Verwaltung, was auch immer,

[9:55] ja so ganz allgemeine Sachen, dann ist das häufig ein Zeichen dafür, dass das Ding einfach viel zu

[9:59] viel macht oder ich gar nicht so ganz genau weiß, was die eigentlich tun soll. Und das heißt dann

[10:04] auf Englisch, we're missing an abstraction. Das heißt, hier gibt es offensichtlich eine

[10:09] Abstraktion, die wir übersehen haben, die wir noch nicht erkannt haben. Wir haben hier einfach

[10:13] alles, was uns eingefallen ist, rund um das Management von Objekten in eine Klasse gepackt,

[10:18] anstatt zu gucken, was muss ich denn fachlich wirklich machen. Und dann zum Beispiel einen,

[10:22] ich weiß es nicht, Objektleser und einen Objektschreiber zu programmieren. Stattdessen

[10:27] mache ich dann eben den Objektmanager, der einfach beides macht. Und schon habe ich dieses

[10:31] Single Responsibility Principle verletzt. Ganz häufig sieht man eine Verletzung von diesem

[10:36] Prinzip, wenn man sich Klassen anguckt, die aus verschiedenen Schichten der Architektur Dinge tun,

[10:41] wie zum Beispiel eine Business-Logik-Klasse, die ganz nebenbei auch noch die Daten aus der

[10:46] Datenbank holt und sie in einer Oberfläche anzeigt. Das heißt, ich habe die Datenbank-Logik,

[10:50] die Geschäfts-Logik und die Anzeigelogik in einer Komponente verwurstet. Und das hat eine

[10:55] ganz starke Konsequenz, denn ich kann diese einzelnen Logik-Teile nie wiederverwerten.

[11:00] Die sind hart miteinander verdrahtet in einer Klasse. Wenn ich diese Klasse jetzt in einem

[11:04] anderen Projekt wiederverwende, habe ich automatisch die Abhängigkeit auf die

[11:07] Datenbank und die Anzeigelogik. Wenn ich jetzt meine Geschäfts-Logik hart zum Beispiel mit

[11:12] einer Web-Oberfläche verdrahte, dann kann ich diese Logik-Klasse halt nie wieder in

[11:15] einer Konsolen-Applikation benutzen, denn da gibt es keine Web-Oberfläche. Oder wenn ich an anderer

[11:20] Stelle die Daten aus einer Datenbank hole oder beziehungsweise nicht aus einer Datenbank hole,

[11:24] sondern aus einer Textdatei oder aus einem Web-Mail-Lade oder was auch immer, dann kann

[11:28] ich die Klasse auch nicht benutzen, denn sie erwartet ja eine Datenbank. Und das bedeutet,

[11:32] ich habe auch noch unterschiedliche Architektur-Ebenen in einer einzigen Klasse verwurstet

[11:37] und kann das deswegen nicht mehr trennen und de facto einfach nicht mehr wiederverwenden. Das ist

[11:43] ganz ganz schlecht. Wir wollen ja gerade so programmieren, dass wir nicht alles doppelt

[11:46] und dreifach machen, sondern Dinge, die wir schon fertig haben, erneut benutzen können,

[11:49] eben wiederverwenden können. Und das schaffen wir nicht, wenn meine Business-Logik hart an

[11:54] eine Oberfläche gebunden ist oder an eine Datenbank. Und das ist auch häufig ein riesen

[11:59] Problem in Legacy-Anwendungen. Kenne ich auch selber aus meinem Alltag. Unsere alten Komponenten,

[12:04] die funktionieren genau so. Die haben im Prinzip eine Lese-Schleife, die über die Datenbank läuft

[12:09] und mitten in der Schleife wird dann zum Beispiel ein Datensatz auf einer Oberfläche angezeigt. Das

[12:14] kann man sich wirklich so vorstellen, so laufe über die Datenbank für jeden Datensatz, mache

[12:18] ein bisschen Geschäftslogik und zeige das Ergebnis in der Oberfläche an. Das heißt,

[12:22] diese Komponente ist null wiederverwendbar. Ohne die Datenbank und ohne die Oberfläche

[12:26] funktioniert die gesamte Logik nicht. Und diese Komponente ist deswegen sowohl nicht

[12:31] wiederverwendbar als auch, und das kommt noch dazu, überhaupt nicht testbar. Denn ich kann

[12:36] zum Beispiel diese Logik gar nicht abprüfen ohne eine Datenbank. Allein um, was weiß ich,

[12:40] meinetwegen die Selektionslogik testen zu können, müsste ich eine Datenbank im Hintergrund haben,

[12:45] in der auch Daten stehen. Denn diese Komponente ist ja hart an die Datenbank gebunden. Und ich

[12:50] kann die im Test halt nicht einfach austauschen, weil die die eben benötigt, um überhaupt

[12:55] funktionieren zu können. Und dann für die Tests noch schlimmer eigentlich ist die Oberfläche. Denn

[12:59] die Oberfläche, ja, die erwartet dann teilweise sogar Benutzereingaben und bleibt stehen, solange

[13:03] bis der Benutzer was tut. Und das kann ich natürlich im Test überhaupt nicht haben. Ich

[13:07] will natürlich, dass das Ding ratzfatz durchläuft und nicht, dass irgendein Benutzer den Test auch

[13:11] noch durchklicken muss am besten. Das ist ja, da wird man ja wahnsinnig, ja. Das ist auch einfach,

[13:15] das ist weder automatisierbar noch irgendwie durch Menschen leistbar sowas. Und das will

[13:19] natürlich auch keiner machen. Die automatisierten Tests haben ja gerade den Vorteil, dass sie

[13:22] irgendwie dunkel im Hintergrund laufen müssen und können und nicht irgendwie durch den Menschen

[13:27] oder durchgeklickt werden. Also das ist ein Riesenproblem. Wenn ich mehrere Sachen miteinander

[13:31] verdrahte und dann auch noch aus verschiedenen Ebenen der Architektur, ja, dann sind sie weder

[13:37] wiederverwendbar noch testbar. Und das ist ganz, ganz schlecht. Ein krasses Gegenbeispiel oder

[13:42] sogenanntes Anti-Pattern zum Single-Responsibility-Principle wäre dann auch die sogenannte

[13:47] Gott-Klasse. Das ist halt eben eine Klasse, die alles kann und alles macht. Das heißt,

[13:52] ich habe in meinem Programm, können wir uns vorstellen, wenn ich Java programmiere,

[13:55] habe ich eine einzige Klasse und am besten habe ich eine einzige Main-Methode und da drin wird

[13:59] einfach alles gemacht. Die macht Datenbankzugriff, Logik, Ausgabe, alles in dieser einen Klasse.

[14:04] Das heißt, die weiß alles, die kann alles, die macht alles. Aber wenn ich diese Klasse anpacke

[14:09] und ich baue einen Fehler rein, dann geht am Ende einfach gar nichts mehr, weil ja die gesamte

[14:13] Gott-Klasse beeinträchtigt wird. Und das ist ganz, ganz schlecht und auch noch völlig untestbar,

[14:18] denn die einzelnen kleinen Logik-Bestandteile mittendrin in dieser Gott-Klasse kann ich

[14:23] unmöglich testen, ohne den ganzen anderen Rumsch, der noch mit dran hängt, auch mitzutesten. Das

[14:28] ist meistens unmöglich. Okay, das war das Single-Responsibility-Principle. Gehen wir

[14:33] nochmal kurz die Vorteile durch, aber auch nochmal einmal die Nachteile, die ich auch

[14:37] nicht unerwähnt lassen möchte. War auch ein kleiner Hinweis von einem Kommentar bei mir im

[14:42] Blog zu einer letzten Podcast-Episode. Gerne auch mal auf die Nachteile eingehen. Gerade bei

[14:46] Don't Repeat Yourself zum Beispiel wurde das als Kommentar dazu geschrieben. Das ist ja nicht immer

[14:50] der weiße letzter Schluss. Manchmal ist es auch sinnvoll, bewusst Sachen zu duplizieren. Ja,

[14:56] das ist richtig und das nehme ich mir hier jetzt gerne mal mit und gucke mir auch dann nochmal

[15:00] kurz die Nachteile an. Also Vorteile, wenn wir das Single-Responsibility-Principle einhalten,

[15:04] ist, dass die Klassen, Methoden, Variablen, insgesamt einfach Komponenten viel, viel kürzer

[15:09] und besser verständlich sind. Denn weniger Aufgaben heißt auch weniger zu tun und auch

[15:15] weniger Code in den einzelnen Komponenten. Also kurzer, präziser, knackiger, kohärenter Code.

[15:22] Das macht es viel besser verständlich und auch leichter anpassbar. Die Entwickler können

[15:27] Anpassungen an diesen Komponenten leichter durchführen und finden auch schneller die Stelle,

[15:32] wo sie was anpassen müssen. Denn es gibt ja nur eine Stelle, wo eine Änderung durchgeführt werden

[15:37] muss. Es ist also auch für das Auffinden von Stellen, die angepasst werden müssen, deutlich

[15:41] einfacher. Und für mich persönlich auch sehr, sehr wichtig, diese Komponenten sind viel einfacher

[15:46] zu testen. Die haben genau eine Aufgabe. Selbst wenn sie eine Abhängigkeit haben auf irgendwelche

[15:51] externen Systeme, dann mocken wir die halt raus und testen diese eine Funktionalität,

[15:55] die sie haben in Isolation. Das heißt, das Test-Setup ist auch viel, viel kleiner,

[15:58] als wenn ich jetzt, Beispiel von eben, für die Business-Logik mir erstmal eine gesamte

[16:02] Datenbank mocken muss und auch noch die Anzeigelogik. Da muss ich quasi mein komplettes

[16:06] System rausmocken, nur um eine winzig kleine Fitzeligkeit in der Business-Logik zu testen.

[16:12] Das ist ja ein mega Overhead für das Test-Setup und das wollen wir nicht. Stattdessen wollen wir

[16:17] das so haben, dass wir die Komponente individuell und isoliert von anderen testen können. Das heißt,

[16:22] sie soll nur eine Aufgabe haben und nicht noch 37 Sachen mitmachen, wie gerade eben den Mail-Versand

[16:27] müsste ich erstmal irgendwie überhaupt zur Verfügung stellen, damit die Klasse vielleicht

[16:30] beim Anlegen des Benutzers nicht abratzt. Vielleicht ist da ja irgendwie eine Exception

[16:34] geworfen, wenn die Mail nicht versendet werden konnte und auf einmal möchte ich meinen

[16:37] Datenbankzugriff testen und kriege eine Exception um die Ohren, weil irgendein Mail-Server nicht

[16:42] funktioniert. Und das hat natürlich auch auf die Verständlichkeit des Tests nachher eine

[16:45] riesen Auswirkung. Schlägt auf einmal mein Test fehl, mein Datenbank-Test schlägt fehl,

[16:50] weil ein Mail-Server nicht verfügbar ist. Wie passt das zusammen? Also, das wollen wir auf

[16:55] jeden Fall nicht. Und außerdem ist es so, dass beim Testen eigentlich immer zu viel Setup ein

[17:00] Problem ist. Das heißt, wenn ich ganz viele Abhängigkeiten habe, die ich erstmal bereitstellen

[17:03] muss, dann ist das ein Riesenproblem und aufwendig und schwer verständlich. Und ein

[17:08] gutes Beispiel sind irgendwie Mocks, die auf ihre, oder Stubs, die auf ihre Methoden aufrufen,

[17:13] mit anderen Stubs, die nochmal wieder irgendwie was Stubben oder Mocken antworten müssen,

[17:17] weil wir irgendwie riesengroße Objektkonstellationen aufbauen müssen, nur um eine kleine Fitzeligkeit

[17:22] zu testen. Und wenn wir sowas haben, wenn wir so einen komplexen Test-Setup haben,

[17:26] dann ist es meistens so, dass die Klasse, die wir eigentlich testen wollen, einfach viel zu

[17:30] viel macht, also das Single-Responsibility-Prinzip verletzt. Und jetzt komme ich noch kurz zu den

[17:36] Nachteilen. Die Konsequenz aus einem durchgezogenen SRP wäre ja, dass ich ganz viele kleine Dinge in

[17:43] meinem Programm habe. Ich habe ganz viele kleine Methoden in ganz vielen kleinen Klassen. Und das

[17:47] führt dazu, dass ich eventuell eine schlechtere Übersicht über das Gesamtsystem habe. Denn wo

[17:53] ich vorher vielleicht drei, vier Klassen hatte, habe ich jetzt auf einmal 30, 40. Und das zu

[17:56] verstehen ist natürlich dann für Menschen auch wiederum schwierig. Die einzelnen Komponenten

[18:01] gucke ich mir an und kann die sehr schnell verstehen und testen. Super. Aber das Zusammenspiel dieser

[18:06] ganzen kleinen Komponenten auf einer höheren Ebene, das wird dadurch vielleicht natürlich

[18:10] ein bisschen schwerer verständlich. Und da sollte man auf jeden Fall also entgegenwirken. Aber ich

[18:17] sage erst mal als Kernaussage, auf jeden Fall eher das SRP befolgen und möglichst viele kleine Dinge

[18:23] machen. Das hat sehr, sehr viele Vorteile. Und die mangelnde Übersichtlichkeit vielleicht, da kann

[18:28] man ja was tun. Da kann man zum Beispiel in Java wäre es vielleicht eine Package-Struktur oder in

[18:33] .NET eine Namespace-Struktur aufbauen mit unterschiedlichen Ordnern, wo die Sachen dann,

[18:37] die zusammengehören, auf einer höheren Ebene eben zusammenliegen, dass man sie findet. Man kann sich

[18:42] natürlich auch an Namenskonventionen halten. Und da habe ich dann zum Beispiel in modernen

[18:46] IDEs schnell die Möglichkeit, mit dem Shortcut bestimmte Sachen direkt aufzumachen, wenn ich

[18:50] weiß, ich brauche einen Benutzer-Controller meinetwegen. In Eclipse wäre es STRG-SHIFT-T,

[18:55] B, C eingeben und dann macht er mir den Benutzer-Controller auf. Also das heißt die

[19:01] Navigation und so weiter, das mache ich ja nicht mehr per Hand und suche mir da meine Dateien raus.

[19:04] Das machen die IDEs alles für mich. Und wenn ich im Dateisystem suche, dann hilft mir halt diese

[19:09] Package- oder Ordnerstruktur da weiter und insgesamt auch die Namenskonventionen. Wenn

[19:13] ich also nicht komische kryptische Abkürzungen für die Klassen nehme, sondern vernünftig

[19:16] ausgeschriebene lange Namen, dann finde ich auch durch eine vernünftige Suche, die jede

[19:20] IDI mitbringt, meine Komponenten relativ schnell wieder. Von daher, für mich ist das kein Grund,

[19:26] der dagegen spricht. Im Gegenteil, ich will auf jeden Fall kleine Komponenten. Das heißt,

[19:30] wenn ich dann eine Funktionalität suche, kann ich auch genau nach dieser Funktionalität suchen

[19:34] in meiner IDI. Und dann geht mir halt genau die eine Klasse auf, wo das drin ist. Und nicht das

[19:40] eine große Monster, wo ich dann noch irgendwie die 37. Methode suchen muss, wo das dann drin ist.

[19:44] Also kann sein, dass die Übersichtlichkeit leidet. Aber jetzt sind wir mal ganz ehrlich,

[19:49] da muss auch schon einiges zusammenkommen. Also in kleinen Projekten, ich sage mal bis zu 50

[19:53] Klassen, das sollte kein Problem sein. Das sollte man auch so im Kopf zusammenkriegen. Bei

[19:58] größeren Projekten, klar, wird das eventuell ein Problem. Aber mit Namenskonventionen und

[20:02] Strukturen auf Ordnerebene kann man da, glaube ich, gut entgegenwirken.

[20:06] Nächster Nachteil wäre allerdings, und das ist dann auch schon der letzte Nachteil,

[20:10] ich habe nur zwei, ja, wenn wir dazu übergehen, dass die Klassen immer nur

[20:13] eine Aufgabe haben, das heißt in sich kohärent sind, dann führt das automatisch

[20:18] dazu, dass die sogenannte Kopplung steigt. Denn eine Klasse kann nicht mehr alle

[20:23] ihre, also ihre Aufgaben schon, aber alle Aufgaben des Systems abbilden, sondern nur noch

[20:27] einen Teil des Ganzen. Um aber die übergeordnete Gesamtaufgabe umsetzen

[20:32] zu können, brauchen wir jetzt also mehrere kleine Komponenten, die

[20:35] miteinander zusammenarbeiten, die interagieren. Und das bedeutet, dass

[20:39] diese Klassen Abhängigkeiten auf andere Klassen haben, um eine Gesamtfunktionalität

[20:44] umzusetzen. Wenn ich also jetzt im Beispiel von eben meinen Benutzer, meinen

[20:48] neuen Benutzer anlege, dann brauche ich die Komponente, die mit der Datenbank

[20:51] redet und die Komponente, die mit der Mail, mit dem Mail-Server redet. Und dann

[20:55] brauche ich auch noch eine Komponente, die beide verdrahtet, weil die sollen sich ja

[20:58] nicht gegenseitig kennen. Das heißt, ich habe mehr Komponenten und die sind

[21:02] miteinander verbunden und hängen also auch von anderen Klassen eventuell ab.

[21:06] Und das führt dazu, dass da vielleicht auch die Testbarkeit ein bisschen

[21:09] schwieriger wird. Da brauchen wir dann nämlich genau solche Stubs und Mocks.

[21:13] Stellen wir uns einfach mal vor, die Datenbankklasse, wenn sie fertig ist

[21:18] mit der Speicherung, ruft die direkt die Mail-Klasse auf. Das würden wir so nicht

[21:22] machen, aber angenommen das wäre so, dann müssten wir halt diese Mail-Klasse, die

[21:26] da benutzt wird, im Test eben rausmocken oder rausstuben. Und das führt dazu, dass

[21:31] die Datenbankklasse selbst etwas schwieriger testbar ist, denn wir müssen

[21:35] ja diese externe Abhängigkeit eben im Test ersetzen durch so einen Stub oder

[21:39] einen Mock. Und das macht das Ganze etwas schwieriger zu testen, weil eben diese

[21:43] höhere Kopplung da ist. Eine Klasse alleine reicht nicht mehr, um meine

[21:48] Aufgabe zu lösen. Ich brauche mehrere Klassen im Zusammenspiel und dadurch

[21:52] wird eben auch diese Anwendung komplexer und eventuell auch schwieriger sogar zu

[21:56] testen in der Gesamtheit. Die einzelne Klasse alleine ist immer sehr, sehr

[22:01] einfach zu testen, weil die ja eine eine losgelöste Funktionalität hat, aber

[22:06] eben das System als Ganzes, da könnte es dann eben halt schwierig werden. Gut, das

[22:11] heißt, so die beiden wichtigen Dinge, die Kohäsion und die Kopplung, die bedingen

[22:17] sich immer gegenseitig. Wenn ich eine ganz, ganz hohe Kohäsion, ja nicht

[22:21] Kohärenzkohäsion heißt es, wenn ich eine ganz hohe Kohäsion habe, dann heißt das

[22:26] eigentlich automatisch, dass ich auch eine hohe Kopplung haben werde, denn ich

[22:30] kann als einzelne Klasse die Gesamtaufgabe nicht mehr abbilden.

[22:33] Aber eigentlich will ich immer eine kleine Kopplung haben, denn je mehr

[22:38] Klassen ich brauche, um meine Aufgabe zu erledigen,

[22:40] umso komplizierter wird dann halt auch eben der Test und umso fehleranfälliger

[22:45] wird das eben auch. Das heißt, ich möchte eigentlich eine hohe Kohärenz und eine

[22:49] kleine Kopplung, aber das ist meistens halt nicht möglich, deswegen brauche ich

[22:53] irgendwie einen Mittelweg. Ich möchte schon eine in sich geschlossene Klasse,

[22:58] ich will aber auch nicht zu viele Abhängigkeiten nach draußen haben. Also

[23:01] das ist genau unsere Aufgabe als Softwareentwickler, diese Entscheidungen

[23:05] zu treffen und dann im Zweifel eine Kopplung mehr einzubauen, damit die

[23:08] Kohärenz passt oder eben umgekehrt. Okay, ich weiß jetzt gerade gar nicht, ob ich

[23:12] am Anfang dieser Episode die ganze Zeit Kohärenz gesagt habe. Das ist irgendwie

[23:15] das falsche Wort. Also Kohäsion heißt das Ding. Auf Englisch Cohesion. Da wollen

[23:21] wir eine High Cohesion und Low Coupling. Das heißt, hohe Kohäsion und eine geringe

[23:27] Kopplung zu anderen Komponenten. Also wenn ich vorher Kohärenz gesagt habe,

[23:31] bitte vergessen, Cohesion, Kohäsion heißt dieser Fachbegriff. Wobei man laut

[23:36] englischem Wörterbuch auch Coherence für Bindigkeit, Zusammenhalt nehmen kann.

[23:42] Also von daher war der Vorhinein nicht ganz so falsch, aber in der Fachliteratur

[23:45] wird halt immer von Coupling und Cohesion gesprochen, also Kopplung und

[23:50] Kohäsion. So, das soll es jetzt zum ersten Prinzip des Solid Principles

[23:56] gewesen sein. Das Single Responsibility Principle, nochmal ganz knackig

[23:59] zusammengefasst, bedeutet, dass jedes Ding, jede Komponente, also jede Klasse,

[24:04] Methode, Variable, was auch immer, nur eine Aufgabe haben sollte, die sie erfüllt

[24:08] und nicht zu viele Dinge auf einmal tun soll.

[24:12] Das erhöht die Wiederverwendbarkeit, die Testbarkeit und insgesamt auch das

[24:17] Verständnis dieser Komponenten. Ein Nachteil ist eventuell, dass bei ganz

[24:21] vielen kleinen Komponenten die insgesamte Übersicht über unser Projekt

[24:26] oder unser Programm etwas leidet, aber im Großen und Ganzen überwiegen da ganz

[24:31] klar die Vorteile. Also für mich wäre es fast so wie das Dry Principle

[24:35] eigentlich anzuwenden, das SRP erstmal alles in sein eigenes kleines Modul

[24:41] packen und wenn man dann feststellt, es nimmt aber überhand und es sind zu

[24:44] viele, dann kann man ja immer noch nach oben hin irgendwie aggregieren, aber

[24:47] nachträglich Dinge wieder auseinander reißen, das ist sehr, sehr schwierig. Wie

[24:51] das Beispiel mit Datenbankzugriff, Anzeigelogik, Businesslogik in einem Modul

[24:55] verwurstet, das wieder sauber auseinanderzunehmen und die einzelnen

[24:59] Komponenten nachher zu bekommen, das wird ja fast unmöglich. Das sage ich dir

[25:03] anhand meiner langjährigen Erfahrung mit Legacy Software, die genauso aufgebaut

[25:07] ist. Das Gegenteil ist kein Problem, drei getrennte Komponenten zu einer

[25:12] großen zusammenzusetzen, kein Thema. Umgekehrt super, super schwierig und ganz

[25:16] fehleranfällig. Von daher SRP bitte beachten bei der täglichen Programmierung

[25:21] genau wie das Dry Prinzip eines der wichtigsten Prinzipien, wie ich

[25:28] finde bei der Softwareentwicklung. Gut, okay, das war es jetzt für heute für

[25:32] dieses dritte Wissenshäppchen. Ich hoffe es war ein bisschen was für dich dabei

[25:35] und auch was, was du in deinem täglichen Alltag bei der Programmierung anwenden

[25:39] kannst. Ich würde mich über deinen Feedback freuen. Ich habe noch in den

[25:42] Shownotes zur Episode ein paar Links hinterlegt, gerade auch zu dem Artikel

[25:46] oder zu dem ganzen Buchkapitel sogar von Ankel Bob zum Thema SRP, was man sich

[25:50] kostenlos im Internet anschauen kann. Guck doch mal vorbei unter

[25:52] anwendungsentwicklerpodcast.de slash wh3, also Wissenshäppchen 3, W und H

[26:00] bitte großgeschrieben und 3 einfach als Ziffer 3. Würde mich freuen, wenn du mir

[26:05] ein Feedback hinterlässt. Schau doch einfach mal vorbei und ansonsten freue

[26:07] ich mich natürlich auch eine Podcast-Bewertung von dir zu bekommen, zum

[26:11] Beispiel auf iTunes oder Stitcher oder wo du auch immer diesen Podcast hörst.

[26:15] Würde mich freuen, denn das trägt dazu bei, dass der Podcast noch ein bisschen

[26:18] bekannter wird und ich noch mehr Anwendungsentwicklern da draußen helfen kann.

[26:22] Damit mache ich jetzt für heute Schluss. Wir hören uns beim nächsten Wissenhäppchen

[26:26] wieder oder auch beim nächsten Anwendungsentwickler-Podcast.

[26:29] Würde mich freuen, wenn du wieder reinhörst.

[26:31] Bis dahin sage ich vielen Dank fürs Zuhören und bis zum nächsten Mal. Tschüss.

[26:45] Untertitel von Stephanie Geiges

Wissenshäppchen

You Ain’t Gonna Need It (YAGNI) – Wissenshäppchen #2 Open Closed Principle (OCP) – Wissenshäppchen #4
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.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert