Seite 2: Lesen heißt nicht, Syntax zu parsen

Inhaltsverzeichnis

close notice

This article is also available in English. It was translated with technical assistance and editorially reviewed before publication.

Don’t show this again.

Wenn vom Lesen des Codes die Rede ist, meinen viele zunächst nur das oberflächliche Erfassen: Welcher Funktionsaufruf folgt auf welchen, welche Variable wird wo gesetzt, welche Rückgabewerte gehen wohin. Das ist die syntaktisch-mechanische Ebene. Sie ist notwendig, aber bei Weitem nicht hinreichend.

Auf einer zweiten Ebene fragt das Lesen, was der Code semantisch tut. Welche Zustandsänderung wird ausgelöst, welche Invariante soll erhalten bleiben, welche Fehlerfälle werden abgedeckt, welche stillschweigend ignoriert. Hier beginnt das eigentliche Verstehen, weil hier die Wirkung des Codes zur Sprache kommt und nicht mehr nur seine Form.

Auf einer dritten Ebene fragt das Lesen nach der Intention. Warum wurde diese Lösung gewählt und nicht eine andere, welche Trade-offs wurden bewusst eingegangen, welche Annahmen liegen zugrunde. Diese Ebene ist im Code selten explizit dokumentiert. Sie muss aus Strukturen, Tests, Kommentaren und Commit-Historie rekonstruiert werden, und genau diese Rekonstruktion macht den Unterschied zwischen oberflächlicher und tiefer Vertrautheit mit einem Modul aus.

Auf einer vierten Ebene fragt das Lesen nach der Geschichte. Wie ist dieser Code geworden, was war ein bewusster Schnitt, was ein kompromissbedingter Workaround, welche Stelle ist organisch gewachsen und welche wurde später angeklebt? Wer hier nicht lesen kann, repariert Symptome statt Ursachen und verschiebt die eigentliche Arbeit auf den nächsten Bug. Ein typisches Beispiel ist eine Validierung, die ursprünglich einer bestimmten Geschäftsregel gehorchte, später wegen einer Sonderanforderung gelockert wurde, wieder verschärft, dann wieder gelockert. Wer diese Bewegung nicht in der Historie liest, baut die nächste Lockerung als vermeintlich saubere Lösung ein und tritt in eine Falle, die andere bereits dreimal gesehen haben.

Senior-Niveau heißt, alle vier Ebenen gleichzeitig im Blick zu haben. Wer nur die erste beherrscht, ist Werkzeugbenutzer. Wer alle vier integriert, ist Entwickler im eigentlichen Sinne. Diese Integration entsteht nicht durch das Schreiben von noch mehr Code, sondern durch das Lesen von Code, den andere geschrieben haben.

Eine Disziplin ohne Lehrplan

In jedem Programmierbuch wird das Schreiben geübt. Tutorials sind Schreibtutorials, Hochschulkurse sind Schreibkurse, Bootcamps sind Schreibbootcamps. Wer einsteigt, bekommt zuerst ein Hello-World-Programm, dann immer komplexere eigene Programme. Das Lesen kommt nirgendwo systematisch vor.

Auch in der dualen Ausbildung zur Fachinformatikerin oder zum Fachinformatiker ist das Lesen kein eigenes Lehrziel. Im Studium der Informatik begegnet man Code in der Regel als Aufgabe, nicht als Quelle. Selbst in Fortbildungen erfahrener Entwicklerinnen und Entwickler ist das Lesen kein Thema, das systematisch trainiert wird. Es wird stillschweigend vorausgesetzt, ohne dass es jemals vermittelt würde.

Code-Reviews wären die naheliegende Praxis, in der Lesen geübt würde. In der Realität reduzieren sie sich häufig auf Stilfragen, Konventionsverstöße und kleine Korrekturen. Die tieferen Ebenen der Intention und der Geschichte werden selten berührt. Das liegt nicht an der Praxis selbst, sondern an der fehlenden Schulung darin, was ein gutes Review eigentlich leisten könnte und welche Fragen es zu stellen hätte.

So entsteht ein blinder Fleck. Eine Disziplin, die einen großen Teil des beruflichen Alltags ausmacht, wird in der Ausbildung wie eine selbstverständliche Begleitfähigkeit behandelt. Niemand wundert sich, dass Juniors Schwierigkeiten beim Lesen haben. Niemand zieht den Schluss, dass man es ihnen beibringen müsste. Damit wird ein Defizit normalisiert, das in seiner ökonomischen Wirkung erheblich ist.

Lesen lässt sich üben

Lesen lässt sich systematisch trainieren, sofern man die Bereitschaft mitbringt. Eine erste Übung besteht darin, sich eine Open-Source-Codebasis vorzunehmen, die man nicht selbst geschrieben hat, und sie über mehrere Wochen zu erkunden, ohne etwas zu ändern. Ziel ist nicht, einen Beitrag zu leisten, sondern die Codebasis zu verstehen. Diese Form des absichtslosen Lesens ist ungewohnt und fühlt sich zunächst unproduktiv an, sie ist aber das eigentliche Trainingsfeld.

Eine zweite Übung ist das Nachvollziehen fremder Pull Requests. Man liest die Diskussion mit, versucht die Änderung zu verstehen, bevor man die Begründung kennt, und vergleicht das eigene Verständnis mit dem, was die Beteiligten geschrieben haben. Diese Übung schärft die Intentionsebene des Lesens, weil sie zwingt, die Frage nach dem Warum vor der Antwort zu formulieren.

Eine dritte Übung ist das bewusste Unterscheiden zwischen drei Lesemodi: scannend, wenn man eine Stelle suchen will; verstehend, wenn man eine Funktion in ihrer Wirkung erfassen will; kritisch, wenn man eine Änderung verantworten muss. Wer immer im selben Modus liest, kann keinen davon richtig. Die meisten Entwicklerinnen und Entwickler scannen unbewusst, auch wenn sie eigentlich kritisch lesen müssten. Genau dort entstehen die teuren Fehler.

Mit LLMs kommt eine vierte Übung hinzu, die in den nächsten Jahren an Bedeutung gewinnen wird: das Prüfen generierten Codes. Es genügt nicht, einen Vorschlag der KI durchzulesen und zu nicken. Echtes Prüfen heißt, die generierte Lösung mit der eigenen Vorstellung zu vergleichen, Annahmen zu hinterfragen, Randfälle gegenzuprüfen, alternative Implementierungen zu durchdenken. Genau das, was eigentlich für jeden Pull Request gelten sollte. Bei generiertem Code ist es zwingend, weil hier kein menschlicher Autor existiert, der für seine Entscheidungen einsteht.

Eine fünfte Übung wird oft übersehen: das Wiederlesen des eigenen Codes nach längerer Pause. Sechs Monate genügen, um die ursprüngliche mentale Gesamtsicht weitgehend zu verlieren. Wer dann die eigene Implementierung erneut liest und ehrlich notiert, an welchen Stellen die Intention nicht mehr ohne externe Hilfe rekonstruierbar ist, lernt zwei Dinge gleichzeitig: Was damals besser zu dokumentieren gewesen wäre und wie es sich anfühlt, fremden Code vor sich zu haben. Diese Übung ist ernüchternd und nützlich zugleich.

Lesen ist also keine angeborene Fähigkeit. Es ist eine erlernbare Disziplin. Wer sie systematisch übt, wird auf eine Weise besser, die kein Schreibtraining ersetzen kann. Und wer sie nicht übt, wird sich in den kommenden Jahren in einer Codebasis wiederfinden, die schneller wächst, als sie zu verstehen ist.

Die Dauerwährung der Softwareentwicklung heißt Verstehen

Der Reflex, beim Anblick fremden Codes lieber selbst neu anzusetzen, ist menschlich und alt. Joel Spolsky hat ihn vor über 25 Jahren beschrieben und vor seinen Folgen gewarnt. Was sich seitdem geändert hat, ist die Geschwindigkeit, mit der dieser Reflex Schaden anrichten kann. Mit LLMs ist das Schreiben so billig geworden, dass die Kosten des Nichtlesens nicht mehr in Jahren, sondern in Wochen sichtbar werden.

Wer Code nur erzeugt, ohne ihn zu durchdringen, baut Schulden auf, die irgendwann eine andere Person begleichen muss. Diese Person sitzt vor einem Bildschirm und liest. Sie ist die wertvollste Person im Team, weil sie die einzige ist, die noch entscheiden kann, was mit dieser Codebasis weiter geschieht. Wer das systematisch trainiert, baut sich einen Vorsprung auf, der auf Promptebene allein nicht zu erzeugen ist. Das Tippen ist die Einstiegsdisziplin. Das Lesen ist die, die bleibt.

(rme)