Eine übernommene Codebase hat oft zigtausend Zeilen, und am ersten Tag stehe ich vor derselben Frage. Nicht „was tut dieser Code“, das kommt später. Sondern: Wo schaue ich zuerst hin, damit meine Zeit dort landet, wo das Risiko sitzt, und nicht in einer ruhigen Ecke, die mich zwei Tage beschäftigt und am Ende niemandem wehtut?
Die ehrliche Antwort ist, dass ich nicht rate. Ich frage die Historie. Jede gewachsene Codebase schleppt ihre eigene Geschichte mit, und die steht in der Versionsverwaltung. Welche Dateien ständig angefasst werden, welche sich seit Jahren nicht bewegt haben, wo sich Änderung auf Änderung stapelt. Git weiß das längst, ich muss es nur fragen.
Im PHPStan-Beitrag ging es darum, die PHPStan-Baseline nach Risiko abzubauen statt nach Dateiname. Welche Stellen das sind, bleibt dort offen. Die Antwort liefert genau diese Technik, und sie taugt für mehr als nur die Baseline: Sie sagt mir, wo Tests zuerst hingehören, wo ich beim Refactoring anfange und worüber ich im ersten Statusbericht rede.
Der erste Blick ist auf Git
Bevor ich ein Werkzeug installiere, sagt schon das nackte git log eine Menge. Welche Dateien tauchen in den letzten ein, zwei Jahren immer wieder in Commits auf? Das ist der schnellste Hinweis darauf, wo das fachliche Leben der Anwendung pulsiert. Ein Einzeiler reicht, um die meistgeänderten Dateien zu zählen:
git log --since="2 years ago" --name-only --pretty=format: \
| grep '\.php$' | sort | uniq -c | sort -rn | head -20
Das Ergebnis ist eine simple Rangliste: Datei und wie oft sie geändert wurde. Oben stehen die Dateien, an denen am meisten gearbeitet wurde. Das allein ist schon Gold wert, weil es mir zeigt, wo das Team tatsächlich seine Zeit verbringt, unabhängig davon, was mir irgendein Architekturdiagramm erzählt. Genauso aufschlussreich ist, was gar nicht auftaucht: Dateien, die über Jahre in keinem Commit stehen, sind entweder stabil oder tot, und welche von beidem, klärt ein späterer Beitrag dieser Reihe.
git blame ist der zweite Blickwinkel, feiner als der erste. Wenn ich eine verdächtige Datei vor mir habe, sehe ich damit zeilengenau, wann was zuletzt angefasst wurde und von wem. Eine Zeile, die seit 2017 unberührt ist, lese ich anders als eine, die letzte Woche dreimal geändert wurde. Beides erzählt mir etwas über das Vertrauen, das ich dem Code entgegenbringen kann.
Zwei Dinge noch zum git log. Umbenannte oder verschobene Dateien reißen die Zählung auseinander, weil Git sie als neue Datei sieht. Für eine einzelne Datei verfolgt git log --follow die Geschichte über Umbenennungen hinweg, in der Sammelzählung oben geht das nicht. Und es lohnt sich, nicht nur auf die Zahl der Änderungen zu schauen, sondern auf ihre Art: Dateien, die immer wieder in Commits mit „fix“ oder „hotfix“ auftauchen, sind oft die, die in Produktion wehtun, nicht nur die, an denen viel gearbeitet wird.
Häufig geändert ist nicht automatisch schlecht
Jetzt kommt der Punkt, an dem die reine Änderungshäufigkeit in die Irre führt. Eine Datei, die oft geändert wird, ist nicht automatisch ein Problem. Vielleicht lebt dort einfach die Fachlogik, die sich mit dem Geschäft weiterentwickelt, und das ist völlig gesund. Genauso ist eine komplexe Datei für sich noch kein Drama, solange sie einmal geschrieben wurde und seither ihre Ruhe hat.
Wehzutun beginnt es erst dort, wo beides zusammenkommt: hohe Änderungshäufigkeit und hohe Komplexität in derselben Datei. Das ist die Stelle, die ständig angefasst werden muss und bei der jede Änderung gefährlich ist, weil niemand mehr den Überblick hat. Genau diese Überschneidung will ich sehen, und dafür gibt es Werkzeuge, die mir die Rechnung abnehmen.
In PHP nehme ich dafür gern churn-php. Es zählt pro Datei die Commits aus der Git-Historie, misst die Komplexität und verrechnet beides zu einem Score:
composer require --dev bmitch/churn-php
vendor/bin/churn run src
Das Ergebnis ist eine Tabelle, im Prinzip so aufgebaut:
Datei Commits Komplexität Score
src/Order/OrderProcessor.php 94 61 0.82
src/Billing/InvoiceBuilder.php 71 48 0.67
src/Export/ReportWriter.php 12 55 0.19
Die Zahlen oben sind nur zur Illustration, aber das Muster ist das, worauf es ankommt. Der OrderProcessor wird oft geändert und ist komplex, er steht oben und ist mein erster Kandidat. Der ReportWriter ist zwar komplex, wird aber kaum angefasst, also kann er vorerst warten. So eine Liste ist in einer halben Stunde erzeugt und sagt mir mehr über die Risikoverteilung als eine Woche Lesen. Wer es grafisch mag, bekommt mit PHPMetrics eine verwandte Sicht auf die Komplexität als Bild. Die Änderungshäufigkeit kommt dabei weiter aus Git.
Zwei Grenzen hat die Methode. Churn zählt jeden Commit gleich, ein Tippfehler-Fix wiegt so viel wie ein echter Umbau, deshalb ist die Liste ein grober Hinweis und kein Messwert. Auch ein Revert oder ein automatischer Formatierungslauf über die ganze Codebase zählt mit. Und der Zeitraum entscheidet: Die Historie der letzten ein, zwei Jahre sagt mehr über das heutige Risiko als die gesamte Geschichte seit der ersten Zeile, in der längst abgelöste Teile das Bild verzerren. Ich schaue deshalb bewusst auf ein jüngeres Fenster.
Wer hat den Code geschrieben
Die dritte Sicht ist oft die unbequemste. git shortlog und git blame zeigen mir nicht nur, was geändert wurde, sondern von wem. Für eine einzelne Datei reicht ein Aufruf:
git shortlog -sn --since="2 years ago" HEAD -- src/Order/OrderProcessor.php
Das Ergebnis ist eine Liste der Autoren mit der Zahl ihrer Commits an dieser Datei. Wenn eine komplexe, geschäftskritische Datei fast nur von einer einzigen Person stammt, die inzwischen weg ist, dann ist das kein Code-Problem, sondern ein Wissensproblem. Niemand im aktuellen Team hat die Datei je angefasst, und das Wissen darüber ist mit dem Autor gegangen. Solche Stellen hebe ich mir gesondert hervor. Sie müssen beim ersten Refactoring doppelt vorsichtig behandelt werden, und ich will früh dafür sorgen, dass wieder mehr als ein Mensch sie versteht.
Aus der Liste wird eine Landkarte
Die Hotspot-Liste ist kein Selbstzweck, sie ist die Reihenfolge für alles, was danach kommt. Ich lese sie als Landkarte für die ersten Wochen.
Die Dateien ganz oben bekommen als Erstes ein Sicherheitsnetz. Dorthin kommen die ersten Characterization Tests, bevor ich irgendetwas ändere, und von dort baue ich die PHPStan-Baseline ab, über die ich im PHPStan-Beitrag geschrieben habe. Wie ich Verhalten festschreibe, ohne den Code schon zu verstehen, steht in einem früheren Logbuch. Erst wenn ein Hotspot abgesichert ist, fasse ich ihn an, und dann oft mit Branch-by-Abstraction, damit der alte Pfad lauffähig bleibt, bis der neue bewiesen ist.
Besonders dringend wird es, wo ein Hotspot auf null Testabdeckung trifft. Oft geändert, komplex und ungetestet, das ist die gefährlichste Kombination, und genau diese Dateien stehen bei mir ganz oben. Wenn schon Coverage-Daten existieren, lege ich sie auf Dateiebene über die Hotspot-Liste und sehe sofort, wo das Netz am dünnsten und die Last am größten ist.
Dieselbe Liste hilft mir auch im Gespräch mit dem Kunden. Wenn ich sagen kann, dass sich die Hälfte aller Änderungen auf wenige Dateien konzentriert und genau die am riskantesten sind, dann ist das ein Argument, das auch jemand ohne PHP-Kenntnisse versteht. Aus einem diffusen „der Code ist alt“ wird eine konkrete, überschaubare Liste.
Stolperfallen
Hotspots mit schlechtem Code verwechseln. Eine Datei kann oben in der Liste stehen, weil sie fachlich lebt, nicht weil sie kaputt ist. Eine zentrale Preisberechnung, die jedes Quartal neue Regeln bekommt, ist naturgemäß oft geändert. Das heißt nicht, dass sie schlecht ist, nur dass ich bei ihr besonders vorsichtig sein muss. Die Liste zeigt mir, wo ich hinschauen soll, nicht was ich dort finden werde.
Metriken für Wahrheit halten. Komplexitätszahlen und Churn-Scores sind Hinweise, keine Urteile. Sie zeigen auf eine Stelle und sagen „schau hier genauer hin“, mehr nicht. Die Entscheidung, ob dort wirklich ein Problem sitzt, trifft immer noch mein Blick in den Code, nicht der Score in der Tabelle.
Die ruhige, aber geschäftskritische Ecke übersehen. Das ist die gefährlichste Falle. Es gibt Code, der selten geändert wird und gerade deshalb nie in der Hotspot-Liste auftaucht, der aber das Geschäft trägt. Ein Zahlungsabgleich, der seit Jahren unverändert läuft, steht nirgends oben und ist trotzdem das, was auf keinen Fall brechen darf. Die Historie zeigt mir, wo viel passiert, nicht, was wichtig ist. Den Unterschied muss ich im Gespräch mit den Leuten klären, die mit der Anwendung arbeiten.
Keine Historie, keine Archäologie. Die ganze Technik lebt von einer echten Git-Historie über Jahre. Bei Übernahmen bekomme ich aber manchmal nur eine Zip-Datei oder ein frisch angelegtes Repo mit einem einzigen Initial-Commit. Dann gibt es nichts zu befragen, dieser Einblick fällt weg, und ich bin zurück beim Lesen und beim Reden mit den Leuten, die die Anwendung täglich benutzen. Kein Werkzeug ersetzt dieses Gespräch, es ordnet nur, wo ich zuerst hinschaue.
Die Historie einer Codebase ist das ehrlichste Dokument, das es gibt, weil niemand sie für den neuen Entwickler geschönt hat. Wenn Sie vor einer Übernahme stehen und nicht wissen, wo Sie anfangen sollen, ist das eine der ersten Fragen, die ich mit Ihnen kläre. Schildern Sie mir kurz Ihre Ausgangslage, ich melde mich mit einer ersten Einschätzung. Termin buchen.