Clean Code: Prinzipien für exzellente Softwareentwicklung

Seminarziel

Am Ende des Seminars sind die Teilnehmenden in der Lage, Clean Code-Prinzipien effektiv anzuwenden, um qualitativ hochwertigen, lesbaren und wartbaren Code zu schreiben. Sie lernen, wie sie Projekte planen, entwickeln, integrieren und optimieren, um die vielfältigen Vorteile dieser Prinzipien voll auszuschöpfen.

Inhalt

• Einführung in Clean Code
  • Überblick über Clean Code: Was ist Clean Code und warum ist es wichtig?
  • Hauptprinzipien von Clean Code: Übersicht über die wichtigsten Konzepte und Prinzipien.
• Namen und Kommentare
  • Gute Namensgebung: Regeln und Best Practices für das Benennen von Variablen, Funktionen und Klassen.
  • Effektive Kommentare: Wann und wie man Kommentare verwendet, um den Code verständlicher zu machen.
• Funktionen und Methoden
  • Gestaltung von Funktionen: Prinzipien für kurze, aussagekräftige und einheitliche Funktionen.
  • Parameter und Rückgabewerte: Umgang mit Parametern und Rückgabewerten in Funktionen.
• Formatierung und Strukturierung
  • Codeformatierung: Regeln für die einheitliche Formatierung von Code.
  • Strukturierung von Code: Techniken zur sinnvollen Anordnung und Strukturierung von Codeblöcken.
• Praktische Übung 1: Refaktorisierung von Code
  • Problemstellung: Identifikation von unsauberem Code in einem bestehenden Projekt und Verbesserung dessen Lesbarkeit und Wartbarkeit.
  • Lösung:
  • Analyse des bestehenden Codes und Identifikation von Verbesserungsmöglichkeiten.
  • Anwendung der Clean Code-Prinzipien zur Refaktorisierung des Codes.
  • Tool: Verwendung von IntelliJ IDEA für die automatische Code-Refaktorisierung.
  • Ergebnis: Ein verbesserter Codeabschnitt, der lesbarer und wartbarer ist.
• Objektorientiertes Design
  • Prinzipien des objektorientierten Designs: SOLID-Prinzipien und ihre Anwendung.
  • Gestaltung von Klassen: Best Practices für die Gestaltung von Klassen und Objekten.
• Fehlerbehandlung und Testen
  • Fehlerbehandlung: Strategien für die saubere und effektive Fehlerbehandlung.
  • Unit-Tests: Bedeutung von Unit-Tests und Best Practices für das Schreiben von Tests.
• Code-Duplizierung und Modularisierung
  • Vermeidung von Code-Duplizierung: Techniken zur Identifikation und Beseitigung von dupliziertem Code.
  • Modularisierung: Aufteilung des Codes in wiederverwendbare Module und Komponenten.
• Refactoring und Wartung
  • Refactoring-Techniken: Ansätze und Techniken zur kontinuierlichen Verbesserung des Codes.
  • Wartungsfreundlicher Code: Tipps und Tricks zur Erhaltung der Wartbarkeit des Codes über die Zeit.
• Praktische Übung 2: Anwendung fortgeschrittener Clean Code-Prinzipien
  • Problemstellung: Anwendung der fortgeschrittenen Clean Code-Prinzipien auf ein komplexeres Projekt zur Verbesserung der Struktur und Wartbarkeit.
  • Lösung:
  • Analyse eines komplexen Codes und Identifikation von Verbesserungsmöglichkeiten.
  • Anwendung der Clean Code-Prinzipien zur Refaktorisierung und Verbesserung des Codes.
  • Tool: Nutzung von SonarQube zur Analyse und Verbesserung der Codequalität.
  • Ergebnis: Ein refaktorierter und verbesserter Codeabschnitt, der die Prinzipien von Clean Code umsetzt.
• Codeanalyse-Tools
  • Einführung in statische Codeanalyse-Tools.
  • Nutzung von SonarQube zur Identifikation von Code-Smells und technischen Schulden.
  • Integration von SonarQube in CI/CD-Pipelines.
• Automatisierte Tests
  • Einführung in Test-Frameworks wie JUnit und NUnit.
  • Schreiben und Ausführen von Unit-Tests mit diesen Frameworks.
  • Integration von Tests in den Entwicklungsworkflow.
• Code-Refactoring-Tools
  • Vorstellung von Refactoring-Tools in gängigen IDEs wie IntelliJ IDEA und Eclipse.
  • Nutzung dieser Tools zur Verbesserung der Codequalität und Vereinfachung des Refactoring-Prozesses.
• Versionskontrolle
  • Best Practices für die Nutzung von Versionskontrollsystemen wie Git.
  • Strategien für saubere Commits und effektive Branching-Modelle.
  • Nutzung von Git-Tools zur Überprüfung und Pflege von Clean Code.
• Praktische Übung 3: Tool-unterstützte Refaktorisierung und Analyse
  • Problemstellung: Anwendung von Codeanalyse- und Refactoring-Tools auf ein bestehendes Projekt zur Verbesserung der Codequalität.
  • Lösung:
  • Durchführung einer statischen Codeanalyse mit SonarQube und Identifikation von Verbesserungsmöglichkeiten.
  • Anwendung von Refactoring-Tools und automatisierten Tests zur Verbesserung des Codes.
  • Tool: Einsatz von Git für Versionskontrolle und Code-Review-Prozesse.
  • Ergebnis: Ein verbesserter Codeabschnitt unter Einsatz von Tools zur Unterstützung von Clean Code-Prinzipien.