Artikel

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:

  1. Frage: Was genau muss das übernehmende Team wissen?
  2. Belege: Welche technischen Belege gibt es dazu?
  3. Reichen sie? Passen die Belege zusammen, und decken sie die Frage ab — oder bleibt eine Lücke?
  4. 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 install und nennt Java 11 als Voraussetzung.
  • Die Build-Konfiguration verlangt dagegen ausdrücklich Java 17.
  • Die Anwendung hängt von einer Bibliothek billing-client ab, 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.yml startet PostgreSQL und bindet dabei ein Verzeichnis db-init ein, 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-init ist 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.

Themen

  • Softwareübernahme
  • Evidence
  • Dienstleisterwechsel
  • Assessment

← Alle Insights