Was ist Clean Code?

Clean Code bezieht sich auf den Ansatz, Code so zu schreiben, dass er leicht verständlich, wartbar und erweiterbar ist. Das Konzept wurde von Robert C. Martin, auch bekannt als „Uncle Bob“, in seinem Buch „Clean Code: A Handbook of Agile Software Craftsmanship“ populär gemacht. Im Kern geht es darum, Softwareentwicklung als Handwerk zu betrachten und stets auf hohe Qualität und Präzision in der Codegestaltung zu achten.

Warum ist es wichtig?

Sauberer Code bietet verschiedene Vorteile, sowohl für den Entwickler selbst, für das gesamte Team und meiner Meinung nach auch für die ganze Welt.

• Verständlichkeit: Clean Code ist einfacher zu lesen und zu verstehen. Das hilft Entwicklern, sich schneller mit dem Code vertraut zu machen und Fehler oder Verbesserungsmöglichkeiten schneller zu erkennen.
• Wartbarkeit: Sauberer Code ist leichter zu warten, da er klar strukturiert und weniger anfällig für Fehler oder unerwartete Probleme ist.
• Effizienz: Da Clean Code einfacher zu verstehen ist, kann das Team schneller arbeiten und die Produktivität steigt.
• Zusammenarbeit: Ein sauberer Code erleichtert die Zusammenarbeit im Team, da jeder den Code anderer Entwickler leichter lesen und verstehen kann.

Prinzipien von Clean Code

Es gibt viele Prinzipien und Praktiken, die beim Schreiben von sauberem Code helfen können. Einige der wichtigsten sind:

• Lesbarkeit: Der Code sollte leicht lesbar und verständlich sein. Das bedeutet, dass man Variablen, Funktionen und Klassen sinnvoll benamt und ihre Funktion leicht erkennbar ist. Kommentare setzt man sparsam ein, um den Code nicht zu überfrachten.

• Einfachheit: Man hält den Code so einfach wie möglich, ohne unnötige Komplexität oder Verwirrung. Das bedeutet, dass man sich auf das Wesentliche konzentrieren und abstrakte Konzepte wie Design Patterns oder Funktionen nur verwendet, wenn sie tatsächlich nützlich sind.

• Modularität: Man teilt den Code in kleine unabhängige Module auf, die jeweils eine bestimmte Funktion erfüllen. Dadurch wird der Code leichter zu verstehen und zu warten.

• Wiederverwendbarkeit: Man schreibt den Code so, dass die Wiederverwendbarkeit gewährleistet ist. Dies bedeutet, dass Funktionen oder Klassen, die eine bestimmte Aufgabe erfüllen, generisch genug sind, um in verschiedenen Situationen Verwendung zu finden.

Clean Code in der Praxis

Hier sind einige konkrete Schritte, die man beim Schreiben von Clean Code in der Praxis beachten sollte:

• Variablen-, Funktions- und Klassennamen: Man wählt sinnvolle, beschreibende Namen, die klar machen, was eine Variable, Funktion oder Klasse macht. Die Vermeidung von Abkürzungen oder unverständliche Namen ist eines der obersten Gebote.

• Single Responsibility Principle (SRP): Jede Funktion oder Klasse sollte nur eine einzige Verantwortung haben. Dies bedeutet, dass sie nur einen Aspekt des Problems lösen sollte, um den Code einfacher und leichter zu warten.

• Funktionen und Methoden: Man hält Funktionen und Methoden kurz und konzentrieren sich darauf, dass sie eine einzige Aufgabe erfüllen. Eine Funktion oder Methode sollte in der Regel nicht länger als 20 Zeilen sein, um ihre Verständlichkeit zu gewährleisten.

• KISS (Keep It Simple, Stupid) Prinzip: Man versucht, den Code so einfach wie möglich zu halten und unnötige Komplexität zu vermeiden. Wenn es eine einfachere Lösung gibt, zieht man diese der komplexeren vor.

• Don’t Repeat Yourself (DRY) Prinzip: Man vermeidet doppelten Code, indem man wiederverwendbare Funktionen oder Klassen erstellt. Das verringert die Wahrscheinlichkeit von Fehlern und macht den Code leichter zu warten.

• Code-Kommentare: Man sollte Kommentare dazu verwenden, den Zweck und die Funktionsweise von Code-Teilen zu erläutern, die nicht sofort offensichtlich sind. Man sollte jedoch nicht zu viele Kommentare schreiben, da dies den Code unübersichtlich machen kann.

• Fehlerbehandlung: Die Implementierung einer angemessenen Fehlerbehandlung sollte unabdingbar sein, um unerwartete Probleme zu erkennen und angemessen darauf zu reagieren. Die Verwendung von Exceptions und try-catch-Blöcken, kann eine gute Lösung darstellen, um Fehler abzufangen und entsprechend darauf zu reagieren.

• Testgetriebene Entwicklung (TDD): Man schreibt zuerst Tests, bevor man den eigentlichen Code entwickelt. Auf diese Weise kann man sicherstellen, dass die Implementierung den gewünschten Anforderungen entspricht und weniger fehleranfällig ist. Siehe hierzu meinen Beitrag über Test Driven Development.

• Kontinuierliche Integration (CI) und Continuous Deployment (CD): Man verwendet CI/CD-Tools, um den Code regelmäßig zu testen und automatisch zu deployen. Dies stellt sicher, dass der Code immer auf dem neuesten Stand ist und das man potenzielle Probleme schnell erkennen kann.

Fazit

Im Grunde genommen ist dies für mich eine relativ neue Angelegenheit, da ich in der Vergangenheit schon recht of den Code einfach reingehackt habe, da ich mich unter Zeitdruck gefühlt habe. Ich ertappe mich hin und wieder immer noch dabei und dies sehr oft, wie ich auf alte Gewohnheiten und Muster zurückgreife. Doch dies sollte sich hoffentlich in den nächsten Monaten und Jahren auf ein Minimum reduzieren lassen. Ich bin davon überzeugt, dass Clean Code ein wesentlicher Bestandteil einer erfolgreichen Softwareentwicklung ist. Indem man sich auf Lesbarkeit, Einfachheit, Modularität und Wiederverwendbarkeit konzentriert, kann man den eigenen Code nicht nur leichter verstehen, sondern auch schneller und effizienter arbeiten. Durch die Anwendung der oben genannten Prinzipien und Praktiken kann man den Code verbessern und letztendlich zu erfolgreichen, wartungsfreundlichen Softwareprodukten beitragen.

Der Beitrag Clean Code – Elegante Lösungen für effiziente und wartungsfreundliche Software erschien zuerst auf CEOsBay.

Definition

Der Begriff wurde zum ersten Mal in einer Arbeit von Ralph Johnson und William Opdyke 1990 gebraucht (Refactoring: An aid in designing application frameworks and evolving object-oriented systems. In: Proceedings of Symposion on Object-Oriented Programming Emphasizing Practical Applications (SOOPPA), September 1990). Opdyke promovierte 1992 zu dem Thema. Sie entwickelten die Idee einer Software-Refactory, die das Umgestalten (eben das Refactoring) von Computerprogrammen erleichtern sollte. Die unzutreffende Übersetzung Refaktorisierung stammt aus einer Verwechslung mit einer häufig zitierten Analogie, die ursprünglich nicht Begriffsinhalt war: Refactoring ist eine Art, ein Programm so zu modifizieren, dass man verborgene Strukturen offenlegt, ohne die Funktionalität zu ändern. Dies, so der (fälschliche) Analogieschluss, entspreche dem Vorgehen der Faktorisierung von Polynomen in der Mathematik. Bin aber kein Mathematiker 😉

Warum ist Refactoring wichtig?

• Verbesserung der Code-Lesbarkeit: Lesbarkeit ist entscheidend, um den Code effizient zu warten und zu erweitern. Durch das Refactoring können Entwickler den Code vereinfachen, Duplikate entfernen und konsistente Benennungen und Formatierungen verwenden, um die Lesbarkeit zu verbessern.
• Reduzierung der technischen Schulden: Technische Schulden entstehen, wenn man die Software in Eile entwickelt, ohne auf Qualitätsstandards zu achten. Sie führen oft zu schwer zu wartendem und unzuverlässigem Code. Es hilft, technische Schulden zu reduzieren und verhindert, dass sie sich im Laufe der Zeit anhäufen.
• Optimierung der Code-Wartbarkeit: Refactoring hilft dabei, den Code modular und gut strukturiert zu halten, was die Wartung und Fehlerbehebung erleichtern kann.
• Verbesserung der Code-Performance: Durch das Entfernen von unnötigem Code und die Optimierung von Algorithmen kann Refactoring dazu beitragen, die Performance der Software zu steigern.
• Erleichterung der Teamarbeit: Ein sauberer und gut strukturierter Code ist leichter zu verstehen und ermöglicht eine effektivere Zusammenarbeit zwischen Entwicklern.

Strategien für effektives Refactoring

• Code Smells identifizieren: „Code Smells“ sind Anzeichen dafür, dass man den Code möglicherweise verbessern muss. Beispiele sind lange Methoden, große Klassen, doppelter Code und unklare Benennungen. Entwickler sollten diese Anzeichen erkennen und entsprechende Maßnahmen ergreifen, um den Code zu verbessern.
• Schrittweise Verbesserungen vornehmen: Refactoring sollte schrittweise erfolgen, um den Code schrittweise zu verbessern und gleichzeitig die Funktionalität intakt zu halten.
• Automatisierte Tests verwenden: Um sicherzustellen, dass die Funktionalität nach dem Refactoring unverändert bleibt, ist es entscheidend, automatisierte Tests zu verwenden. Dies stellt sicher, dass Änderungen am Code keine unerwünschten Nebenwirkungen verursachen.
• Konsistente Coding-Standards einhalten: Ein konsistenter Codierungsstil erleichtert das Lesen und Verstehen des Codes. Es ist wichtig, dass das gesamte Team die gleichen Standards einhält, um Inkonsistenzen zu vermeiden.
• Regelmäßiges Refactoring betreiben: Man Refactoring als fortlaufenden Prozess betrachten, der in die tägliche Arbeit eines Entwicklers integriert ist. Regelmäßiges Refactoring hilft dabei, den Code kontinuierlich sauber und auf dem neuesten Stand zu halten, wodurch man die langfristige Wartbarkeit der Software verbessern kann. Außerdem hilft es dabei, den Code zu besser verstehen und tiefere Erkenntnisse über das Programmieren selbst zu erhalten.

Beliebte Refactoring-Techniken

1. Extract Method: Wenn eine Methode zu lang oder zu komplex ist, kann sie in kleinere, gut definierte Methoden aufgeteilt werden, um die Lesbarkeit und Wartbarkeit des Codes zu verbessern.
2. Rename Variable/Method/Class: Durch das Umbenennen von Variablen, Methoden und Klassen in klarere und aussagekräftigere Namen kann man den Code verständlicher und leichter pflegbar machen.
3. Remove Duplication: Duplikate im Code können Wartungsprobleme verursachen und man sollte sie entfernen. Bei der Erkennung von Duplikaten können Entwickler allgemeine Funktionen extrahieren und wiederverwenden, um den Code zu straffen.
4. Replace Conditional with Polymorphism: Anstatt mehrere bedingte Anweisungen zu verwenden, kann man Polymorphismus eingesetzen, um den Code besser zu strukturieren und die Lesbarkeit zu erhöhen.
5. Encapsulate Field: Durch das Kapseln von Feldern in Klassen und die Bereitstellung von Zugriffs- und Mutationsmethoden kann man den Code modularer und besser wartbar machen.

Tools und Programme

Es gibt eine Vielzahl von Tools und Programmen, die Entwicklern beim Refactoring helfen. Nachfolgend sind einige der gängigsten Tools für verschiedene Programmiersprachen (Einige davon habe ich bereits in diversen Beiträgen thematisiert. Hierzu einfach auf die jeweiligen Verlinkungen klicken oder die Suchfunktion verwenden 😉 ):

Integrated Development Environments (IDEs): Viele moderne IDEs bieten integrierte Refactoring-Unterstützung für verschiedene Programmiersprachen an. Einige der bekanntesten sind:

a. JetBrains IntelliJ IDEA (Java, Kotlin, Scala, u.a.)

b. JetBrains PhpStorm (PHP)

c. JetBrains PyCharm (Python)

d. JetBrains ReSharper (C# in Visual Studio)

e. Microsoft Visual Studio (C#, C++, VB.NET)

f. Eclipse (Java)

g. Xcode (Swift, Objective-C)

Standalone-Tools: Es gibt auch eigenständige Refactoring-Tools, die man unabhängig von der IDE verwenden kann. Einige Beispiele sind:

a. JDeodorant (Java)

b. SonarLint und SonarQube (Java, JavaScript, TypeScript, u.a.)

c. JSLint und ESLint (JavaScript)

d. RuboCop (Ruby)

e. Clang-Tidy (C++, Objective-C)

Code-Editor-Erweiterungen: Viele Code-Editoren, wie Visual Studio Code und Sublime Text, verfügen über Erweiterungen, die Refactoring-Unterstützung für verschiedene Programmiersprachen bieten. Einige dieser Erweiterungen sind:

a. Visual Studio Code Refactoring Extensions (z.B. Python, JavaScript, TypeScript, PHP, Ruby, C#)

b. Sublime Text Refactoring Plugins (z.B. Anaconda für Python, JsPrettier für JavaScript)

Es ist wichtig zu beachten, dass jedes Tool seine eigenen Stärken und Schwächen hat. Ein Entwickler sollte die verfügbaren Optionen für seine Programmiersprache und seinen Arbeitsablauf sorgfältig prüfen, um das am besten geeignete Refactoring-Tool zu finden.

Fazit

Refactoring ist ein wesentlicher Bestandteil des Softwareentwicklungsprozesses, der es ermöglicht, den Code sauber, lesbar und wartbar zu halten. Durch das Identifizieren von „Code Smells“, die Anwendung bewährter Techniken und das kontinuierliche Integrieren von Refactoring in den Arbeitsablauf können Entwickler qualitativ hochwertigen Code schreiben, der leicht zu verstehen und zu erweitern ist.

Die Investition in regelmäßiges Refactoring zahlt sich langfristig aus, indem sie dazu beiträgt, die technischen Schulden zu reduzieren und die Zusammenarbeit im Team zu verbessern. Der Schlüssel zum erfolgreichen Refactoring liegt in der Kombination aus automatisierten Tests, konsistenten Codierungsstandards und einem proaktiven Ansatz zur Code-Optimierung. Durch die Priorisierung von Refactoring in der Softwareentwicklung können Entwickler sicherstellen, dass ihre Projekte skalierbar und zukunftssicher sind.

Der Beitrag Refactoring – Optimierung und Evolution für nachhaltigen Code erschien zuerst auf CEOsBay.

Die verhaltensgetriebene Entwicklung kombiniert die allgemeinen Techniken und Prinzipien von TDD. Unter Anderem auch mit Ideen aus dem bereichsgetriebenen Design, der objektorientierten Analyse und dem objektorientierten Design, um Softwareentwicklungs- und Managementteams gemeinsame Tools und einen gemeinsamen Prozess für die Zusammenarbeit bei der Softwareentwicklung zur Verfügung zu stellen.

So wie man die Softwareentwicklung sowohl von geschäftlichen Interessen als auch von technischem Verständnis voranbringt, setzt die BDD-Praxis den Einsatz spezieller Softwaretools zur Unterstützung des Entwicklungsprozesses voraus. Obwohl man diese Tools oft speziell für den Einsatz in BDD-Projekten entwickelt, kann man sie als spezialisierte Formen der Tools zur Unterstützung der testgetriebenen Entwicklung betrachten. Diese Tools dienen dazu, die allgegenwärtige Sprache, die ein zentrales Thema von BDD ist, zu automatisieren.

BDD wird weitestgehend durch die Verwendung einer einfachen domänenspezifischen Sprache (DSL = Domain-Specific-Language) mit natürlichen sprachlichen Konstrukten (z.B. deutsch- oder englischsprachige Sätze) erleichtert, mit denen man das Verhalten und die erwarteten Ergebnisse ausdrückt. Testskripte sind seit langem eine beliebte DSLs mit unterschiedlichem Grad an Raffinessen. BDD gilt als effektive technische Praxis, insbesondere wenn der „Problemraum“ des zu lösenden Geschäftsproblems komplex ist.

Wie funktioniert BDD?

Im Grunde genommen besteht Behavior Driven Development aus den folgenden Elementen:

• Starke Einbeziehung der Stakeholder in den Prozess durch sogenannte Outside-In-Softwareentwicklung. Diese ist fokussiert auf die Erfüllung der Anforderungen der Auftraggeber, der Enduser, des Betriebs und von Insidern.
• Textuelle Beschreibung des Verhaltens der Software und von Softwareteilen durch Fallbeispiele. Verwendung genormter Schlüsselwörter zur Markierung von Vorbedingungen, des externen Verhaltens und des gewünschten Verhaltens der Software.
• Automatisierung der Fallbeispiele unter Verwendung von Mock-Objekten zur Simulation von noch nicht implementierten Softwareteilen.
• Sukzessive Implementierung der Softwareteile und dem Ersetzen der Mock-Objekte.

Dadurch entsteht eine automatisiert prüfbare Beschreibung der zu entwickelnden Software, die jederzeit die Richtigkeit der bereits umgesetzten Teile der Software überprüfen lässt.

Wichtig ist hierbei, dass die Beschreibung nicht die Implementierung der Anwendung vorgibt, sondern den Zweck der Anwendung in Form von Anwendungsbeispielen.

Beim Behavior Driven Development werden die Anforderungen an die Software mittels Beispiele, sogenannten Szenarien beschrieben. Üblicherweise wird für die Beschreibung dieser Szenarien ein bestimmtes Format vorgegeben, damit später die automatisierte Überprüfung der Szenarien einfach umzusetzen ist. Eines dieser Formate ist die Beschreibungssprache „Gherkin“. Man kann es auch in verschiedenen Behavior-Driven-Development-Implementierungen verwenden. Diese Sprache gibt es sowohl mit englischen Schlüsselwörtern (Given, When, Then, And, …), deutschen (Gegeben, Wenn, Dann, Und, …) und in weiteren Sprachen. Mehr dazu in meinem Beitrag über Cucumber bzw. Gherkin.

Fazit

Behavior Driven Development (BDD) ist eine agile Softwareentwicklungs-Methode, die sich auf die Zusammenarbeit zwischen Entwicklern, Business Analysten und Kunden konzentriert, um sicherzustellen, dass die erstellte Software den Bedürfnissen der Anwender entspricht. BDD ist eine Erweiterung des Test Driven Developments (TDD) und legt den Schwerpunkt auf die Definition von klaren, verständlichen Anforderungen und Tests, die das Verhalten der Anwendung aus der Perspektive des Nutzers beschreiben. Durch die Verwendung von gemeinsamer Sprache und konkreten Beispielen kann man die Kommunikation zwischen den Stakeholdern verbessern und Missverständnisse vermeiden. Das Ergebnis ist eine höhere Qualität der Software, eine schnellere Markteinführung und eine höhere Kundenzufriedenheit.

Der Beitrag BDD – Behavior Driven Development – Software, die den Anforderungen der Kunden entspricht erschien zuerst auf CEOsBay.

Kurze Zeitreise

CSS (Cascading Style Sheets) entstand in den 90er Jahren als Reaktion auf die wachsende Komplexität des Webdesigns und das Bedürfnis, eine klarere Trennung zwischen Inhalt (HTML) und Gestaltung (CSS) zu erreichen. Bis dahin verwendeten Webdesigner und Entwickler hauptsächlich HTML-Tags und -Attribute, um das Design einer Webseite zu kontrollieren. Diese Praxis führte jedoch zu unübersichtlichem und schwer wartbarem Code und schränkte die kreativen Möglichkeiten ein.

Der norwegische Informatiker und Web-Pionier Håkon Wium Lie ist der Hauptentwickler von Cascading Style Sheets. Zusammen mit dem belgischen Informatiker Bert Bos schlug er 1994 die Idee von CSS vor. Lie arbeitete zu dieser Zeit am CERN (der Europäischen Organisation für Kernforschung) und war am Projekt beteiligt, das zum ersten Webbrowser führte, dem WorldWideWeb (später umbenannt in Nexus). Lie und Bos erkannten, dass man eine Lösung für das Design-Problem finden musste, und entwickelten das Konzept der Cascading Style Sheets.

Später übernahm World Wide Web Consortium (W3C) Cascading Style Sheets. Eine internationale Organisation, die Webstandards entwickelt und pflegt. Das W3C veröffentlichte CSS Level 1 (CSS1) im Jahr 1996. Relativ schnell nahm man es als Webstandard auf. Seitdem hat sich Cascading Style Sheets stetig weiterentwickelt und umfasst mittlerweile mehrere Versionen und Module, die unterschiedliche Aspekte des Webdesigns abdecken.

Die Syntax von CSS

Ein CSS besteht aus Regelsätzen, die jeweils aus einem Selektor und einer Deklaration bestehen. Der Selektor bestimmt, auf welche Elemente man die Stilregeln anwendet, während die Deklaration eine oder mehrere Eigenschaften und deren Werte definiert, die man auf die ausgewählten Elemente angewenden möchte.

Beispiel:

h1 {
  color: red;
  font-size: 24px;
}

Selektoren

Selektoren sind die grundlegenden Bausteine eines CSS-Stylesheets. Sie bestimmen, welche HTML-Elemente von den definierten Stilregeln betroffen sind. Es gibt verschiedene Arten von Selektoren, wie z.B. Element-Selektoren, Klassen-Selektoren, ID-Selektoren und Pseudoklassen.

Das Box-Modell von CSS

Eines der grundlegenden Konzepte in CSS ist das Box-Modell. Die Darstellung aller Elemente auf einer Webseite erfolgt als rechteckige Box.

Diese bestehen aus den folgenden vier Bereichen:

1. Inhalt
2. Padding
3. Border
4. Margin.

Durch die Manipulation dieser Bereiche kann man das Layout und die Anordnung von Elementen auf der Webseite steuern.

Responsive Webdesign

Das Aufkommen von mobilen Geräten hat die Wichtigkeit von Responsive Webdesign signifikant erhöht. CSS bietet verschiedene Techniken, um Websites auf unterschiedlichen Bildschirmgrößen und Geräten optimal darzustellen. Die bekannteste Technik ist die Verwendung von Media Queries, die es ermöglichen, verschiedene Cascading Style Sheet Regeln abhängig von der Bildschirmgröße oder anderen Geräteeigenschaften anzuwenden.

Fazit:

CSS ist immer noch ein unverzichtbares Werkzeug für Webdesigner und Entwickler. Durch das Verständnis der Grundlagen und der zugrundeliegenden Konzepte kann man das Aussehen und die Benutzererfahrung von Webseiten und Webanwendungen drastisch verbessern. Die Flexibilität und Leistungsfähigkeit von CSS eröffnen eine Welt der kreativen Möglichkeiten und helfen dabei, das Web nach den eigenen Vorstellungen zu gestalten.

Der Beitrag CSS – Die Sprache für ansprechendes Webdesign und kreative Freiheit erschien zuerst auf CEOsBay.