Code Quality und Software Craftsmanship: Grundlagen professioneller Softwareentwicklung

Kursüberblick

Dieser umfassende 2-tägige Grundlagenkurs vermittelt die Fundamentals hochwertiger Softwareentwicklung. Teilnehmer lernen die Prinzipien von Clean Code, Software Craftsmanship und professionellem Software Engineering. Praktische Übungen führen in Test-Driven Development (TDD), Code Reviews und statische Code-Analyse ein. Der Kurs legt die Grundlage für nachhaltige Code-Qualität in Entwicklungsteams.

Was Sie lernen werden

Tag 1: Fundamentals & Klassische Ansätze

• Einführung in Code Quality

  • Bedeutung von Code-Qualität (Wartbarkeit, Lesbarkeit, Testbarkeit)
  • Typische Qualitätsmetriken (Komplexität, Kopplung, Kohäsion)
  • Technical Debt und seine Auswirkungen

• Software Craftsmanship und Clean Code

  • Grundlagen des Software Craftsmanship
  • Das Software Craftsmanship Manifesto
  • Professionalität und Berufsethik

• Software Entropy

  • Definition und Ursachen
  • Indikatoren (Smells) von Software-Entropie

• Was ist Software-Architektur?

  • Architecture in the small vs. architecture in the large
  • Unterschied zwischen “Design” und “design” (strategisch vs. taktisch)
  • Die Rolle der Architektur als Bindeglied zwischen Anforderungen und Implementierung

• Architekturdarstellung und Views

  • Kommunikations- und Dokumentationszwecke
  • Blockdiagramme vs. UML
  • Das 4+1 Architektur-View-Modell (Logical, Process, Development, Physical View + User)

• Architektur-Design-Prinzipien

  • Separation of Concerns, SOLID, KISS, YAGNI
  • Clean Architecture, Modularität, Abstraktion
  • Dependency Injection & Inversion of Control
  • Wartbarkeit, Flexibilität und Testbarkeit als Architekturziele

Tag 2: Moderne Ansätze & Professional Practices

• Architektur-Patterns

  • Layered Architecture (Schichtenarchitektur)
  • Client/Server, Peer-to-Peer, Master/Slave
  • Repository, CQRS, Event Bus, Message Queue

• Standard-Architekturen

  • Model-View-Controller (MVC)
  • Service-Oriented Architecture (SOA, Microservices)
  • Hexagonal Architecture (Ports & Adapters, Dependency Rule)

• Einführung in Software Design Patterns

  • Unterschied zu Architektur-Patterns und wie sie zusammenarbeiten
  • Struktur eines Patterns (Name, Problem, Lösung, Konsequenzen)
  • Kategorien: Creational, Structural, Behavioral

• Testing-Strategie und Test-Driven Development (TDD)

  • Red–Green–Refactor Zyklus
  • Unit Tests und ihre Rolle in der Code-Qualität

• Statische Code-Analyse & Tooling

  • Linters und Analyse-Tools (z.B. SonarQube, ESLint, Pylint)
  • CI/CD Integration und Quality Gates

• Trunk-Based Development und Feature Toggles

  • Kurze Release-Zyklen und Continuous Integration
  • Verwendung von Feature Toggles für risikofreie Deployments und kontrolliertes Feature-Rollout

• Integration von Architektur und Design Patterns

  • Kombination von Clean Architecture mit Strategy und Repository Patterns
  • Wie Patterns praktisch Prinzipien wie SOLID und Separation of Concerns unterstützen

Voraussetzungen

• Grundlegende Programmierkenntnisse in einer objektorientierten Programmiersprache (vorzugsweise Python, C++, C# oder Java)
• Erste Erfahrungen mit Versionskontrollsystemen (z.B. Git)
• Grundkenntnisse von Entwicklungs- und Build-Tools (IDE, Compiler, Test-Frameworks)

Kursformat

• Dauer: 2 ganze Tage (je 8 Stunden)
• Format: Instruktor-geleitetes Training mit umfangreichen Hands-on Übungen
• Klassengröße: Maximal 12 Teilnehmer für intensive Betreuung
• Materialien: Umfassende Kursunterlagen, Code-Beispiele und Checklisten inklusive

Hands-on Übungen

Während des Kurses arbeiten Sie an praxisnahen Projekten:

1. Code-Analyse: Identifikation von Code Smells und Verbesserungsvorschläge
2. Refactoring-Übung: Verbesserung eines Legacy-Codes
3. TDD-Praxis: Implementierung einer Funktion mit Red-Green-Refactor
4. Architektur-Design: Erstellung eines 4+1 View Models für ein System
5. Pattern-Anwendung: Implementierung von Design Patterns in bestehendem Code
6. Statische Analyse: Setup und Konfiguration von SonarQube/Linter
7. Feature Toggle Implementation: Praktische Umsetzung

Verwendete Tools und Technologien

Im Kurs arbeiten wir mit:

• Programmiersprachen: Python, Java, C#, oder C++ (je nach Teilnehmerwunsch)
• Git für Versionskontrolle
• SonarQube für statische Code-Analyse
• Linters: ESLint, Pylint, oder ähnliche
• Test-Frameworks: pytest, JUnit, NUnit
• IDE: VS Code, IntelliJ IDEA, oder Visual Studio
• CI/CD Tools für Quality Gates

Wer sollte teilnehmen

• Software-Entwickler (Junior bis Mid-Level)
• Backend- und Frontend-Entwickler
• Entwickler, die ihre Code-Qualität verbessern möchten
• Team Leads, die Standards etablieren wollen
• Quereinsteiger in der professionellen Softwareentwicklung
• Alle, die Clean Code Prinzipien lernen möchten

Lernziele

Am Ende dieses Kurses werden Sie in der Lage sein:

• ✅ Code-Qualität zu bewerten und zu messen
• ✅ Clean Code Prinzipien anzuwenden
• ✅ Code Smells zu identifizieren und zu beseitigen
• ✅ Software-Architektur zu verstehen und zu dokumentieren
• ✅ SOLID Prinzipien in der Praxis umzusetzen
• ✅ Test-Driven Development (TDD) anzuwenden
• ✅ Gängige Design Patterns zu erkennen und einzusetzen
• ✅ Statische Code-Analyse-Tools zu nutzen
• ✅ Technical Debt zu verstehen und zu managen
• ✅ Professionelle Entwicklungspraktiken zu etablieren

Kursmaterialien

Alle Teilnehmer erhalten:

• Umfassendes Software Craftsmanship Handbuch (180+ Seiten)
• Clean Code Checkliste und Quick Reference
• Design Patterns Katalog mit Code-Beispielen
• SOLID Prinzipien Poster
• Architektur-Templates und Diagramm-Vorlagen
• Code-Beispiele in mehreren Programmiersprachen
• Zugang zu Übungs-Repository (60 Tage)
• Digitales Abschlusszertifikat
• 30 Tage Post-Kurs E-Mail-Support

Zertifizierungsvorbereitung

Dieser Kurs unterstützt die Vorbereitung auf:

• Certified Software Development Professional (CSDP)
• iSAQB Certified Professional for Software Architecture (CPSA-F)
• Clean Code Developer Grades