Prinzipien für sauberen Code

Mehr als nur funktionierender Code

Du hast bereits gelernt, wie du Programme schreibst, die syntaktisch korrekt sind und das gewünschte Ergebnis liefern. Clean Code (sauberer Code) geht einen entscheidenden Schritt weiter: Es geht nicht nur darum, dass der Code für den Computer ausführbar ist, sondern dass er für Menschen verständlich ist. In der professionellen Softwareentwicklung wird Code viel häufiger gelesen als geschrieben. Wenn du oder deine Teammitglieder den Code in sechs Monaten wieder ansehen, solltet ihr sofort verstehen, was er tut, ohne ihn mühsam entschlüsseln zu müssen. Sauberer Code ist gut lesbar, leicht zu warten und einfach zu erweitern. Dies spart langfristig Zeit und Kosten, reduziert Fehler (Bugs) und erleichtert die Einarbeitung neuer Teammitglieder.

KISS: Keep It Simple, Stupid

Das KISS-Prinzip ist eine Aufforderung, Lösungen so einfach und verständlich wie möglich zu halten. Komplexität ist der größte Feind der Sicherheit und Wartbarkeit. Oft neigen Entwickelnde dazu, "clevere" oder technisch beeindruckende Einzeiler zu schreiben, die jedoch schwer nachzuvollziehen sind.

• Komplex (Bad Practice): Verschachtelte Bedingungen und unklare Berechnungen in einer einzigen Zeile.
• Simple (Clean Code): Aufteilung in klare Schritte, sprechende Variablennamen und verständliche Anweisungen.

Beispiel: Du möchtest prüfen, ob ein:e Kund:in rabattberechtigt ist. Kompliziert und schwer lesbar:

if (u.age > 60 or (u.status == 2 and u.points > 100)) and not u.blocked:
    give_discount()

Einfach und verständlich (KISS): Hier werden die Bedingungen in sprechende Variablen (Booleans) ausgelagert. Der Code liest sich fast wie ein englischer Satz.

is_senior = user.age > 60
is_loyal_customer = user.status == 2 and user.points > 100
is_active = not user.blocked

if is_active and (is_senior or is_loyal_customer):
    give_discount()

DRY: Don't Repeat Yourself

Das DRY-Prinzip ("Wiederhole dich nicht") besagt, dass Wissen oder Logik in einem System nur an einer einzigen Stelle existieren sollte. Wenn du denselben Code-Block an mehreren Stellen kopierst und einfügst (Copy & Paste), schaffst du Redundanz.

• Das Risiko: Wenn sich die Logik ändert (z. B. der Umsatzsteuersatz sinkt von 19% auf 7%), musst du daran denken, alle kopierten Stellen zu ändern. Vergisst du eine Stelle, entstehen Inkonsistenzen und Fehler.
• Die Lösung: Nutze Funktionen, um wiederkehrende Logik zu kapseln und zentral zu verwalten.

Beispiel: Redundant (Verstoß gegen DRY): Die Steuerberechnung erfolgt an zwei Stellen identisch.

def calculate_total(price):
    tax = price * 0.19  # Logik hier
    return price + tax

def calculate_special_offer(price):
    discounted = price - 10
    tax = discounted * 0.19 # Logik wiederholt
    return discounted + tax

Modular (Clean Code): Die Steuerberechnung wird in eine eigene Funktion ausgelagert. Ändert sich der Steuersatz, muss nur die Funktion calculate_tax angepasst werden.

def calculate_tax(amount):
    return amount * 0.19  # Zentrale Logik

def calculate_total(price):
    return price + calculate_tax(price)

def calculate_special_offer(price):
    discounted = price - 10
    return discounted + calculate_tax(discounted)