Software übernehmen heißt Fragen beantworten — nicht Metriken sammeln
Eine Softwareübernahme beginnt mit der Frage, nicht mit der Kennzahl: Welche Belege gibt es, reichen sie, was bleibt offen? Gezeigt an einem konstruierten Beispiel.
Zuletzt aktualisiert am
Wer eine bestehende Software übernimmt, bekommt meist ein Paket: Zugang zum Repository, eine Readme, vielleicht ein Architekturdiagramm und eine Übergabepräsentation. Das gilt nach einem Dienstleisterwechsel genauso wie dann, wenn ein Unternehmen die Weiterentwicklung ins eigene Haus holt. Die Versuchung ist groß, dieses Paket nach seinem Umfang zu beurteilen: Es gibt einen Build, es gibt Tests, es gibt eine Pipeline, und die Testabdeckung liegt vielleicht bei 80 Prozent. Das klingt nach einer übergabefähigen Software.
Ob sie das ist, zeigt diese Liste aber nicht. Im ersten Beitrag dieser Reihe ging es darum, warum eine einzelne Kennzahl eine Übernahmeentscheidung nicht trägt. Dieser Beitrag beschreibt, wie man stattdessen vorgehen kann: Man beginnt nicht mit dem, was sich messen lässt, sondern mit der Frage, die beantwortet werden muss — und prüft dann, ob die vorhandenen Belege dafür ausreichen.
Das Modell: von der Frage zur begründeten Aussage
Der Ablauf hat vier Schritte:
- Frage: Was genau muss das übernehmende Team wissen?
- Belege: Welche technischen Belege gibt es dazu?
- Reichen sie? Passen die Belege zusammen, und decken sie die Frage ab — oder bleibt eine Lücke?
- Aussage: Was lässt sich auf dieser Grundlage begründet sagen, und was nicht?
Mit „Belegen“ ist hier das gemeint, was in diesem Projekt Evidence heißt: nachprüfbare technische Tatsachen. Das kann eine Datei im Repository sein, ein Eintrag in der Build-Konfiguration oder die Ausgabe eines Testlaufs. Daneben gibt es Auskünfte, etwa vom bisherigen Dienstleister. Sie sind oft die einzige Quelle für Wissen, das nicht im Code steht, und deshalb wertvoll. Ein technisch geprüfter Nachweis sind sie aber nicht. Wer eine Auskunft verwendet, sollte deshalb festhalten, von wem sie stammt und ob sie überprüft wurde.
Der Ablauf endet selten nach einem Durchgang. Ein erster Befund wirft oft eine neue Frage auf, und die verlangt eine gezielte Klärung. Zwei Missverständnisse liegen dabei nahe. Dass eine Datei existiert, heißt noch nicht, dass sie aktuell ist, zu den übrigen Dateien passt oder die Frage beantwortet. Und umgekehrt zeigt ein fehlender Beleg oder eine gescheiterte Prüfung zunächst nur, dass etwas nicht vorliegt oder nicht funktioniert hat. Warum, muss man erst herausfinden.
Ein durchgängiges Beispiel
Das folgende Beispiel ist konstruiert. Es beschreibt kein reales Projekt, sondern setzt Beobachtungen zusammen, wie sie bei Java-Anwendungen vorkommen können. Alle Namen und Ergebnisse sind frei gewählt.
Angenommen, ein Unternehmen übernimmt von seinem bisherigen Dienstleister ein Backend für die Auftragsabwicklung: eine Spring-Boot-Anwendung mit Maven, einer PostgreSQL-Datenbank und einer Anbindung an einen externen Zahlungsdienst. Die Leitfrage des übernehmenden Teams lautet:
Kann unser Team diese Software eigenständig bauen und betreiben?
Die fünf Schritte des Beispiels folgen dem Modell von oben. Der vierte Schritt ist die Schleife: Er führt mit neuen Belegen zurück zu den Schritten davor.
Schritt 1: Die Frage so zerlegen, dass sie beantwortbar wird
So gestellt, ist die Frage zu groß, um sie mit einem einzelnen Beleg zu beantworten. Sie zerfällt in Teilfragen, die jeweils eigene Belege brauchen:
- Lässt sich die Software mit frei verfügbaren Werkzeugen bauen, ohne Zugänge des bisherigen Dienstleisters?
- Laufen die automatisierten Tests ohne besondere Umgebung?
- Was braucht die Anwendung zum Start — Datenbank, fremde Dienste, Konfigurationswerte?
- Welche Werte hängen von der Umgebung ab, und liegen sie vor?
- Lässt sich die Software ausliefern, ohne die Infrastruktur des Dienstleisters zu nutzen?
Diese Zerlegung ist schon ein Ergebnis. Sie macht sichtbar, dass „wir haben den Code“ nur einen Teil der Leitfrage abdeckt.
Schritt 2: Welche Belege liegen vor?
Ein erster Blick ins Repository liefert mehrere Belege:
- Es gibt eine Maven-Build-Datei und einen Maven-Wrapper, also ein Skript, das die passende Maven-Version selbst mitbringt.
- Die Readme beschreibt den Build mit
mvn clean installund nennt Java 11 als Voraussetzung. - Die Build-Konfiguration verlangt dagegen ausdrücklich Java 17.
- Die Anwendung hängt von einer Bibliothek
billing-clientab, die nicht aus einem öffentlichen Verzeichnis stammt. Ein Artefakt-Repository, aus dem sie geladen werden könnte, ist im Projekt nirgends eingetragen. - Eine
docker-compose.ymlstartet PostgreSQL und bindet dabei ein Verzeichnisdb-initein, das im Repository fehlt. - In der Anwendungskonfiguration steht die Adresse des Zahlungsdienstes als Platzhalter, der aus einer Umgebungsvariablen gefüllt wird. Einen Standardwert gibt es nicht, und die Dokumentation nennt keinen Wert.
- Die CI-Pipeline erwartet mehrere Zugangsdaten — für ein Artefakt-Repository und eine Container-Registry — und liefert in die Registry des Dienstleisters aus.
Für sich genommen klingt jeder dieser Punkte harmlos. Interessant wird es erst, wenn man sie nebeneinanderlegt.
Schritt 3: Passen die Befunde zusammen?
Ein Widerspruch fällt sofort auf: Readme und Build-Konfiguration nennen verschiedene Java-Versionen. Weil der Build Java 17 erzwingt, ist vermutlich die Angabe in der Readme veraltet. Daraus folgt nicht, dass die gesamte Dokumentation unzuverlässig ist. Der Widerspruch ist aber ein Anlass, die Angaben genauer zu prüfen, auf die sich das Team bei der Übernahme stützen will — etwa die Startanleitung und die vorausgesetzte Datenbankversion.
Dazu kommen Lücken. Woher die Bibliothek billing-client stammt, sagt das Repository
nicht. Das ist bei Maven kein ungewöhnlicher Zustand: Die Adressen interner
Artefakt-Repositories und die Zugangsdaten dazu müssen nicht im Projekt stehen. Sie
können auch in der Maven-Einstellungsdatei settings.xml auf dem Rechner oder
Build-Server hinterlegt sein. Diese Datei ist laut Maven-Dokumentation ausdrücklich
nicht dafür gedacht, mit dem Projekt verteilt zu werden. Beim Dienstleister baut die
Software also möglicherweise problemlos, weil dort genau diese Einstellung vorhanden
ist. Ebenso offen ist, was in db-init hätte liegen sollen und welche Adresse und welche
Zugangsdaten der Zahlungsdienst in Test- und Produktionsumgebung braucht.
An dieser Stelle lässt sich die Leitfrage noch nicht beantworten. Man kann aber genau sagen, warum nicht — und das ist der Ausgangspunkt für den nächsten Schritt.
Schritt 4: Gezielt klären und nachfordern
Die Lücken führen zu zwei Arten von Folgeschritten: zu Prüfungen, die das übernehmende Team selbst durchführen kann, und zu Fragen und Unterlagen, die es an die abgebende Partei richten muss. In beiden Fällen gilt dasselbe Muster: Ein Befund ist noch keine Bewertung. Erst wenn seine Ursache geklärt ist, lässt sich eine Aussage begründen.
Die naheliegende Prüfung ist ein Build in einer frischen Umgebung: ein leerer Abhängigkeits-Cache, keine Zugangsdaten des Dienstleisters, nur die dokumentierten Schritte und frei verfügbare Werkzeuge. Er zeigt, was ohne das Umfeld des Dienstleisters nicht funktioniert.
In unserem Beispiel scheitert dieser Build, weil sich billing-client nicht laden lässt.
Belegt ist damit nur, dass die Bibliothek in der geprüften Umgebung nicht verfügbar ist.
Dafür gibt es mehrere mögliche Ursachen: Es fehlen Berechtigungen, die
Repository-Konfiguration ist unvollständig, oder die Bibliothek wurde nicht mit
übergeben. Eine gezielte Rückfrage beim Dienstleister ergibt — so nehmen wir an —, dass
sie nur in seinem internen Artefakt-Repository liegt, das nicht Teil der Übergabe war.
Erst damit ist die Bewertung begründet: Es handelt sich um eine Lücke in der Übergabe.
Daraus folgt eine gezielte Nachforderung: die Bibliothek selbst, möglichst mit Quellcode
und geklärten Nutzungsrechten, oder ein dauerhafter Zugang zu dem Repository, aus dem sie
stammt.
Nehmen wir weiter an, der Dienstleister liefert die Bibliothek nach. Im zweiten
Durchgang baut die Software mit Java 17. In einem eigenen Lauf führt das Team auch die
automatisierten Tests aus, und sie laufen grün. Beim Start bricht die Anwendung jedoch
mit der Meldung ab, dass die Adresse des Zahlungsdienstes fehlt. Auch hier ist zunächst
nur der Abbruch belegt. Er kann bedeuten, dass der Wert je Umgebung gesetzt wird und
bisher nicht übergeben wurde. Er kann aber ebenso auf einen Konfigurationsfehler
hinweisen, etwa auf ein falsch aktiviertes Profil oder einen abweichenden Namen der
Umgebungsvariablen. Klären lässt sich das mit einem Blick in Profile und
Konfigurationsdateien und mit einer Rückfrage beim Dienstleister. Nehmen wir an, der
Wert wird tatsächlich nur in den Zielumgebungen gesetzt. Daraus folgt die zweite
Nachforderung: eine Aufstellung aller umgebungsabhängigen Werte je Zielumgebung, der
angebundenen fremden Dienste und der dafür nötigen Zugänge, dazu der Inhalt von
db-init.
So wird aus einer vagen Unsicherheit eine Liste von Punkten, die sich einzeln klären und abhaken lassen.
Schritt 5: Was ist jetzt begründet — und was nicht?
Nach diesen Durchgängen lässt sich eine Aussage formulieren, die ihre Bedingungen und offenen Punkte explizit einbezieht:
Mit Java 17, dem mitgelieferten Maven-Wrapper und der nachgelieferten Bibliothek lässt sich die Software in einer Umgebung ohne Zugänge des Dienstleisters bauen, und die automatisierten Tests laufen dort grün. Gestartet werden konnte die Anwendung noch nicht: Es fehlen die Werte der Zielumgebungen, und der Inhalt von
db-initist noch nicht übergeben. Ausgeliefert wird bisher nur über Registry und Zugangsdaten des Dienstleisters.
Belegt sind darin Build und Testlauf, weil das Team beide selbst ausgeführt hat. Die übrigen Teile benennen offene Punkte. Sie stützen sich auf die Konfiguration im Repository und auf die geklärten Rückfragen, nicht auf einen erfolgreichen Lauf. Ebenso wichtig ist, was die Aussage nicht abdeckt. Ob die Anwendung mit der PostgreSQL-Version der Produktionsumgebung funktioniert, ist nicht geprüft. Wie sich der Zahlungsdienst im Fehlerfall verhält, ebenfalls nicht. Und aus dem Repository allein lässt sich nicht zuverlässig ausschließen, dass es weitere Betriebsabläufe außerhalb der Anwendung gibt, etwa zeitgesteuerte Skripte auf einem Server des Dienstleisters. Hinweise darauf können im Repository stehen, zum Beispiel in Betriebsskripten oder in der Dokumentation. Fehlen sie, bleibt das eine Frage an den Dienstleister.
Auch der erfolgreiche Build hat eine Grenze: Er belegt, dass dieser Stand des Codes mit diesen Werkzeugen in dieser Umgebung gebaut werden konnte — nicht mehr.
Wo Metriken ihren Platz haben
Nichts davon macht Metriken überflüssig. Testabdeckung, Abhängigkeitsversionen oder die Ergebnisse statischer Analyse sind echte Belege, aber jeweils nur für bestimmte Fragen. Auch eine scheinbar eindeutige Angabe beantwortet allein oft wenig. Die Spring-Boot-Version aus der Build-Konfiguration ist nötig, um zu beurteilen, ob die Plattform noch unterstützt wird. Beantworten lässt sich das aber erst zusammen mit den aktuellen Supportangaben des Herstellers.
Eine Metrik beantwortet also nur die Frage, zu der sie passt. 80 Prozent Testabdeckung
sagen nichts darüber, ob sich billing-client beschaffen lässt oder welche Werte der
Zahlungsdienst braucht. Wer mit Metriken beginnt, sammelt deshalb leicht viele Zahlen,
während die Fragen, an denen die Übernahme hängt, gar nicht gestellt werden. Mit der
Frage zu beginnen, dreht diese Reihenfolge um: Zuerst steht fest, was man wissen muss,
und dann wird klar, welche Metrik dazu einen Beleg liefert und welche nicht.
Was das Werkzeug dieses Projekts dazu beiträgt
Das Werkzeug, an dem dieses Projekt arbeitet, wertet Java-Quellcode, OpenAPI-Beschreibungen der Schnittstellen und die zentrale Maven-Build-Datei aus. Es baut nichts und führt keinen Code aus. Zur Leitfrage des Beispiels liefert es deshalb Hinweise, etwa das verwendete Build-System und die eingetragene Spring-Boot-Version. Steht die Java-Version nicht in der zentralen Build-Datei, markiert es sie als unbekannt, statt sie zu raten. Ob sich die Software bauen, starten und ausliefern lässt, erfordert zusätzliche Prüfungen wie die oben beschriebenen.
Was das übernehmende Team davon hat
Das Vorgehen ist aufwendiger, als eine Kennzahl abzulesen. Dafür bringt es drei Dinge, die eine Kennzahl nicht liefert.
Offene Fragen werden früh sichtbar. Dass eine Bibliothek fehlt oder eine Umgebung nirgends beschrieben ist, fällt idealerweise vor dem Übergabetermin auf und nicht am ersten Tag, an dem das neue Team eine Änderung ausliefern soll.
Nachforderungen werden gezielt. Statt pauschal „vollständige Dokumentation“ zu verlangen, kann das Team benennen, was fehlt: diese Bibliothek, diese Werte, dieses Verzeichnis, diese Zugänge. Solche Forderungen sind für die abgebende Partei leichter zu erfüllen und lassen sich besser nachhalten.
Entscheidungen bleiben nachvollziehbar. Jede Aussage nennt ihren Beleg, ihre Bedingungen und das, was sie offenlässt. Wer später fragt, warum eine Übernahme zu bestimmten Bedingungen zugesagt wurde, findet die Begründung — und sieht auch, welche Annahmen damals ungeprüft blieben.
Ein Einstieg für die nächste Übernahme
Für den Anfang genügen drei Fragen: Kann das neue Team die Software bauen? Kann es sie starten? Und kann es eine Änderung ausliefern? Zu jeder dieser Fragen lässt sich festhalten, was nachgewiesen ist, unter welchen Bedingungen der Nachweis gilt und was noch fehlt. Schon diese kurze Liste zeigt, wo nachgefragt werden muss und welche Aussagen bereits belastbar sind.