Im Laufe der Entwicklung einer Anwendung sammeln sich in Quellcodes unsauber strukturierte Stellen, die die Anwendbarkeit und Kompatibilität eines Programms gefährden. Die Lösung ist entweder ein komplett neuer Quellcode oder eine Restrukturierung in kleinen Schritten. Viele Programmierer und Unternehmen entscheiden sich zunehmend für das Code-Refactoring, um eine funktionierende Software langfristig zu optimieren und für andere Programmierer lesbarer und klarer zu gestalten.
Beim Refactoring stellt sich die Frage, welches Problem im Code durch welche Methode gelöst werden soll. Inzwischen gehört Refactoring zu den Grundlagen beim Programmieren lernen und gewinnt immer mehr an Bedeutung. Welche Methoden kommen dabei zur Anwendung und welche Vorteile und Nachteile entstehen?
Die Programmierung einer Software ist ein langwieriger Prozess, an dem teilweise mehrere Entwickler arbeiten. Dabei wird geschriebener Quelltext oft überarbeitet, umgestellt und erweitert. Durch Zeitdruck oder veraltete Praktiken sammeln sich unsaubere Stellen in Quellcodes, sogenannte Code-Smells. Diese historisch gewachsenen Schwachstellen gefährden die Anwendbarkeit und Kompatibilität eines Programms. Um die voranschreitende Erosion und Verschlechterung einer Software zu vermeiden, ist ein Refactoring notwendig.
Das Refactoring ist mit dem Lektorieren eines Buches vergleichbar. Während des Lektorats entsteht kein vollkommen neues Buch, sondern ein besser verständlicher Text. So wie es beim Lektorieren verschiedene Herangehensweisen wie Kürzen, Umformulieren, Streichen oder Umstrukturieren gibt, so gibt es auch beim Code-Refactoring Methoden wie Einkapseln, Umformatieren oder Extrahieren, um einen Code zu optimieren, ohne ihn im Wesen zu verändern.
Dieser Prozess ist deutlich kostengünstiger als die Erstellung einer komplett neuen Codestruktur. Vor allem in der iterativen und inkrementellen Software-Entwicklung sowie der agilen Software-Entwicklung spielt Refactoring eine große Rolle, da Programmierer in diesem zyklischen Modell eine Software immer wieder ändern. Refactoring ist dabei ein fester Arbeitsschritt.
Zunächst ist es nötig zu verstehen, wie ein Code altern und zum berüchtigten Spaghetti-Code mutieren kann. Ob aus Zeitdruck, durch mangelnde Erfahrung oder unklare Anweisungen: Die Programmierung eines Codes führt durch unnötig komplizierte Befehle zu Einbußen in der Funktionalität. Ein Code erodiert zunehmend, je schneller und komplexer sein Anwendungsbereich ist.
Spaghetti-Code steht für einen verworrenen, unlesbaren Quellcode, dessen Sprache für Programmierer nur schwer verständlich ist. Einfache Beispiele für verworrenen Code sind überflüssige Sprung-Befehle (GOTO), die ein Programm anweisen, im Quellcode hin und her zu springen, oder überflüssige for-/while-Schleifen und if-Anweisungen.
Besonders Projekte, an denen viele Software-Entwickler arbeiten, neigen zu unübersichtlichem Quelltext. Geht ein Code durch viele Hände und enthielt das Original bereits Schwachstellen, so lässt sich eine zunehmende Verknotung durch „Umschiffungslösungen“ und ein kostspieliges Code-Review schwer vermeiden. In den drastischsten Ausprägungen kann Spaghetti-Code die komplette Entwicklung einer Software gefährden. Dann kann selbst Code-Refactoring das Problem nicht beheben.
Nicht ganz so drastisch sind Code-Smells und Code-Rot. Mit dem Alter kann ein Code durch unsaubere Stellen im übertragenen Sinne zu riechen anfangen. Schlecht verständliche Stellen verschlimmern sich durch Eingriffe anderer Programmierer oder Erweiterungen. Findet bei ersten Anzeichen von Code-Smell kein Refactoring statt, so erodiert der Quellcode zusehends und verliert durch Code-Rot (von engl. rot für „verrotten“) seine Funktionalität.
Die Absicht hinter einem Refactoring ist schlicht und einfach ein besserer Code. Durch einen effektiven Code lassen sich neue Code-Elemente besser integrieren, ohne neue Fehler einzubauen. Programmierer, die einen Code mühelos lesen können, finden sich schneller ein und können Bugs leichter entfernen oder vermeiden. Ein anderer Zweck des Refactorings ist eine verbesserte Fehleranalyse und Wartbarkeit einer Software. Programmierer, die einen Code überprüfen, haben deutlich weniger Aufwand.
Die Techniken, die beim Refactoring zum Einsatz kommen, sind so vielfältig wie die Fehler, die sie beheben sollen. Im Grunde definiert sich Code-Refactoring durch seine Fehler und zeigt die nötigen Schritte, um einen Lösungsweg zu verkürzen oder zu entfernen. Fehlerquellen, die Sie durch Methoden des Refactorings beheben können, sind u. a.:
Refactoring sollte stets vor der Änderung einer Programmfunktion kommen. Es erfolgt am besten in sehr kleinen Schritten und testet Änderungen des Codes durch Software-Entwicklungsprozesse wie Test Driven Development (TDD) und Continuous Integration (CI). Kurz gesagt stehen TDD und CI für das kontinuierliche Testen von neuen, kleinen Codeabschnitten, die Programmierer bauen, integrieren und durch oft automatisierte Testdurchläufe auf ihre Funktionalität hin prüfen.
Es gilt die Regel: Das Programm nur in kleinen Schritten von innen ändern, ohne die äußere Funktion zu beeinflussen. Nach jeder Änderung sollten Sie einen möglichst automatisierten Testlauf durchführen.
Es gibt zahlreiche konkrete Refactoring-Techniken. Eine vollständige Übersicht findet sich in dem umfangreichsten Werk zum Refactoring von Martin Fowler und Kent Beck: „Refactoring: Improving the Design of Existing Code“. Hier ein kurzer Überblick:
Die Rot-Grün-Entwicklung ist eine testgesteuerte Methode der agilen Software-Entwicklung. Sie findet Anwendung, wenn man eine neue Funktion in einen bestehenden Code integrieren möchte. Rot steht für den ersten Testdurchlauf vor der Implementierung einer neuen Funktion in den Code. Grün steht für den einfachsten möglichen Codeabschnitt, der für die Funktion nötig ist, um den Test zu bestehen. Was folgt, ist eine Erweiterung mit konstanten Testdurchläufen, um fehlerhaften Code auszusortieren und die Funktionalität zu erhöhen. Rot-Grün-Entwicklung ist ein Grundstein für kontinuierliches Refactoring bei kontinuierlicher Software-Entwicklung.
Diese Refactoring-Methode beschreibt eine schrittweise Änderung an einem System und die Umstellung alter implementierter Codestellen auf neue integrierte Abschnitte. Branching-by-Abstraction kommt gewöhnlich bei großen Änderungen zum Einsatz, die Klassenhierarchien, Vererbung und Extrahierung betreffen. Durch die Implementierung einer Abstraktion, die mit einer alten Implementierung verknüpft bleibt, lassen sich andere Methoden und Klassen mit der Abstraktion verknüpfen und die Funktionalität des alten Codeabschnitts durch die Abstraktion ersetzen.
Oft geschieht dies durch Pull-up- oder Push-down-Methoden. Sie verknüpfen eine neue, bessere Funktion mit der Abstraktion und übertragen die Verknüpfungen auf diese. Dabei verschieben Sie entweder eine Unterklasse in eine höhere Klasse (Pull-up) oder teilen eine höhere Klasse in Unterklassen auf (Push-down).
Die alten Funktionen können Sie schließlich löschen, ohne die Gesamtfunktionalität zu gefährden. Durch diese kleinteiligen Änderungen funktioniert das System unverändert, während Sie unsauberen Code Abschnitt für Abschnitt durch sauberen Code ersetzen.
Refactoring soll die Methoden eines Codes so leicht lesbar wie möglich machen. Bereits beim Lesen erschließt sich im besten Fall die innere Logik einer Methode auch außenstehenden Programmierern. Für das effiziente Zusammenstellen von Methoden gibt es beim Refactoring verschiedene Techniken. Ziel jeder Änderung ist es, Methoden zu vereinheitlichen, Dopplungen zu entfernen und zu lange Methoden in eigene Abschnitte zu spalten, um sie für zukünftige Änderungen zu öffnen.
Techniken dafür sind beispielsweise:
Um einen Code zu verbessern, müssen Sie mitunter Attribute oder Methoden zwischen Klassen verschieben. Hierfür kommen folgende Techniken zur Anwendung:
Diese Methode hat das Ziel, Daten in Klassen zu unterteilen und diese möglichst klein und übersichtlich zu halten. Unnötige Verknüpfungen zwischen Klassen, die bei kleinsten Veränderungen die Funktionalität der Software beeinträchtigen, sollten Sie entfernen und in schlüssige Klassen teilen.
Beispiele für Techniken sind:
Bedingte Ausdrücke sollten Sie während des Refactorings so weit wie möglich vereinfachen. Hierzu bieten sich folgende Techniken an:
Methodenaufrufe lassen sich u. a. durch folgende Methoden schneller und leichter durchführen:
Im folgenden Beispiel ist erkennbar, dass im ursprünglichen Code die Benennung der Methode deren Funktionalität nicht eindeutig und schnell verständlich macht. Die Methode soll die Postleitzahl einer Büroanschrift ausgeben, zeigt diese Aufgabe jedoch nicht direkt im Code an. Um den Code klarer zu formulieren, bietet sich beim Code-Refactoring eine Umbenennung der Methode an.
Vorher:
String getPostalCode() {
return (theOfficePostalCode+“/“+theOfficeNumber);
}
System.out.print(getPostalCode());Nachher:
String getOfficePostalCode() {
return (theOfficePostalCode+“/“+theOfficeNumber);
}
System.out.print(getOfficePostalCode());| Vorteile | Nachteile |
|---|---|
| Bessere Verständlichkeit erleichtert die Wartung und Erweiterbarkeit der Software. | Ein ungenaues Refactoring könnte neue Bugs und Fehler in den Code implementieren. |
| Die Restrukturierung des Quellcodes ist ohne Veränderung der Funktionalität möglich. | Es gibt keine klare Definition für einen „sauberen Code“. |
| Verbesserte Lesbarkeit erhöht die Verständlichkeit des Codes für andere Programmierer. | Ein verbesserter Code ist für den Kunden oft nicht erkennbar, da die Funktionalität identisch bleibt, d. h. der Nutzen ist nicht offensichtlich. |
| Beseitigte Redundanzen und Dopplungen erhöhen die Effektivität des Codes. | Bei größeren Teams, die am Refactoring arbeiten, könnte der Abstimmungsaufwand unerwartet hoch sein. |
| In sich geschlossene Methoden verhindern, dass lokale Änderungen auf andere Teile des Codes Auswirkungen haben. | |
| Ein sauberer Code mit kürzeren, in sich geschlossenen Methoden und Klassen zeichnet sich durch bessere Testbarkeit aus. |
Grundsätzlich gilt beim Refactoring: Führen Sie neue Funktionen nur ein, wenn der vorliegende Quellcode unverändert bleibt. Nehmen Sie Veränderungen am Quellcode, also Refactoring, nur vor, wenn Sie keine neuen Funktionen hinzufügen.
Wer Software entwickelt, hat viel zu beachten: Eine gute Usability ist ebenso wichtig wie die Funktionalität der Anwendung; gleichzeitig ist eine optimale Performance – im Gegensatz zu Programmfehlern – unverzichtbar. Schließlich soll das Produkt auch auf den anvisierten Zielplattformen bzw. -geräten laufen. Inwiefern helfen Software Development Kits (SDKs) bei der Realisierung dieser Punkte?
Legacy Code ist ein Begriff aus dem Englischen, der übersetzt so viel wie „Altcode“ bedeutet. Derartiger Code ist meist unverständlich für Programmierer oder kompliziert in der Wartung und Anwendung, da er auf veralteten Software-Versionen beruht bzw. von fremden Firmen geschrieben wurde. Legacy Code kann zwar nicht durch Regressionstests geprüft werden, doch es gibt durchaus gute Wege, mit...
Behavior Driven Development (BDD) ist Hauptbestandteil der agilen oder verhaltensgetriebenen Software-Entwicklung. Statt auf einer bestimmten Programmiersprache basiert die Technik auf einer Textform, mit der sich später automatisierte Tests durchführen lassen. BDD erleichtert Nicht-Entwicklern die Nutzung komplexer Tools, die die Funktionalität von Software überprüfen, und verbessert so das...
Eine Readme-Datei ist in vielen Fällen die erste Anlaufstelle, wenn es darum geht, ein Projekt zu starten, eine Software zu installieren oder ein Update durchzuführen. Besonders für Entwickler ist sie von enormer Bedeutung, wenn sie öffentliche Repositories (von zum Beispiel GitHub) in das eigene Projekt integrieren. Wir klären auf, was hinter und in der Readme-Datei steckt – und bieten darüber...
In der Softwareentwicklung ist der Begriff Cloud Native seit einiger Zeit in aller Munde. Aber was ist Cloud Native eigentlich genau und wie wird das Konzept erfolgreich angewandt? Die agile Entwicklungsmethode zielt darauf ab, Anwendungen so zu entwickeln, dass sie sich nahtlos in eine Cloud-Infrastruktur integrieren lassen. Erfahren Sie hier mehr zu den Merkmalen und Vorteilen der...
