1992 offiziell geprägt, ist der Begriff der technischen Schulden mittlerweile im Berufsalltag der Softwareentwicklung angekommen. Seither wird er mit unvorhergesehenen Planabweichungen infolge ungünstiger technischer Entscheidungen in Verbindung gebracht. Dabei besteht kein grundlegendes Verständnis darüber, was genau technische Schulden sind, welche Auswirkungen sie haben, welche Vorteile deren gezieltes Management hat und wie dieses in die Softwareentwicklung integriert werden kann.
Das erste Kapitel liefert eine zusammenhängende Beschreibung technischer Schulden und baut darauf ein Modell auf. Dieses Modell dient im zweiten Kapitel als Basis für konkrete Einführungsstrategien in die Softwareentwicklung.
Das Konzept der technischen Schulden bezeichnet in der Softwareentwicklung das Eingehen von Kompromissen: So wird beispielsweise zur Einhaltung einer Deadline der Fokus auf Featurevollständigkeit gesetzt und dabei die Codequalität (temporär) vernachlässigt. Diese Kompromisse können kurzfristig vorteilhaft sein, beispielsweise um das kritische strategische Ziel zu realisieren, mit einem Softwareprodukt vor der Konkurrenz am Markt zu sein. Findet jedoch keine angemessene Steuerung statt, können technische Schulden mittel- bis langfristig für ein Softwareprodukt (und seinen Hersteller) Probleme verursachen. Vor fast einem Vierteljahrhundert von Ward Cunningham als Technical Debt geprägt [1], sind seitdem vier Dinge klar geworden:
- Technische Schulden können in allen Phasen der Softwareentwicklung entstehen bzw. wirken.
- Technische Schulden werden einem Softwareprodukt, -projekt und -hersteller schaden, sofern sie nicht bewusst aufgenommen und kontrolliert werden.
- Werden technische Schulden jedoch bewusst aufgenommen und fortwährend gesteuert, führt dies durch eine zusammenhängende und stets aktuelle Informationslage zu einer für alle Stakeholder belastbaren Entscheidungsbasis und somit zu einer reduzierten Unsicherheit in der Softwareentwicklung und im Softwareprojektmanagement.
- Im Zuge der o. g. Informationslage ergeben sich Gelegenheiten für taktisch kalkulierbare Risiken, z. B. zur kurzfristigen Steigerung der Produktivität, um kritischen Terminen gerecht zu werden, oder aber für strategisch wirtschaftliche Entscheidungen zur Codequalität: bei kritischen Komponenten, die eine hohe Veränderbarkeit haben müssen, in eine ausreichend hohe Codequalität zu investieren. Bei belegbar unwichtigen Komponenten, von denen eine niedrige bis gar keine Veränderbarkeit erwartet wird, könnte somit deutlich weniger in diese Richtung investiert werden.
Bei der Übersetzung aus dem Englischen wird bewusst die Pluralform (technische Schulden) gewählt, um herauszustellen, dass es sich dabei um zählbare, messbare und somit tilgbare Posten in der Softwareentwicklung handelt und nicht etwa um eine nebulöse Eigenschaft, deren Auswirkungen in der Softwareentwicklung zwar zu spüren sind, über deren Ursachen und Steuerbarkeit hingegen keine Klarheit besteht.
Die verschiedenen Phasen im Softwarelebenszyklus sind in Abbildung 1.1 dargestellt – die Phasen „Deployment“ und „Betrieb“ werden nicht dediziert behandelt.

Abbildung 1.1: Softwarelebenszyklus
Veränderbarkeit von Software ist ein unumstrittener Erfolgsfaktor für ihre Projektierung und Wartung und stellt gleichermaßen den Dreh- und Angelpunkt des Managements technischer Schulden dar. Eine beeinträchtigte Veränderbarkeit von Software und die folglich geringere Flexibilität bzgl. sich ändernder (Markt-)Anforderungen ist eines der zwei Hauptrisiken technischer Schulden.
Unsicherheit im Softwareprojektmanagement stellt das andere große Risiko dar. In diesem Zusammenhang soll beschrieben werden, wie das Management technischer Schulden als Chance genutzt werden kann, um Veränderbarkeit von Software zu erhöhen bzw. mit zunehmender Komplexität aufrechtzuerhalten und Unsicherheit in der Softwareentwicklung zu reduzieren bzw. nicht ansteigen zu lassen. Folglich richtet sich dieser shortcut vorrangig an Softwareentwickler und -architekten, Analysten, Projektmanager und Tester und beantwortet praxisorientiert folgende Fragen:
- Was sind technische Schulden? Dazu wird das grundlegende Prinzip anhand der Gegenüberstellung von bewusst mit unbewusst aufgenommenen technischen Schulden erläutert. Darauf folgen Szenarien zur Veranschaulichung der Wechselbeziehungen unterschiedlicher technischer Schulden. Abschließend werden die Gültigkeitsgrenzen der Metapher der technischen Schulden und die daraus abgeleiteten Herausforderungen als Legitimation für das Management technischer Schulden diskutiert.
- Wie kann ein Modell für die Beschreibung technischer Schulden aussehen? Wie im weiteren Verlauf des shortcuts beschrieben wird, sind technische Schulden interdisziplinär: Sie können in verschiedenen Phasen der Softwareentwicklung entstehen und sich gegenseitig bedingen – auch phasenübergreifend. Um diesem Umstand Rechnung zu tragen und technische Schulden greifbarer zu machen, wird ein zusammenhängendes Modell zur Beschreibung technischer Schulden mit einer konsistenten Nomenklatur erarbeitet, das Ursachen, Eigenschaften und Auswirkungen technischer Schulden beschreibt. Dieses Modell soll als Grundlage für das Management technischer Schulden im Berufsalltag der Softwareentwicklung dienen.
- Wo und weshalb entstehen technische Schulden, wie sehen sie aus und welche Auswirkungen haben sie? Auf Basis des erarbeiteten Modells (Frage 2) erfolgt eine praxisorientierte Betrachtung technischer Schulden. Dabei werden die verschiedenen Typen technischer Schulden vorgestellt sowie ausgewählte technische Schulden exemplarisch anhand konkreter Ursachen, Eigenschaften und Auswirkungen beschrieben.
Was sind technische Schulden?
Technische Schulden bezeichnen die Auswirkungen infolge technisch ungünstiger Kompromisse. Dabei können technische Schulden bewusst aufgenommen werden oder aber sich unbemerkt anhäufen. Bewusst aufgenommene technische Schulden können sinnvoll sein und sogar situationsbezogen als Projekthebel eingesetzt werden, sofern sie kontrollierbar sind. Das heißt, sie sind sichtbar, ihre Ursachen sind dokumentiert, sie sind (näherungsweise) bzgl. Behebungsaufwänden sowie Auswirkungen bewertbar, und es liegt ein Tilgungsplan vor.
Jeder Kompromiss birgt in der Regel Risiken und Chancen. Folglich sind unbewusst aufgenommene technische Schulden gleichbedeutend mit verborgenen Risiken. Diese so genannten „Unknown Unknowns“ gelten im Risikomanagement als besonders große Gefahr, da man für sie keine Gegenmaßnahmen einplanen kann. Daher stellen unbewusst aufgenommene technische Schulden ein unwägbares Risiko für Softwareprojekte, -produkte und -hersteller dar. Sie sind nirgends dokumentiert, was die Zuverlässigkeit von Zeit- und Ressourcenplanung verringern kann. Sie fallen erst nach Eintreten überraschender und ungünstiger Symptome auf, wie z. B.:
- unerwartet schlechte Veränderbarkeit der Codebasis
- überraschende Fehler
- unerwartet geringe Testbarkeit der Codebasis
- auf den ersten Blick hin nicht nachvollziehbare Seiteneffekte
Der Weg von diesen Symptomen zu nachvollziehbaren technischen Schulden führt häufig über Analyseaufwände, die nicht im Zeitplan vorgesehen waren, ebenso wenig wie die daraufhin für nötig befundenen Refactoring-Aufwände. Die Wechselwirkungen zwischen den einzelnen Phasen des Softwarelebenszyklus können zusätzlich für eine Fehlerfortpflanzung sorgen.
Als griffiges Beispiel seien unvollständige Anforderungen und schlechte Codequalität genannt, die das vernünftige Testen an bestimmten Stellen unmöglich machen. Eine eingangs unvollständig beschriebene Anforderung führt kurz vor geplantem Releasedatum zu einem Defect, der zufällig durch exploratives Testen bemerkt wird. Dieser Defect hätte mit entsprechenden Unit Tests wesentlich früher aufgedeckt und anschließend behoben werden können. Doch das Schreiben von Unit Tests für anforderungskritische Stellen im Code war infolge schlechter Codequalität nicht möglich.
Eine Analyse der Situation ergibt als Gründe eine geringe Veränderbarkeit sowie Parametrierbarkeit der betroffenen Codebereiche, konkreter:
- Die betroffenen Codebereiche haben eine hohe zyklomatische Komplexität.
- An vielen Stellen wird das Single Responsibility Principle verletzt.
- Die Konstruktoren kritischer Klassen verletzen Prinzipien der Dependency Injection. Dies führt dazu, dass die Fachlogik nicht mit den für Unit Tests erforderlichen Objektgrafen betankt werden kann.
Die eigentliche Behebung von Defects wurde im Projektplan mittels eines Risikoaufschlags berücksichtigt – die für die Behebung des Defects benötigten Refactorings allerdings nicht. Solche Fälle sorgen zumindest für Verzögerungen und zusätzliche Aufwände. Eine entsprechende Häufung solcher Fälle kann durchaus den Projekterfolg gefährden. Außerdem ist der Erfolg der Defect-Behandlung kritisch zu sehen, denn mangels Codequalität ist auch die Qualität des Fixes in Frage zu stellen: Welche Auswirkungen hat er neben denen auf den gefundenen Defect? Die typische Antwort auf diese Frage liefern Regressionstests. Diese erfordern im Rahmen automatisierter Entwicklertests (z. B. Unit Tests, Integrationstests) allerdings eine ausreichend hohe Codequalität [2], die in diesem und ähnlichen Fä...

