Definition: Was sind technische Schulden?
Technische Schulden sind die Kosten, die entstehen, wenn in der Softwareentwicklung einfachere, schnellere oder kostengünstigere Lösungen gewählt werden. Diese sind oft eingeschränkt, anstatt den optimalen Ansatz zu verfolgen, der mehr Zeit benötigt. Häufig liegt das an Zeitdruck, Budgetbeschränkungen oder mangelndem Bewusstsein für zukünftige Anforderungen. Mit der Zeit summieren sich diese Kosten und machen Softwareanwendungen sowie Systeme anfällig und ineffizient.
Häufige Ursachen für technische Schulden sind:
- nicht skalierbare Architekturen und Designs, die mit wachsender App an ihre Grenzen stoßen;
- geschäftlicher Druck, der zur Veröffentlichung von Code mit Fehlern und Mängeln führt;
- Code wird ohne unterstützende Dokumentation erstellt und veröffentlicht;
- Refactoring wird aufgeschoben, wodurch ineffizienter oder schwer editierbarer Code bestehen bleibt;
- es wurden keine ordnungsgemäßen Tests durchgeführt;
- unklare oder unvollständige Definition der funktionalen und technischen Anforderungen;
- keine verfügbare Testumgebung;
- keine Anpassung an Standards wie branchenübliche Funktionen, Frameworks oder Technologien;
- fehlende Verfahren zur Bewertung und Messung der Auswirkungen von Abkürzungen;
- Änderungen der Spezifikationen in letzter Minute;
- ausgelagerte Softwareentwicklung, die interne technische Unterstützung erfordert, um den Code zu verbessern oder neu zu schreiben;
- parallele Entwicklungspfade mit Änderungen, die überstürzt zu einer einzigen Codebasis zusammengeführt werden;
- unzureichende technische Führung;
- überhastete Veröffentlichung von Software, ohne den Code vollständig zu optimieren;
- Auswahl veralteter oder ungeeigneter Technologien zur schnellen Zielerreichung;
- eng verknüpfte Softwarekomponenten, die Anpassungen erschweren.
Es gibt zwar einen kurzfristigen Erfolg, da die Bereitstellung beschleunigt wird – allerdings entstehen Schulden in Form von erhöhter Komplexität und mehr Kosten für zukünftige Codeänderungen. Genau wie bei finanziellen Schulden fallen auch bei technischen Schulden Zinsen an. Je länger die Kompromisse bestehen bleiben, desto mehr Zeit, Aufwand und Ressourcen wird die spätere Behebung kosten.
Technische Schulden können zu einer unübersichtlichen Codebasis führen, die schwer zu verstehen, zu warten oder zu erweitern ist.
Dies kann die Entwicklung neuer Funktionen verlangsamen, die Wahrscheinlichkeit von Fehlern erhöhen und die Performance und Stabilität der Software beeinträchtigen. Zudem führt es zu einer geringeren IT-Effizienz.
Woher stammt der Begriff technische Schulden?
Der Begriff „technische Schulden“ wird Ward Cunningham zugeschrieben. Er verwendete ihn 1992 bei einer Präsentation auf der OOPSLA-Konferenz (Object-Oriented Programming, Systems, Languages & Applications). Er beschrieb damit Kompromisse in der Softwareentwicklung, die die Bereitstellung beschleunigen, aber die Komplexität und Kosten zukünftiger Änderungen erhöhen können. Dabei zog er eine Parellele zu finanziellen Schulden. Die Metapher hat sich seitdem in der Softwarebranche etabliert, um zu verdeutlichen, dass kurzfristige Lösungen später zu höheren Kosten führen können.
So entstehen technische Schulden in der Softwareentwicklung
Technische Schulden werden in verschiedenen Phasen der traditionellen Softwareentwicklung aufgenommen (Funktionsentwicklung, Alpha-, Beta- und Golden-Master-Version). In der Regel werden Bugs in jeder Phase der Funktionsentwicklung entdeckt. Einige werden behoben, andere werden in einer späteren Entwicklungsphase gelöst.
In der Alpha-Phase werden die Bugfixes beispielsweise nach Priorität geordnet. Entscheidend ist, welche für den Übergang zur Beta-Phase erforderlich sind. Diese Bugs sollen dann in der Beta-Phase behoben werden. Gleichzeitig werden jedoch unweigerlich neue Bugs entdeckt, sodass die Liste der Bugfixes wächst. Derselbe Ablauf wiederholt sich in der Golden-Master-Phase. Obwohl es in der Golden-Master-Phase keine offenen Bugs mehr geben sollte, ist es üblich, bekannte Bugs zu beheben und andere auf die nächste Version zu verschieben.
Technische Schulden häufen sich an und führen zu einer wachsenden Anzahl von Bugs, die immer schwieriger zu beheben sind. Diese Bugs verursachen nicht nur unzufriedene Benutzer, sondern verlangsamen auch die Entwicklung und erhöhen die Kosten für ihre Behebung. Wird eine Änderung an einem bestimmten Teil des Codes beauftragt, sind oft zusätzliche Anpassungen in anderen Bereichen der Software sowie Aktualisierungen der Dokumentation erforderlich.
Auswirkungen von technischen Schulden über Entwicklungsteams hinaus
Technische Schulden werden mit der Softwareentwicklung in Verbindung gebracht, haben aber Auswirkungen auf das gesamte Unternehmen.
- Erhöhte Kosten
Technische Schulden sind durch zukünftige Kosten und Herausforderungen gekennzeichnet. Ähnlich wie finanzielle Schulden müssen sie später beglichen werden. Die Behebung erfordert in der Regel zusätzliche Ressourcen, Zeit und Aufwand, um Probleme zu lösen, die aus suboptimalen Entwicklungsentscheidungen entstanden sind. - Betriebliche Probleme
Technische Schulden können den gesamten Betrieb beeinträchtigen. Sie führen zu Ineffizienzen, geringerer Produktivität, höheren Wartungskosten, Systemausfällen und Sicherheitslücken. - Geringere Agilität
Unternehmen mit hohen technischen Schulden haben es schwerer, sich an Marktveränderungen und neue Technologien anzupassen. - Qualitätsprobleme
Angesammelte technische Schulden führen oft zu mehr Bugs und instabilen Systemen. Das beeinträchtigt die Benutzerfreundlichkeit und kann zu unzufriedenen Kunden führen.
Was zählt zu den technischen Schulden und was nicht?
Technische Schulden:
- Probleme mit der Codequalität
Schlecht geschriebener Code ist schwer zu lesen und zu warten. Probleme entstehen, wenn der Code nicht den Best Practices entspricht oder nicht ins Gesamtdesign des Systems passt. Typische Beispiele für technische Schulden in diesem Bereich sind Spaghetti-Code, mangelnde Modularität, doppelter Code und übermäßig lange Methoden. - Verspätetes Refactoring
Wird notwendiges Refactoring aus Zeitmangel oder aufgrund anderer Prioritäten aufgeschoben, häufen sich technische Schulden an. Dies erhöht die Komplexität und senkt die Produktivität, da neuer Code auf einer instabilen Basis aufbaut. - Unzureichende Tests
Eine geringe Testabdeckung, fehlende automatisierte Tests oder ausgelassene Tests zur Einhaltung von Fristen können schwerwiegende Folgen haben. Mängel und Bugs werden oft erst spät im Entwicklungsprozess oder nach der Bereitstellung entdeckt. - Fehlende Dokumentation
Unzureichende oder veraltete Dokumentation erschwert es neuen Teammitgliedern, das System zu verstehen. Auch bestehende Teammitglieder haben Schwierigkeiten, sich an die Gründe für bestimmte Entscheidungen zu erinnern. - Veraltete Technologien
Der Einsatz veralteter Technologien, Sprachen, Bibliotheken oder Frameworks kann technische Schulden verstärken. Besonders problematisch wird es, wenn diese Entscheidungen die Integration mit modernen Systemen behindern. - Suboptimale Architekturentscheidungen
Nicht skalierbare, zu komplexe oder veraltete Systemarchitekturen führen zu technischen Schulden. Sie erschweren die Implementierung neuer Funktionen und Technologien und bremsen die Weiterentwicklung.
Keine technischen Schulden:
- Ineffiziente Geschäftsabläufe
Unproduktive Geschäftsprozesse oder ineffizientes Projektmanagement fallen nicht unter technische Schulden. Sie betreffen nicht die technischen Aspekte der Codebasis oder Architektur. - Funktionsanforderungen und Produktrückstand
Ein Rückstand an Funktionen oder Erweiterungen zählt nicht zu technischen Schulden. Auch wenn diese noch umgesetzt werden müssen, sind sie nicht das Ergebnis früherer Kompromisse oder Abkürzungen. Zudem stehen sie nicht im Zusammenhang mit Qualitätsproblemen im Code oder Systemdesign. - Lernen und Experimentieren
Lernen, Experimentieren und iterative Verbesserungen sind kein Bestandteil technischer Schulden. Frühere Versionen eines Produkts folgen möglicherweise nicht den später ermittelten Best Practices, doch diese Entwicklung ist ein natürlicher Teil der Softwareentwicklung. - Normale Aufgabenpriorisierung
Die Entscheidung, bestimmte Funktionen später zu implementieren oder einer Funktion aus geschäftlichen Gründen Vorrang zu geben, stellt keine technischen Schulden dar. - Nicht umgesetzte Optimierung
Nicht optimierter Code ist nicht automatisch eine technische Schuld. Verfrühte Optimierung kann sogar die Komplexität erhöhen. Technische Schulden entstehen erst, wenn notwendige Optimierungen kontinuierlich aufgeschoben werden. - Probleme mit Benutzererfahrung / User Experience (UX)
Eine nicht benutzerfreundliche Oberfläche zählt nicht zu technischen Schulden, auch wenn sie optimierungsbedürftig ist. Erst wenn Entscheidungen getroffen werden, die künftige Verbesserungen der Benutzeroberfläche oder des Benutzererlebnisses erheblich einschränken, entstehen technische Schulden.
Arten von technischen Schulden
In der Softwareentwicklung können verschiedene Arten von technische Schulden auftreten. Jede Art hat ihre eigenen Ursachen, Herausforderungen und Konsequenzen. Daher sind spezifische Strategien erforderlich, um sie zu verwalten und zu lösen. Im Folgenden finden Sie Beispiele für die vielen Arten von technischen Schulden. Welche Art vorliegt, hängt von der zugrunde liegenden Entscheidung oder dem Verhalten ab, das dazu geführt hat:
- Unbeabsichtigte technische Schulden
Diese Schulden entstehen ungewollt. Das Entwicklungsteam ist sich ihrer Existenz nicht bewusst, bis sie während der normalen Arbeit oder durch Tests aufgedeckt werden. - Bekannte technische Schulden
Das Entwicklungsteam ist sich dieser Schulden bewusst und entscheidet sich bewusst dafür, sie in Kauf zu nehmen. - Gezielte technische Schulden
Diese technischen Schulden sind bekannt und werden gezielt in den Refactoring-Prozess eingeplant.
Schulden aufnehmen beschreibt die Anhäufung von Komplikationen und Ineffizienzen in der Softwareentwicklung. Sie entstehen durch übereilte Builds und unzureichende anfängliche Setups und müssen später durch Nacharbeiten behoben werden.
Codeschulden entstehen durch Probleme in der Codebasis. Dazu gehören schlechte Codierungspraktiken, mangelnde Standardisierung, unzureichende Codekommentare sowie veraltete oder ineffiziente Codierungstechniken. Codeschulden erschweren die Wartung und Skalierbarkeit des Codes.
Mängelschulden umfasst ungelöste Bugs und Probleme, die sich im Laufe der Zeit in der Software ansammeln. Deren Behebung erfordert umfangreiche Korrekturen und Tests, um die Zuverlässigkeit und Funktion der Software langfristig zu gewährleisten.
Abhängigkeitsschulden entstehen, wenn sich Entwickler auf veraltete oder nicht unterstützte Bibliotheken, Frameworks oder Tools von Drittanbietern verlassen. Dadurch können Sicherheitslücken und Integrationsprobleme auftreten.
Design- oder Architekturschulden resultieren aus fehlerhafter oder veralteter Softwarearchitektur oder -design. Beispiele sind übermäßig komplexe Entwürfe, unsachgemäße Verwendung von Mustern oder mangelnde Modularität. Solche Schulden behindern die Skalierbarkeit und erschweren die Einführung neuer Funktionen.
Dokumentationsschulden sind unzureichende oder veraltete Unterlagen. Sie erschweren es sowohl neuen als auch bestehenden Teammitgliedern, das System und die Entscheidungsgründe zu verstehen. Dies beeinträchtigt die Effizienz der Wartung und Weiterentwicklung.
Infrastrukturschulden betreffen die Umgebung, in der die Software betrieben wird. Dazu gehören veraltete Server, unzureichende Bereitstellungspraktiken oder das Fehlen von Notfallwiederherstellungsplänen. Infrastrukturschulden können zu Leistungsproblemen und längeren Ausfallzeiten führen.
Prozessschulden beziehen sich auf ineffiziente oder veraltete Entwicklungsprozesse und -methoden. Beispiele sind schlechte Kommunikationspraktiken, ein Mangel an agilen Methoden und unzureichende Tools für die Zusammenarbeit.
Anforderungsschulden entstehen durch unvollständige oder schlecht definierte Projektanforderungen. Dadurch werden Funktionen entwickelt, die nicht den Bedürfnissen oder Erwartungen der Benutzer entsprechen, was zukünftige Überarbeitungen und zusätzliche Entwicklungsarbeit erforderlich macht.
Service- oder Versionsschulden entstehen, wenn Services oder Komponenten nicht ordnungsgemäß versioniert werden oder wenn Altsysteme ohne angemessene Support- oder Integrationsfunktionen genutzt werden.
Technische Fähigkeitsschulden oder menschliche Schulden entstehen, wenn dem Team bestimmte Fähigkeiten oder Kenntnisse fehlen. Das führt zu suboptimalen Lösungen. Investitionen in Schulungen und Weiterbildungen können helfen, diese Schulden zu reduzieren.
Testschulden resultieren aus unzureichenden Tests, einschließlich fehlende Modultests, Integrationstests oder eine mangelnde Testabdeckung. Diese Schulden erhöhen das Risiko von Fehlern und Bugs in der Produktion, was möglicherweise zu Systemausfällen und Unzufriedenheit bei den Kunden führt. Auch eine unzureichende Testautomatisierung trägt zur Entstehung dieser Schulden bei.
Kategorisierung von technischen Schulden
Die verschiedenen Arten von technischen Schulden lassen sich im Allgemeinen in vier Kategorien einteilen. Sie basieren sowohl auf der Absicht als auch auf dem Kontext wie ursprünglich von Martin Fowler definiert. Technische Schulden werden zunächst nach ihrer Absicht klassifiziert – also ob sie absichtlich oder unabsichtlich entstanden sind. Anschließend erfolgt eine weitere Unterteilung in umsichtige oder unbedachte Schulden.
#sp-tw-styles main ol { list-style: decimal; padding-left: 2rem;} #sp-tw-styles main ol li, #sp-tw-styles main ul li { font-size: 1.125rem; line-height: 1.75rem; }
Umsichtige und absichtliche technische Schulden
Ein Team kann sich bewusst dafür entscheiden, ein Produkt schnell auf den Markt zu bringen und potenzielle Probleme später zu lösen. Diese Form technischer Schulden wird als umsichtig und absichtlich bezeichnet. Sie wird gewählt, wenn die Vorteile einer frühen Markteinführung die Risiken und späteren Kosten überwiegen. Das Team nimmt diese Schulden in Kauf, da die schnelle Marktpräsenz strategisch wichtiger ist als die langfristigen Aufwände zur Behebung der technischen Defizite.
Unbedachte und absichtliche technische Schulden
Hierbei kennt das Team zwar die besten Programmierpraktiken, entscheidet sich aber bewusst für eine schnelle Bereitstellung auf Kosten der Qualität. Diese Schulden werden als unbedacht und absichtlich eingestuft. Die kurzfristige Priorität liegt auf Geschwindigkeit, obwohl die langfristigen Nachteile bekannt sind.
Umsichtige und unabsichtliche technische Schulden
Diese Schulden entstehen, wenn ein Team zunächst versucht, optimalen Code zu entwickeln, später aber eine bessere Lösung entdeckt. Umsichtige und unbeabsichtigte technische Schulden treten auf, wenn Erkenntnisse nach der Implementierung eine effektivere Herangehensweise offenbaren, die zuvor nicht erkennbar war.
Unbedachte und unabsichtliche technische Schulden
Hier versucht ein Team, qualitativ hochwertigen Code zu schreiben, macht jedoch unwissentlich Fehler aufgrund mangelnder Erfahrung oder unzureichenden Fachwissens. Unbedachte und unabsichtliche technische Schulden entstehen, wenn die Auswirkungen von Entscheidungen nicht vollständig verstanden werden. Dies kann zu unerwarteten Komplikationen führen, die erst später sichtbar werden.
Wie denken Unternehmen über technische Schulden?
Kluge Unternehmen betrachten technische Schulden mit einer Mischung aus Vorsicht und Strategie. Sie erkennen sie als unvermeidlichen Aspekt der Softwareentwicklung und entwickeln gezielte Ansätze, um sie zu verwalten. Die wichtigsten Überlegungen umfassen:
Kontinuierliches Monitoring und Refactoring
Unternehmen führen regelmäßige Code-Audits durch, um technische Schulden zu identifizieren und zu bewerten. Diese werden oft mit geplanten Refactoring-Initiativen kombiniert, um Schulden systematisch abzubauen. So bleibt die Codebasis sauber, effizient und wartbar.
Aufklärung der Stakeholder
Viele Unternehmen investieren in die Aufklärung ihrer Stakeholder über technische Schulden. Ziel ist es, ein Verständnis für deren Bedeutung zu schaffen und Investitionen in Qualitäts- und Wartungsinitiativen zu fördern. Dazu gehört die Schulung von Entwicklungsteams in Best Practices für Programmierung und Systemdesign, um unnötige Schulden zu vermeiden.
Sensibilisierung und Beteiligung der Führungskräfte
In größeren Unternehmen sind Führungskräfte oft stärker für technische Schulden sensibilisiert. Sie verstehen, dass nicht verwaltete technische Schulden die Innovationsfähigkeit und Wettbewerbsfähigkeit des Unternehmens erheblich beeinträchtigen können. Daher engagieren sie sich aktiver in deren Management.
Investitionen in Qualität und Exzellenz
Unternehmen setzen oft auf Qualitätssicherung, kontinuierliche Integration und Bereitstellungspraktiken sowie auf die Einführung von Programmierstandards, um neue technische Schulden zu verhindern. Dazu gehören regelmäßige Code-Reviews, automatisierte Tests und Refactoring im Rahmen des Entwicklungslebenszyklus.
Risikomanagement
Technische Schulden sind oft in die umfassenderen Risikomanagement-Frameworks integriert. Unternehmen bewerten Risiken wie Sicherheitslücken, Systemausfälle oder Performance-Probleme und analysieren, wie diese mit anderen geschäftlichen Risiken zusammenhängen.
Strategisches Asset-Management
Unternehmen betrachten technische Schulden als Aspekt ihrer Software-Assets. Ähnlich wie finanzielle Schulden erfordern sie eine regelmäßige Verwaltung. Dazu gehören regelmäßige Prüfungen und Bewertungen, um die Auswirkungen auf das Unternehmen zu ermitteln. Auf Basis einer Kosten-Nutzen-Analyse wird entschieden, ob sie getilgt werden sollten oder ob man mit ihnen leben kann.
Setzen Sie technische Schulden vorsichtig ein
An und für sich sind technische Schulden weder gut noch schlecht. Es handelt sich einfach um etwas Geliehenes, das zurückgezahlt werden muss. Genau wie bei finanziellen Schulden kann die Aufnahme technischer Schulden unter bestimmten Umständen der richtige Schritt sein. Wenn Sie sich dafür entscheiden, ist es wichtig, dass das Entwicklungsteam die positiven und negativen Aspekte der technischen Schulden versteht.
