Was ist ein Code Smell?
Code Smells sind Kategorien von Problemen im Code, die im Laufe der Zeit zu tiefergehenden Problemen führen können. Sie ähneln Warnindikatoren, die aufgrund potenziell schlechter Codierungspraktiken auftreten.
Code Smells sind zwar keine Fehler oder Bugs an sich und beeinträchtigen auch nicht die Funktionalität der Software, aber sie weisen auf Schwächen im Design hin, die die Entwicklung verlangsamen oder das Risiko von Bugs oder Ausfällen im weiteren Verlauf erhöhen können.
Zu den häufigsten Beispielen für Code Smells gehören Probleme wie große Klassen und lange Methoden – d. h. eine Funktion, die zu viel leisten soll, oder Methoden, deren Verständnis viel Zeit in Anspruch nimmt.
Ein weiteres Beispiel ist doppelter Code – wenn derselbe Code an mehreren Stellen wiederholt wird.
Probleme wie diese können zu unübersichtlichem Code führen, die kognitive Komplexität der Codebasis erhöhen und zu Wartungsproblemen und erhöhten technischen Schulden in der Software beitragen.
Was sind Beispiele für Code Smells?
Der folgende Code in Python hat aufgrund der Verschachtelung der Funktionen einen kognitiven Komplexitätswert von 8. Obwohl dieser Code einwandfrei funktioniert, erhöht er die Komplexität für den Autor, den Prüfer und zukünftige Entwickler, wenn er nicht korrigiert wird.
def process_user(user):
if user.is_active(): # +1 (if)
if user.has_profile(): # +1 (if) +1 (nested)
... # process active user with profile
else: # +1 (else)
... # process active user without profile
else: # +1 (else)
if user.has_profile(): # +1 (if) +1 (nested)
... # process inactive user with profile
else: # +1 (else)
... # process inactive user without profileWarum sind Code Smells wichtig?
Code Smells sind wichtige Indikatoren für den Zustand einer Software, da sie Frühwarnzeichen für mögliche Probleme sind, die in der Codebasis auftreten könnten. Sie sind wichtig, weil sie Stellen identifizieren können, an denen der Code in Zukunft anfällig für Probleme sein könnte, auch wenn er derzeit einwandfrei funktioniert.
Entwickler können grundlegende Designfehler, Wartbarkeitsprobleme und Skalierbarkeitsprobleme verhindern, bevor sie zu ernsteren Problemen werden, indem sie Code Smells erkennen.
Die Erkennung von Code Smells kann während der Entwicklung aufdringlich und störend wirken, aber sie ermutigt Entwickler, empfohlene Codierungsstandards und Best Practices zu befolgen, was dazu beiträgt, eine hochwertige Code-Kultur innerhalb der Entwicklungsteams zu schaffen.
Sie dienen als Leitkonzepte für Entwickler, die an Refactoring-Projekten arbeiten, und weisen ihnen den Weg zu saubererem, modularerem und wartungsfreundlicherem Code.
Darüber hinaus sind Code Smells Lehrmittel, die Entwicklern helfen, ein tieferes Verständnis für Software-Designmuster und -Ideen zu entwickeln.
Entwickler können ihre Fähigkeiten verfeinern, ein Bewusstsein und eine Wertschätzung für Codequalität entwickeln und zur kontinuierlichen Verbesserung der Codebasis beitragen, indem sie Code Smells identifizieren und beheben.
Indem sie Entwicklern eine gemeinsame Sprache zur Diskussion und Verwaltung von Codequalitätsproblemen bieten, fördern Code Smells die Zusammenarbeit und Kommunikation.
Durch die konsequente Erkennung und Behebung von Code Smells können Softwareprojekte technische Schulden reduzieren, die langfristige Wartbarkeit erhöhen und die allgemeine Softwarequalität verbessern.
Wie kann man Code Smells beheben?
Die Behebung von Code Smells erfordert einen systematischen Plan, der sich darauf konzentriert, die Ursache des Smells zu finden und die richtigen Refactoring-Techniken zu seiner Behebung einzusetzen. Code Smells sollten zunächst von den Entwicklern nach ihrer Auswirkung auf die Codebasis und dem möglichen Nutzen ihrer Behebung priorisiert werden.
Der obige Codeausschnitt trug zu Code Smells bei, da er unnötig komplex war und zu viele Codezeilen enthielt.
Probleme, die zu kognitiver Komplexität oder einfach gesagt zu einer „Überlastung des Gehirns” beitragen können, können dazu führen, dass Entwickler mehr Zeit mit dem Lesen und Verstehen von Code verbringen als mit dem Schreiben.
Eine hohe kognitive Komplexität verlangsamt Änderungen und erhöht die Wartungskosten.
Durch die Refaktorisierung des Codes in kleinere Funktionen kann die Komplexität auf mehrere Funktionen verteilt werden, und die Unterbrechungen im Ablauf sind nicht mehr verschachtelt.
def process_user(user):
if user.is_active(): # +1 (if)
process_active_user(user)
else: # +1 (else)
process_inactive_user(user)
def process_active_user(user):
if user.has_profile(): # +1 (if) +1 (nested)
... # process active user with profile
else: # +1 (else)
... # process active user without profile
def process_inactive_user(user):
if user.has_profile(): # +1 (if) +1 (nested)
... # process inactive user with profile
else: # +1 (else)
... # process inactive user without profileEin weiteres Beispiel für einen häufigen Code Smell ist die Verwendung eines Built-ins als Name einer Variablen. Auch wenn dies bei erfahrenen Entwicklern nicht vorkommt, ist dies keine gute Codierungspraxis, da das Built-in bei dieser Verwendung nicht über seinen ursprünglichen Namen zugänglich ist.
def a_function():
int = 42Die richtige Vorgehensweise zur Behebung dieses Problems ist die Verwendung einer geeigneten Variablen:
def a_function():
value = 42Ein weiteres Beispiel aus dem obigen Abschnitt sind Dateien mit zu vielen Codezeilen.
Wenn eine Quelldatei zu groß wird, kann sie zahlreiche Aufgaben ansammeln und schwer verständlich und wartbar werden.
Um den Code wartbarer zu machen, sollten Dateien, die einen bestimmten Schwellenwert überschreiten, in kleinere Dateien umgestaltet werden, deren Code sich auf klar definierte Aufgaben konzentriert.
Diese kleineren Dateien sind leichter zu verstehen und zu testen.
Es gibt Tausende solcher Probleme, die zu Code-Smells führen können, und ihre frühzeitige Behebung fördert gute Codierungspraktiken.
Sobald Code Smells gefunden wurden, können Entwickler eine Vielzahl von Refactoring-Strategien anwenden, um sie zu beseitigen, ohne das äußere Verhalten des Codes zu verändern.
Entwickler können lange, komplizierte Prozeduren, die zu Code Smells führen, in kleinere, leichter zu verwaltende Methoden aufteilen, die jeweils eine bestimmte Aufgabe übernehmen.
Code-Smells und Refactoring
Refactoring, also die Umstrukturierung von Code ohne Änderung seines äußeren Verhaltens, wird in der Regel eingesetzt, um Code-Smells zu beheben und damit die Lesbarkeit, Modularität und allgemeine Codequalität zu verbessern.
Der Refactoring-Prozess umfasst eine strenge Abwägungsanalyse, da eine übereilte Umsetzung von Änderungen zu unerwarteten Effekten oder neuen Problemen führen kann.
Daher erfordert die Beseitigung von Code Smells eine ausgewogene Strategie, die technisches Know-how mit einem Verständnis für die Ziele und Grenzen des Projekts verbindet.
Letztendlich können Software-Teams eine Kultur der kontinuierlichen Verbesserung fördern, indem sie Code Smells proaktiv erkennen und beheben und so sicherstellen, dass ihre Codebasis
wartbar, zuverlässig und sicher für langfristige Änderungen ist.
Die Refaktorisierung muss von umfassenden Tests begleitet werden, um sicherzustellen, dass keine Fehler oder Regressionen eingeführt werden.
Um die Lesbarkeit der Codebasis zu erhalten und zukünftige Wartungsarbeiten zu erleichtern, sollten Entwickler auch die Gründe für jeden Refaktorisierungsschritt in ihrer Dokumentation angeben.
Der Wissensaustausch im Team und die Validierung von Refactoring-Entscheidungen können durch Code-Reviews und Pair Programming erleichtert werden.
Sonar und Code Smells
SonarQube Server und SonarQube Cloud können Entwicklern dabei helfen, Code Smells sowie eine Vielzahl anderer Probleme (Bugs, Sicherheitslücken usw.) zu identifizieren und zu verhindern.
Beide lassen sich nativ in Ihre CI/CD-Pipelines integrieren, um Probleme frühzeitig in der Entwicklungsphase zu finden und zu beheben, bevor sie zu Schwierigkeiten in der Produktion führen.
SonarQube for IDE, ein Begleit-Tool zu SonarQube Server und SonarQube Cloud, ist ein IDE-Plugin, das Echtzeit-Feedback innerhalb des Editors des Entwicklers liefert und Code-Probleme (einschließlich Code Smells) hervorhebt, während Entwickler Code schreiben.