Kleine Schritte, große Wirkung: Softwareentwicklung in kurzen Zyklen

Kleine Commits, Trunk-Based Development, Feature Flags und eine Deployment-Pipeline: wie Teams Software jederzeit auslieferbar halten
Aktualisiert:
Abstract
- #Softwareentwicklung
- #evolutionär
- #Continuous Delivery
- #Deployment-Pipeline
- #Trunk-Based Development
- #Feature Flags
- #Agilität
- #Testautomatisierung
- #Softwarequalität
- #Entwicklungsprozess
- #Agile Methoden
Warum der einfachste Entwicklungsprozess oft der robusteste ist
Freitagnachmittag, ein Entwickler führt einen Feature-Branch zusammen, an dem er drei Wochen gearbeitet hat. 2.000 geänderte Zeilen, 40 Konflikte, die Tests schlagen an sechs Stellen fehl. Welche Änderung den Fehler verursacht, lässt sich kaum noch sagen. Das Release wird verschoben, das Wochenende auch.
Dieselbe Arbeit, in vierzig kleine Schritte zerlegt, hätte jeden Tag ein paar Dutzend Zeilen in den Hauptzweig gebracht, jede davon getestet und jede einzeln rückgängig zu machen. Die Idee klingt banal, doch sie ist der Kern dessen, was unter Continuous Integration und Continuous Delivery verstanden wird: Ein Team, das in sehr kleinen Schritten arbeitet und jeden Schritt sofort prüft, kommt verlässlicher ans Ziel als eines, das große Pakete schnürt.
Softwareentwicklung ist vor allem Lernen
Im Kern löst Softwareentwicklung Probleme für andere Menschen. Dafür sind drei Dinge nötig: das Problem verstehen, eine Lösung bauen und prüfen, ob das Problem tatsächlich gelöst ist. Entsprechend braucht es drei Bausteine: eine Anforderung, die das Problem beschreibt, Code, der es löst, und Tests, die das bestätigen. Alles andere im Prozess sollte diesen drei Bausteinen dienen.
Die Schwierigkeit liegt darin, dass am Anfang niemand alle Antworten kennt. Nutzerinnen und Nutzer wissen oft selbst nicht genau, was sie brauchen, bis sie eine erste Version sehen. Auch die technische Lösung zeigt ihre Schwächen erst, wenn sie gebaut wird. Softwareentwicklung ist deshalb in erster Linie ein Lernprozess. Wer lernen will, braucht schnelle Rückmeldung, und schnelle Rückmeldung gibt es nur bei kleinen Schritten.
Warum kleine Schritte Fehler billig machen
Jede Änderung ist eine kleine Wette darauf, dass sie funktioniert und das Richtige tut. Kleine Wetten haben einen großen Vorteil: Geht eine schief, ist der Schaden überschaubar.
- Fehler fallen früher auf. Wer nach zwanzig Minuten testet, findet den Fehler in zwanzig Minuten Arbeit. Wer nach drei Wochen testet, sucht in drei Wochen Arbeit.
- Rückgängig machen ist einfach. Ein kleiner Commit lässt sich mit
git revertzurücknehmen, ohne andere Arbeit zu verlieren. - Reviews werden besser. Eine Änderung von 50 Zeilen liest eine Kollegin aufmerksam. Bei 2.000 Zeilen wird meist nur noch überflogen.
- Änderungskosten bleiben flach. Ein System, das ständig in kleinen Schritten verändert wird, bleibt in einem Zustand, in dem es sich verändern lässt. Spätere Kurswechsel kosten dann nicht dramatisch mehr als frühe.
Der letzte Punkt ist der wichtigste. Klassische Projektplanung geht davon aus, dass Änderungen umso teurer werden, je später sie kommen. Teams, die in kleinen Schritten arbeiten und gut testen, können diese Kurve abflachen. Dazu gehört auch, Komplexität bewusst klein zu halten. Wie das auf Ebene der Architektur gelingt, beschreibt der Beitrag Software-Komplexität verstehen und reduzieren.
Kleine Commits und kurze Branches im Alltag
Continuous Integration bedeutet im ursprünglichen Sinn nicht „wir haben einen CI-Server“, sondern: Alle Beteiligten führen ihre Änderungen mindestens einmal täglich im gemeinsamen Hauptzweig zusammen, und ein automatischer Build prüft jedes Mal, ob alles noch zusammenpasst. Viele erfahrene Teams integrieren deutlich häufiger, mehrmals am Tag.
Die Praxis dazu heißt Trunk-Based Development. Entwickler:innen arbeiten direkt auf dem Hauptzweig oder auf Branches, die nur wenige Stunden bis höchstens ein, zwei Tage leben. Lange Feature-Branches sind tabu. Das klingt nach einer Einschränkung, beseitigt aber das Problem aus dem Einstieg: Große Zusammenführungen mit vielen Konflikten entstehen gar nicht erst.
Damit das funktioniert, helfen ein paar Gewohnheiten:
- Eine Änderung, ein Zweck. Ein Commit behebt einen Fehler oder ergänzt einen Teil einer Funktion, nicht beides. Umbauten am bestehenden Code („Refactoring“) kommen in eigene Commits.
- Immer grün. Nach jedem Commit läuft die Software und alle Tests sind bestanden. Bricht der Build, hat die Reparatur Vorrang vor neuer Arbeit.
- Große Aufgaben zerlegen. Angenommen, ein Webshop bekommt eine neue Zahlungsart. Statt alles auf einmal zu bauen, entstehen nacheinander die Schnittstelle zum Zahlungsdienst, die Datenbankfelder, die Logik im Bestellprozess und zuletzt die Oberfläche, jeweils getestet und eingebunden.
Wie eine Pipeline aussieht, die jede dieser Änderungen automatisch prüft, zeigt der Beitrag Continuous Integration: Wie CI Ihr Entwicklungsteam verändert.
Feature Flags: Unfertiges ausliefern, ohne es freizuschalten
Wenn jede Änderung täglich im Hauptzweig landet, liegt dort auch Code für Funktionen, die noch nicht fertig sind. Damit Kundinnen und Kunden davon nichts merken, setzen Teams Feature Flags ein: Schalter, über die sich ein Codepfad zur Laufzeit ein- oder ausschalten lässt.
// Minimaler Feature-Flag-Mechanismus. In größeren Systemen übernimmt das
// meist ein Flag-Dienst oder eine Bibliothek nach dem OpenFeature-Standard.
type FlagName = 'neuerCheckout' | 'wunschliste';
type Warenkorb = { positionen: string[]; summe: number };
declare function renderNeuerCheckout(warenkorb: Warenkorb): string;
declare function renderAlterCheckout(warenkorb: Warenkorb): string;
const flags: Record<FlagName, boolean> = {
neuerCheckout: process.env.FLAG_NEUER_CHECKOUT === 'true',
wunschliste: false,
};
export function isEnabled(flag: FlagName): boolean {
return flags[flag];
}
// Der neue Pfad ist bereits ausgeliefert, bleibt aber aus, bis das Flag gesetzt ist.
export function renderCheckout(warenkorb: Warenkorb): string {
return isEnabled('neuerCheckout')
? renderNeuerCheckout(warenkorb)
: renderAlterCheckout(warenkorb);
}
Feature Flags trennen zwei Dinge, die oft vermischt werden: das Deployment, also das technische Ausliefern von Code, und das Release, also das Freischalten einer Funktion für Nutzer. Ein Team kann eine neue Funktion zuerst nur intern einschalten, dann für einen kleinen Teil der Kundschaft und erst zum Schluss für alle. Geht etwas schief, wird das Flag zurückgesetzt, ohne neues Deployment.
Flags haben allerdings ihren Preis. Jeder Schalter verdoppelt die möglichen Pfade durch den Code. Wer Flags nach der Freischaltung nicht wieder entfernt, sammelt schnell eine eigene Art technischer Schulden an. Bewährt hat sich, für jedes Flag schon beim Anlegen ein Ablaufdatum oder eine Aufgabe zum Entfernen festzulegen.
Für größere Umbauten gibt es verwandte Muster. Bei Branch by Abstraction wird hinter einer Schnittstelle zuerst die neue Implementierung gebaut, während die alte weiterläuft, und dann umgeschaltet. Bei Datenbankänderungen hilft das Expand-Contract-Muster: erst neue Spalten oder Tabellen ergänzen, dann den Code umstellen, zuletzt Altes entfernen. Jeder dieser Schritte ist für sich auslieferbar.
Von der Idee zur ausführbaren Spezifikation
Kleine Schritte beginnen nicht erst beim Code, sondern bei der Anforderung. Eine neue Funktion startet meist als vage Idee. Der erste Schritt ist, sie präziser zu fassen, etwa als User Story aus Sicht der Nutzer: „Als Kundin möchte ich Artikel für später merken, damit ich sie nicht erneut suchen muss.“ Die Story beschreibt den Bedarf, nicht die Lösung. Wie die Merkfunktion technisch umgesetzt wird, entscheidet das Team.
Im zweiten Schritt entstehen konkrete Beispiele, die zeigen, wann der Bedarf erfüllt ist. Sie bilden die Akzeptanzkriterien. Im dritten Schritt werden diese Beispiele so formuliert, dass sie sich automatisch ausführen lassen. Ein verbreitetes Format dafür ist Gherkin mit seiner Struktur aus Ausgangslage, Aktion und erwartetem Ergebnis:
# language: de
Funktionalität: Wunschliste
Szenario: Artikel für später merken
Angenommen eine angemeldete Kundin sieht die Produktseite "Wanderschuh Alpina"
Wenn sie "Auf die Wunschliste" wählt
Dann enthält ihre Wunschliste den Artikel "Wanderschuh Alpina"
Und der Warenkorb bleibt unverändert
Solche ausführbaren Spezifikationen haben zwei Vorteile. Sie halten fest, was das System tun soll, ohne festzulegen, wie. Und sie prüfen bei jeder späteren Änderung automatisch, ob das Verhalten noch stimmt. Auf Ebene einzelner Funktionen und Klassen setzt Test-Driven Development dasselbe Prinzip um: erst den Test schreiben, dann den Code. Mehr dazu im Beitrag Test-Driven Development: Was TDD für die Softwarequalität leistet.
Die Deployment-Pipeline: von jedem Commit bis zur Produktion
Den organisatorischen Rahmen für kleine Schritte bildet die Deployment-Pipeline. Jede Änderung durchläuft dieselbe automatisierte Kette von Prüfungen. Besteht sie alle, ist sie auslieferbar. Das Konzept haben Jez Humble und David Farley 2010 in ihrem Buch „Continuous Delivery“ ausführlich beschrieben.
Commit-Stufe: schnelle Rückmeldung
Die erste Stufe ist im Wesentlichen Continuous Integration. Sie kompiliert den Code, führt die schnellen Unit-Tests aus und prüft statisch auf typische Fehler. Ziel ist eine Rückmeldung innerhalb weniger Minuten, damit Entwickler:innen noch gedanklich bei ihrer Änderung sind. Das Ergebnis dieser Stufe ist ein fertiges Artefakt, etwa ein Container-Image, das ab hier unverändert weitergereicht wird.
Akzeptanzstufe: Lässt sich die Software ausliefern?
Das Artefakt wird in eine produktionsähnliche Testumgebung ausgerollt, mit denselben Werkzeugen und Konfigurationsmechanismen wie später in der Produktion. So wird nicht nur der Code geprüft, sondern auch der Weg dorthin. Anschließend laufen die ausführbaren Spezifikationen gegen das laufende System.
Weitere Prüfungen und Freigabe
Je nach System folgen Last- und Sicherheitstests oder eine manuelle explorative Prüfung. Am Ende steht die Entscheidung, ob ausgeliefert wird. Bei Continuous Delivery ist jede Version, die alle Stufen bestanden hat, auslieferbar, die Entscheidung trifft ein Mensch. Bei Continuous Deployment geht jede erfolgreiche Version automatisch in Produktion.
Nebeneffekte: Dokumentation und Nachvollziehbarkeit
Wer ausführbare Spezifikationen sauber formuliert, bekommt eine lebende Dokumentation des Systemverhaltens, die nie veraltet, weil sie bei jedem Build geprüft wird. Aus denselben Daten lassen sich Release Notes zumindest teilweise automatisch erzeugen.
Ist die Pipeline der einzige Weg in die Produktion, entsteht außerdem ein lückenloser Prüfpfad: Für jede Version ist nachvollziehbar, welche Änderungen sie enthält, wer sie geprüft hat und welche Tests bestanden wurden. Das hilft in regulierten Branchen wie Finanzwesen oder Medizintechnik, wo Nachweise über Änderungen verlangt werden. Ob eine Pipeline die konkreten Anforderungen eines Regelwerks erfüllt, muss allerdings im Einzelfall geprüft werden.
Wo der Ansatz an Grenzen stößt
Kleine Schritte funktionieren für fast jede Art von Software, die Umsetzung ist aber nicht überall gleich einfach.
- Apps in Stores durchlaufen eine Prüfung durch Apple oder Google, bevor eine Version erscheint, bei Apple in der EU für alternative Vertriebswege nur eine reduzierte Notarisierung statt der vollständigen App-Review. Hier helfen Feature Flags, die serverseitig gesteuert werden, damit sich Funktionen unabhängig vom Store-Release schalten lassen.
- Embedded-Software und Geräte lassen sich nicht beliebig oft aktualisieren. Kleine Schritte und automatische Tests im Entwicklungsprozess bleiben trotzdem sinnvoll, ausgeliefert wird nur seltener.
- Altsysteme ohne Tests erlauben zunächst keine sicheren kleinen Schritte. Der erste Schritt ist dann, um die Stellen, die sich ändern sollen, Tests zu legen, die das heutige Verhalten festhalten.
- Organisatorische Hürden wie Änderungsgremien, die nur einmal im Monat tagen, bremsen mehr als jede Technik. Sie lassen sich oft durch nachvollziehbare automatische Prüfungen ersetzen, was aber Überzeugungsarbeit kostet.
Was das für Ihr Team bedeutet
Der Prozess, der hier beschrieben wird, ist nicht kompliziert. Er verlangt aber Disziplin: kleine Commits, ein immer lauffähiger Hauptzweig, automatisierte Tests und eine Pipeline, der das Team vertraut. Für die meisten Teams lohnt es sich, mit der Integrationshäufigkeit anzufangen. Messen Sie, wie lange Branches heute leben, und setzen Sie sich das Ziel, diese Zeit schrittweise zu verkürzen. Die Engpässe, die dabei sichtbar werden, etwa langsame Tests oder manuelle Freigaben, sind genau die Stellen, an denen sich Arbeit lohnt.
Überschätzt wird oft der Aufwand für die Werkzeuge, unterschätzt die Umgewöhnung im Team. Wer jahrelang in großen Paketen gearbeitet hat, muss das Zerlegen von Aufgaben erst üben. Organisatorisch passt das Prinzip zu Arbeitsweisen, die auf feste Auslieferungstermine verzichten, wie sie der Beitrag Das Ende von Scrum? beschreibt.
Wenn Sie eine Pipeline aufbauen oder Ihr Team in Continuous Integration und Continuous Delivery schulen möchten, finden Sie auf unserer Themenseite zur CI/CD-Pipeline mit Beratung, Coaching und Seminaren die passenden Angebote.
Häufige Fragen zum Arbeiten in kleinen Schritten
Wie klein ist ein kleiner Schritt?
Eine feste Grenze gibt es nicht. Eine gute Faustregel: Die Änderung lässt sich in einem Satz beschreiben, in wenigen Minuten reviewen und ohne Nebenwirkungen wieder zurücknehmen. Viele Teams integrieren mehrmals täglich.
Brauchen wir dafür Feature Flags?
Nicht zwingend. Viele Änderungen lassen sich so schneiden, dass sie sofort sichtbar sein dürfen, etwa ein neues Feld, das noch nirgends angezeigt wird. Feature Flags werden wichtig, sobald eine Funktion länger als ein, zwei Tage im Bau ist oder schrittweise für Nutzer freigeschaltet werden soll.
Wie lässt sich ein Team von diesem Vorgehen überzeugen?
Am besten mit einem Experiment. Wählen Sie eine überschaubare Funktion, arbeiten Sie dafür ausschließlich mit kurzen Branches und täglicher Integration, und vergleichen Sie danach Durchlaufzeit, Konflikte und Fehler mit früheren Vorhaben. Eigene Erfahrung überzeugt mehr als Berichte anderer Firmen.
Funktioniert das auch in regulierten Branchen?
Ja, oft sogar besonders gut, weil eine automatisierte Pipeline Änderungen lückenlos dokumentiert. Welche Nachweise ein bestimmtes Regelwerk verlangt, muss aber im Einzelfall geklärt werden, und manche Branchen schreiben zusätzliche manuelle Freigaben vor.
Kategorien
Schlagworte