Du interessierst dich für Software-Entwicklung?

Ich beantworte alle Fragen zum Thema Software-Entwicklung.

Möchtest du regelmäßig über neue Antworten in meinem Blog informiert werden?

Abonniere meinen Newsletter!

9. Mai 2019

Was ist das Decorator Design Pattern?

Ein Decorator (deutsch Dekorierer) ist ein Structural Design Pattern mit dem man bestehende Software-Komponeten flexibel um zusätzliches Verhalten ergänzen kann - ohne dabei die Komponente selbst verändern zu müssen. Man spricht dabei häufig von einem Wrapper (deutsch Hülle oder Umschlage).

Das Decorator Design Pattern wird klassisch für Klassen bzw. Objekte formuliert. Allerdings lässt sich das Decorator Design Pattern auch auf Funktionen anwenden und sogar als ein grundlegendes Refactoring nutzen. Durch das Dekorieren von Funktionen können z.B.

  • neue Varianten einer Funktionen inkrementell entwickelt werden,
  • Testfälle elegant in den bestehenden Code eingebunden werden,
  • Programm-Aspekte entkoppelt werden (Transaktionen, Logging, Konsistenzprüfungen, etc.),
  • Vor- und Nachbedingungen geprüft werden,
  • Funktionalitäten in andere Komponeten verlagert werden.

Es ist natürlich auch möglich, einen Dekorierer selbst zu dekorieren. Dadurch kann eine Schichten-Struktur geschaffen werden, die orthogonale Funktionalitäten entkoppelt. Die einzelnen Funktionalitäten können dann isoliert getestet oder selektiv genutzt werden.

8. Mai 2019

Was sind Design Patterns?

Design Patterns (deutsch: Entwurfsmuster) sind "Musterlösungen" für typische Entwurfsaufgaben in der (objekt-orientierten) Software-Entwicklung. Design Patterns sind also wiederverwendbare Vorlagen zur Problemlösung, die unter bestimmten Voraussetzungen einsetzbar sind. Der Begriff wurde vom Architekten Christopher Alexander geprägt und später in der Software-Entwicklung wieder aufgegriffen.

7. Mai 2019

Was ist Refactoring?

Entsprechend des Standardwerks von Martin Fowler (Refactoring, 1999) ist ein Refactoring eine Strukturverbesserung unter Beibehaltung des beobachtbaren Verhaltens. Durch ein Refactoring wird ein Programm-Code also “nach außen” hin nicht verändert, sondern “nach innen” so verändert, dass der Code einfacher, lesbarer und besser verständlich wird. Dadurch kann der Code einfacher verändert, korrigiert und erweitert werden.

Bekannte und häufig eingesetzte Refactorings sind:

  • Variablen umbenennen
  • Funktion extrahieren
  • Methode verschieben
  • Datenattribut kapseln
  • Funktionsparameter hinzufügen
  • Klasse extrahieren
  • Interface extrahieren

Während moderne IDEs einfache Refactorings unterstützen, müssen komplexere Refactorings manuell durchgeführt werden. Außerdem hat es sich bewährt, komplexere Refactorings aus einfachen zusammenzusetzen.

7. Mai 2019

Was ist Clean Code?

Ebenso wie es unterschiedliche “Definitionen” für Legacy Code gibt, gibt es auch unterschiedliche “Definitionen” für den Begriff Clean Code:

  • Code, der einfach zu verstehen ist
  • Code, der einfach zu warten ist
  • “Schöner” Code
  • Code, mit hoher Abdeckung durch (automatisierte) Tests
Als Clean Code kannst du jeden Programm-Code bezeichnen, der mit geringem Aufwand stabil verändert werden kann.

6. Mai 2019

Was ist Legacy Code?

Es gibt unterschiedliche “Definitionen” für den Begriff Legacy Code:

  • Code, der zu einer älteren Software-Version gehört
  • Code, der von einem anderen Entwickler geschrieben wurde
  • Code, der in einer nicht mehr unterstützten Programmiersprache entwickelt wurde
  • Code ohne (automatisierte) Tests
Als Legacy Code kannst du jeden Programm-Code bezeichnen, der nur mit erheblichem Aufwand verändert werden kann. Tatsächlich kann jeder Programm-Code morgen schon Legacy Code sein!

3. Mai 2019

Was ist Test-Driven Development?

Aufgrund der natürlichen Komplexität von Software, sind alle Änderung potentiell riskant. Während einfache (Syntax-)Fehler bereits durch den Compiler oder eine statischen Codeanalyse entdeckt werden können, müssen logische Fehler, die erst zur Laufzeit auftreten, durch geeignete Tests gefunden werden.

Grundsätzlich muss jede Code-Änderung nach dem gleichen Rhythmus erfolgen: Testen -> Ändern -> Testen. Vor jeder Änderung muss der betroffenen Code also ausreichend getestet sein und ohne Fehler durchlaufen. Soll das Verhalten verändert werden, müssen zuerst die entsprechenden Tests angepasst bzw. erstellt werden. Nun erfolgen die Änderungen so, dass wieder alle Tests ohne Fehler durchlaufen.

Dieses Vorgehen wird als Test-Driven Development bezeichnet. Alternative Bezeichnungen sind testgetriebene Entwicklung, Test-Driven Design, Test-First oder kurz TDD.

Um diesen Rhythmus durchhalten zu können, müssen Tests schnell gehen und idealerweise in allen Testphasen automatisiert stattfinden.

Während umfangreiche Refactorings selbst durch geeignete Testfälle abgesichert werden müssen, sind grundlegende Refactorings erforderlich, um den Code testbar zu machen und geeignete Tests zu entwickeln.

30. April 2019

Warum ist Legacy Code problematisch?

Lebendige Software muss ständig verändert und weiterentwickelt werden:

  • Fehler müssen behoben werden
  • Die Software soll schneller laufen
  • Kunden bestellen neuen Funktionalitäten
Der Änderungsaufwand von Legacy Code ist unnötig hoch. Dadurch steigen entweder die Kosten oder die Softwarequalität leidet.

29. April 2019

Welche Vorteile hat Clean Code?

Da Clean Code einfach geändert werden kann, bleibt der Änderungsaufwand gering. Dadurch wird unnötiger Druck auf die Entwickler vermieden und die Kunden bleiben zufrieden dank weniger Fehler.

Da der Änderungsaufwand für Kundenanforderungen geringer ist, kann die Software weiter systematisch optimiert werden, d.h. Clean Code kann Clean Code bleiben.

25. April 2019

Wie kann man Legacy Code erkennen?

Als Entwickler erkennst du Legacy Code anhand folgender Eigenschaften:

  • Keine (automatisierten) Tests
  • Code ist unübersichtlich
  • Code wurde bereits seit längerem nicht geändert („Never touch a running system”)
  • Code ist schwer zu verstehen
  • Namen von Variablen und Funktionen sagen nichts über deren Bedeutung aus

24. April 2019

Welche Design Patterns gibt es?

Klassisch werden folgenden Arten von Design Patterns für objekt-orientierte Software unterschieden:

Creational Patterns (deutsch: Erzeugungsmuster): Creational Patterns dienen der Erzeugung von Software-Objekten und helfen die Erzeugung von Objekten von seiner konkreten Implementierung zu entkoppeln, indem die Erzeugung der Objekte mit Hilfe von Schnittstellen ausgelagert und gekapselt wird.

Structural Patterns (deutsch: Strukturmuster): Structural Patterns vereinfachen die Struktur von Software. Komplexe Abhängigkeiten zwischen Software-Komponenten werden durch die Definition geeigneter Schnittstellen verringert. Structural Patterns wirken damit "statisch".

Behavioral Patterns (deutsch: Verhaltensmuster): Behavioral Patterns helfen komplexes Verhalten der Software zu vereinfachen. Das Verhalten der Software kann zur Laufzeit verändert werden, indem entsprechende Objekte übergeben werden. Behavioral Patterns wirken damit "dynamisch".

24. April 2019

Welche Eigenschaften hat Clean Code?

Eine gute Definition für Clean Code wird von Robert C. Martin in seinem Buch Clean Code (2009) gegeben. Neben grundlegende Regeln für die Benennung und Struktur von Variablen und Funktionen erfüllt Clean Code die folgenden fünf Prinzipien:

  • Single responsibility principle (SRP)
  • Open/closed principle (OCP)
  • Liskov substitution principle (LSP)
  • Interface segregation principle (ISP)
  • Dependency inversion principle (DIP)

23. April 2019

Wie kann man Legacy Code zu Clean Code machen?

Die Weg von Legacy Code zu Clean Code führt nur über eine Kombination von Refactoring und Test-Driven Development (testgetriebener Entwicklung). Dabei wird bestehender (Legacy) Code im ersten Schritt durch kleine Refactorings (lokal) testbar gemacht. Sobald eine ausreichende Testabdeckung gewährleistet ist, überführt man den Code durch Refactorings schrittweise in Clean Code. Dadurch können zukünftige Änderungen einfacher umgesetzt werden.

17. April 2019

Wie entsteht Legacy Code?

Legacy Code entsteht nicht überraschend, sondern immer schleichend und über einen langen Zeitraum hinweg. Entscheidend ist dabei, dass die Anforderungen des Herstellers nicht geeignet definiert und konsequent überprüft werden. Tatsächlich gibt es kaum einen Software-Hersteller, der seine eigenen Anforderungen an die Software bewußt steuert.

Stehen aber “nur” die Kundenanforderungen im Fokus, dann ist schnell keine Zeit für mehr für gute Softwarequalität. Und dann entsteht Legacy Code.

16. April 2019

Welche Vorteile haben Design Patterns?

Design Patterns sind hilfreich, weil sie Software-Architekten, -Designern und -Entwicklern allgemeine Lösungen in umsetzbarer Form bieten. Daneben dokumentieren Design Patterns wertvolles Wissen basierend auf tatsächlich erfoglreichen Ergebnissen. Außerdem bilden Design Patterns eine gemeinsamen Sprache in der objekt-orientierten Software-Entwicklung.

Design Patterns vereinfachen:

  • eine Software und erhöhen deren Wartbarkeit (Änderung, Erweiterung und Korrektur).
  • die Software-Entwicklung, da typische Aufgaben schneller und besser gelöst werden können.
  • die Kommunikation im Software-Entwicklungs-Team.
  • das Verständnis erhöhen die Verständlichkeit des Programm-Codes durch bekannte Strukturen und Bezeichnungen.

In der Konsequenz wir Software durch die Anwendung von Design Patterns flexibel, stabil sowie wart-, änder- und erweiterbar. Zudem erhöht sich die Wiederverwendbarkeit und Wiederverwendung von Software-Komponenten.

Newsletter

Melde dich für meinen Newsletter an, um über neue Beiträge in meinem Blog auf dem Laufenden zu bleiben.