Verabschiede dich von technischen Altlasten: Agile Lösungen für saubere Entwicklung

Technische Schulden sind ein Konzept in der Softwareentwicklung, das die zukünftigen Kosten beschreibt, wenn man sich jetzt für eine schnelle oder einfache Lösung entscheidet, anstatt für einen besseren, aber zeitaufwändigeren Ansatz. 

Wenn Entwickler Geschwindigkeit mehr Priorität einräumen als der Codequalität, führt dies zu suboptimalen Lösungen, die ein Refactoring erfordern oder verbessert werden müssen. Das bedeutet doppelte Arbeit für die Teams und belastet ihre Budgets, Ressourcen und Projektzeitpläne. 

Beispielsweise die Verwendung einer veralteten Bibliothek, weil man damit vertraut ist, oder das Hardcoding von Werten, die konfigurierbar sein sollten. Das mag im Moment effizient erscheinen, führt aber später zu kostspieligen Nacharbeiten, zum Beispiel:

• Umschreiben von fragilem Code, der bei jeder Änderung eines damit verbundenen Features nicht mehr funktioniert.

• Refactoring eines Moduls, das nicht für eine Skalierung bei steigender Nutzerzahl oder Datenmenge ausgelegt war.

• Ersetzen veralteter Abhängigkeiten, für die keine Sicherheitsupdates mehr bereitgestellt werden.

• Entflechten eng gekoppelter Komponenten, damit Features unabhängig voneinander erstellt und bereitgestellt werden können.

Herkömmliche Softwareentwicklungsprogramme arbeiten häufig mit einem phasenbasierten Entwicklungsansatz: Funktionsentwicklung, Alpha, Beta und Golden Master (GM).

Jedes Software-Release beginnt mit einer Phase, in der neue Funktionen entwickelt und (idealerweise) verbleibende Probleme aus dem letzten Release behoben werden.

• Alpha: Ist erreicht, sobald jede Funktion implementiert und zum Testen bereit ist. 

• Beta: Ist erreicht, sobald genügend Bugs behoben wurden, um Kundenfeedback zu ermöglichen. Während das Team noch damit beschäftigt ist, genug Bugs zu beheben, um Beta zu erreichen, tauchen leider neue Bugs auf, die zu technischen Schulden beitragen. Das ist ein klassisches Beispiel für einen Teufelskreis: Für jeden behobenen Bug kommen zwei neue dazu. 

• Keine offenen Bugs: Wird normalerweise erreicht, indem einige bekannte Probleme behoben werden und die Behebung der restlichen Probleme auf das nächste Release verschoben wird. 

Verschleppte Bug-Korrekturen führen dazu, dass sich technische Schulden anhäufen und immer neue Probleme nach sich ziehen. Je größer das Backlog wird, desto schwieriger wird seine Aufarbeitung. Die Entwicklung verlangsamt sich, Zeitpläne verzögern sich und Kunden haben mit anhaltenden Fehlern zu kämpfen. Damit die technischen Schulden nicht derart außer Kontrolle geraten, kann Agile als nachhaltigere Strategie Abhilfe schaffen.

Zum Verständnis von technischen Schulden gehört die Erkenntnis, dass nicht alle Schulden gleich sind. Die Hauptkategorien technischer Schulden umfassen: 

• Absichtliche Schulden: Wenn Teams wissentlich Abkürzungen nehmen, um Fristen einzuhalten oder Funktionen schneller auszuliefern. Es ist eine bewusste Entscheidung, bei der Entwickler wissen, dass sie zukünftige Arbeit erzeugen, aber Geschwindigkeit der Perfektion vorziehen. 

• Unabsichtliche Schulden: Schlechte Codequalität kann unbeabsichtigt entstehen. Ein Entwickler kann Anforderungen falsch interpretieren oder dem Team kann es an Erfahrung mit einer bestimmten Technologie mangeln. Diese Art von technischen Schulden entsteht eher durch ehrliche Fehler als durch strategische Entscheidungen. 

• Bit Rot: Selbst guter Code kann mit der Zeit problematisch werden. Mit der Weiterentwicklung von Systemen, sich ändernden Abhängigkeiten und neuen Funktionen kann zuvor solider Code veralten oder mit neueren Komponenten inkompatibel werden.

Teams häufen aus verschiedenen Gründen technische Schulden an, oft ohne überhaupt zu merken, dass es passiert. Hier einige der häufigsten Ursachen für technische Schulden: 

• Enge Deadlines: Wenn das Produktmanagement auf eine schnellere Lieferung drängt, werden Kompromisse gemacht. Hastige Korrekturen ersetzen richtige Lösungen und führen zu Schulden, die sich im Laufe der Zeit ansammeln. 

• Unzureichende Tests: Tests auszulassen mag anfangs Zeit sparen, aber übersehene Bugs führen zu kontinuierlichem Wartungsaufwand, der die Entwicklung verlangsamt. 

• Schlechte Kommunikation: Wenn Agile-Projektmanagementpraktiken versagen, steigt das Risiko, dass Entwickler Anforderungen missverstehen oder einfach von Annahmen ausgehen, die später Überarbeitungen nötig machen. 

• Fehlende Fähigkeiten: Teams, die mit ihnen unbekannten Technologien arbeiten, entwickeln oft suboptimale Lösungen, die überarbeitet werden müssen, sobald sie sich besser mit ihren Tools auskennen. 

• Ständig wechselnde Anforderungen: Wenn sich die Produktstrategie ändert, passt bisher sinnvoller Code möglicherweise nicht mehr zur aktuellen Vision und wird damit zu technischen Schulden.

Trügerisch an technischen Schulden ist, dass sie oft erst sichtbar werden, wenn sie anfangen, echte Probleme zu verursachen. An diesem Punkt bist du schon ins Hintertreffen geraten. Glücklicherweise gibt es einfache Möglichkeiten, technische Schulden zu identifizieren, bevor sie ernste Konsequenzen nach sich ziehen.

Die effektivsten Methoden zur frühzeitigen Identifizierung technischer Schulden sind: 

• Code-Überprüfungen: Regelmäßige Peer-Reviews offenbaren oft, wo Abkürzungen genommen und Kompromisse gemacht wurden oder wo die Komplexität so stark zugenommen hat, dass sie sich nicht mehr managen lässt. 

• Komplexitätsmetriken: Tools zur Messung der Codekomplexität können dabei helfen, problematische Abschnitte zu identifizieren, die Aufmerksamkeit erfordern. Eine hohe zyklomatische Komplexität oder tiefe Verschachtelung weist oft auf Bereiche hin, für die ein Refactoring erforderlich ist. 

• Entwickler-Feedback: Teammitglieder, die täglich mit dem Code arbeiten, können Muster und Schwachstellen erkennen, die in Metriken möglicherweise übersehen werden. Ihre Einblicke sind von unschätzbarem Wert, um Hindernisse zu identifizieren, die den Entwicklungsprozess verlangsamen. 

• Leistungsüberwachung: Lange Reaktionszeiten oder Spitzen in der Ressourcennutzung können auf zugrunde liegende technische Probleme hinweisen, die Aufmerksamkeit erfordern. 

Wiederkehrende Bugs oder unerwartete Verzögerungen deuten ebenfalls auf versteckte Schulden hin, die den Fortschritt verlangsamen. Wenn immer wieder die gleichen Probleme auftreten oder einfache Änderungen länger dauern als erwartet, ist das in der Regel ein Zeichen dafür, dass technische Schulden die Geschwindigkeit deines Teams beeinträchtigen.

Technische Schulden können sich anhäufen – ob durch schnelle Lösungen unter Zeitdruck, sich ändernde Anforderungen oder veraltete Systeme. Und vielleicht hast du ein paar dieser Schulden aus älterem Code übernommen. 

Die folgenden Tipps helfen dir dabei, vorhandene Schulden im Zaum zu halten, damit sich dein Team auf Spannenderes wie die Entwicklung neuer Features konzentrieren kann. 

1. Klare Definition von technischen Schulden festlegen

Manchmal sind sich Entwickler und Produktmanager nicht einig, was technische Schulden sind. Diesen Streit können wir hier begraben:

Auf der Entwicklerseite besteht die Versuchung, architekturbezogene Arbeiten als technische Schulden zu bezeichnen. Das kann je nach Art der Änderung der Fall sein oder auch nicht (z. B. das Ersetzen einer Abkürzung durch die "echte" Lösung im Vergleich zum Aufteilen einer monolithischen Codebasis in Mikroservices).

Andererseits ist es für das Produktmanagement oft dringlicher, neue Features zu entwickeln, statt Bugs oder eine langsame Performance zu beheben. 

Um zu vermeiden, dass eine Seite einfach resigniert, müssen alle den Unterschied zwischen technischen Schulden, gewünschten architekturbezogenen Änderungen in der Codebasis und neuen Features verstehen. Für die Priorisierung des Backlogs und die Weiterentwicklung der Codebasis ist eine klare Kommunikation zwischen der Entwicklung und dem Produktmanagement unerlässlich. 

2. Tests in deinen Workflow integrieren

Stelle sicher, dass Tests in den ersten Entwicklungszyklus integriert werden, um Probleme frühzeitig zu erkennen und zu beheben. Beginne damit, eine klare Definition von "Erledigt" festzulegen und vermeide es, Tests aufzuschieben. 

Definiere "Erledigt" nicht nur als vollständige Funktionalität, sondern auch als getestet und bereit für den Release. Das bedeutet, der ursprünglichen User Story eine separate Testaufgabe hinzuzufügen. Wenn das Testen nicht als Teil der ursprünglichen Story oder des Bugfixes durchgeführt wird, ist die ursprüngliche Story oder der Bugfix nicht abgeschlossen bzw. erledigt. 

Ein Aufschieben ist zu einfach und es führt nur zu technischen Schulden.

3. Bugs wegautomatisieren

Wenn jemand einen Bug in der Software entdeckt, nimm dir die Zeit, einen automatisierten Test hinzuzufügen, der diesen demonstriert. Sobald der Bug behoben wurde, führe den Test erneut durch, um die Korrektur sicherzustellen. 

Das ist der Kern der testorientierten Entwicklung, einer bewährten Methode zur Qualitätssicherung in der agilen Entwicklung.

Es ist nicht leicht, die Haltung des Teams (und der Stakeholder des Teams) im Umgang mit technischen Schulden zu ändern. Manchmal hat es Vorrang, die Entwicklungszeit zu verkürzen, um das Produkt schneller auf den Markt zu bringen. Behalten wir das im Hinterkopf, während wir einige Aufgaben für das Eindämmen technischer Schulden wiederholen:

• Informiere den Produktinhaber über die wahren Kosten von technischen Schulden: Sorge dafür, dass die Story-Point-Werte für zukünftige Storys korrekt sind, die eine Lösung vorhandener technischer Schulden erfordern.

• Modularisiere deine Architektur: Mache keine Zugeständnisse in Bezug auf technische Schulden in neuen Komponenten oder Bibliotheken in der Anwendung. Sobald die Agilität in diesen neuen Komponenten sichtbar ist, werden die Teams diese Verfahren selbstverständlich auch auf andere Teile des Codes ausweiten wollen.

• Schreibe automatisierte Tests: Nichts verhindert Bugs besser als automatisierte Tests und Continuous Integration (CI). Wenn ein neuer Bug gefunden wird, schreibe einen neuen Test, um ihn zu reproduzieren und das Problem zu beheben. Wenn dieser Bug jemals wieder auftaucht, wird der automatisierte Test ihn erkennen, bevor es die Kunden tun.

Das Konzept der technischen Schulden lässt sich mit ein paar einfachen Beispielen veranschaulichen:

Nehmen wir an, dein Team hat Datenbankverbindungen hartcodiert, statt ein Konfigurationssystem zu verwenden. Das spart anfangs durchaus Zeit, führt langfristig aber zu Problemen, sobald in unterschiedlichen Umgebungen bereitgestellt werden muss. 

Ein anderes Beispiel ist das Auslassen einer gründlichen Fehlerbehebung, weil eine Deadline eingehalten werden muss. Dadurch wird das System anfällig für Abstürze, die dann später Notfallkorrekturen erfordern. 

Gutes Schuldenmanagement kann bedeuten, bewusst einen Algorithmus zu wählen, der sich einfacher verstehen und pflegen lässt, auch wenn er vielleicht etwas weniger effizient ist. Schlechtes Management ist es, immer wieder kleinere Korrekturen zu implementieren, ohne die eigentliche Grundursache anzugehen. 

Teams können Jira nutzen, um neben der regulären Feature-Arbeit auch technische Schulden zu verfolgen, zu priorisieren und zu beseitigen. Erstelle spezifische Vorgangstypen für technische Schulden und integriere sie in deinen regulären Sprintplanungsprozess. 

Nutze Funktionen der Ressourcenplanung, um Zeit für den Schuldenabbau einzuplanen, und setze Tools für das Ressourcenmanagement ein, um Prozesse zu verfolgen. Richte Workflows ein, die technische Schulden für alle Stakeholder sichtbar machen, nicht nur für Entwickler. 

Mit Rovo Dev können Teams noch einen Schritt weiter gehen, indem sie KI einsetzen, um routinemäßige Programmieraufgaben zu automatisieren und das Refactoring zu beschleunigen. Rovo Dev kann mehrstufige Workflows erstellen, Wissen bereitstellen und Code umfassend planen, generieren und überprüfen. Durch die Reduzierung des manuellen Aufwands bei der Identifizierung, Planung und Bewältigung technischer Schulden hilft Rovo Dev Teams dabei, hochwertige Software schneller bereitzustellen.

Diese Transparenz hilft Produktmanagern, die wahren Kosten der angesammelten Schulden zu verstehen, und erleichtert es ihnen, den Zeitaufwand für Wartungsarbeiten zu rechtfertigen. 

Jira testen

Was sind technische Schulden in Scrum?

In Scrum sind technische Schulden Vorgänge, die erledigt werden müssen, um die Codequalität und die Systemintegrität zu wahren. Scrum-Teams nehmen Schuldenvorgänge in die Sprint-Backlogs auf und geben ihnen die gleiche Priorität wie anderen Vorgängen. 

Wie lassen sich technische Schulden vermeiden?

Die ersten Schritte zur Vermeidung technischer Schulden sind eine sorgfältige Planung, regelmäßige Peer-Überprüfungen und automatisierte Tests. Die Schaffung einer Kultur, in der langfristige Code-Qualität wichtiger ist als kurzfristige Geschwindigkeit, hilft Teams, von Anfang an bessere Architekturentscheidungen zu treffen. 

Sind technische Schulden immer schlecht?

Nicht unbedingt. Strategische technische Schulden können akzeptabel sein, wenn Teams sich aus triftigen geschäftlichen Gründen bewusst für Geschwindigkeit und gegen Perfektion entscheiden. Der Schlüssel liegt darin, dies gezielt und punktuell zu tun statt immer wieder versehentlich.

Wer zahlt für technische Schulden?

Alle zahlen für technische Schulden. Die Entwicklerteams verbringen mehr Zeit mit der Wartung, während die Produktteams nur langsam neue Funktionen erhalten und Kunden mit mehr Bugs zu kämpfen haben. Effektives Schuldenmanagement ist eine gemeinsame Aufgabe der technischen Teams und der Produktteams. 

Wie lassen sich technische Schulden messen?

Du kannst Tools wie Jira verwenden, um Schuldenelemente zu verfolgen, die Zeit bis zu ihrer Lösung zu messen und Trends zu überwachen. Regelmäßige Code-Audits, Komplexitätsmetriken und Entwicklerumfragen können dabei helfen, den Umfang und die Auswirkungen der aufgelaufenen Schulden zu quantifizieren.