Es gibt diesen einen Moment in der Geschichte der Informatik, den fast jeder Programmierer als den Urknall der modernen Welt beschreibt. Man stellt sich zwei bärtige Männer in den Bell Labs vor, die zwischen Magnetbändern und Fernschreibern eine Sprache schufen, die so perfekt war, dass sie den Grundstein für alles legte, was wir heute digital nennen. Die landläufige Meinung besagt, dass die Veröffentlichung von C Programming Language Kernighan Ritchie im Jahr 1978 eine Art göttliche Offenbarung für die Softwarewelt darstellte, ein Manifest der Effizienz und der maschinennahen Eleganz. Doch wer die staubigen Archive der Betriebssystementwicklung jener Zeit durchforstet, stößt auf eine unbequeme Wahrheit. Das Buch war kein fertiger Bauplan für die Ewigkeit, sondern ein verzweifelter Versuch, Ordnung in ein Chaos zu bringen, das die Autoren selbst mitverursacht hatten. Brian Kernighan und Dennis Ritchie schrieben keine Bibel; sie verfassten ein Handbuch für ein flüchtiges Werkzeug, das eigentlich nie dazu gedacht war, die gesamte Weltinfrastruktur für die nächsten fünfzig Jahre zu stützen. Wir haben uns an die Idee gewöhnt, dass C das Fundament der Freiheit ist, während es in Wahrheit oft die Fessel ist, die uns an eine Ära der Speicherfehler und Sicherheitslücken bindet, die wir längst hätten hinter uns lassen müssen.
Die Verehrung dieses Werks grenzt oft an eine Form von technologischem Konservatismus, der jede Kritik im Keim ersticken will. Wenn man heute in Informatikvorlesungen an deutschen Universitäten sitzt, wird das weiße Buch mit dem großen blauen C oft wie eine Reliquie behandelt. Man lehrt die Studenten, dass man erst dann ein richtiger Entwickler ist, wenn man die manuelle Speicherverwaltung und die Arithmetik von Zeigern beherrscht, so wie es in dem schmalen Band skizziert wurde. Ich habe mit Systemarchitekten gesprochen, die Stein auf Bein schwören, dass es ohne diese spezifische Art der Programmierung keine modernen Betriebssysteme gäbe. Das ist ein Mythos. Die Geschichte hätte anders verlaufen können. Es gab sicherere Alternativen wie Algol oder später Pascal, die Konzepte verfolgten, die heute in modernen Sprachen mühsam wiederentdeckt werden. C setzte sich nicht durch, weil es die beste Sprache war, sondern weil es die billigste und portabelste Lösung für eine Hardwarewelt war, die damals extrem fragmentiert und leistungsschwach war. Es war der kleinste gemeinsame Nenner, nicht die technologische Spitze.
Die gefährliche Schlichtheit von C Programming Language Kernighan Ritchie
Was in den späten Siebzigern als Brillanz gefeiert wurde, entpuppt sich bei genauerer Betrachtung als eine architektonische Nachlässigkeit mit globalen Folgen. Das Buch C Programming Language Kernighan Ritchie definierte eine Sprache, die fast vollständig auf Sicherheitsmechanismen verzichtete, um dem Programmierer maximale Kontrolle zu geben. Das klingt heroisch, ist aber im Kontext moderner Vernetzung ein Albtraum. Ein vergessenes Semikolon oder ein Pufferüberlauf, der in der Welt von Kernighan und Ritchie vielleicht nur einen Labor-Rechner zum Absturz brachte, legt heute ganze Industriezweige lahm oder ermöglicht staatlich finanzierten Hackern den Zugriff auf private Daten von Millionen Menschen. Die Autoren konnten nicht ahnen, dass ihre Schöpfung eines Tages das Rückgrat des Internets bilden würde, aber das entbindet uns nicht von der Pflicht, die Schwachstellen dieser Architektur offen zu legen. Die Sprache kennt kein Konzept von Grenzen bei Arrays, keine automatische Typsicherheit in einem modernen Sinne und keine eingebaute Verteidigung gegen die eigene Unachtsamkeit des Menschen.
Die Illusion der totalen Kontrolle
In den Bell Labs herrschte eine Kultur des Vertrauens. Man ging davon aus, dass der Programmierer genau weiß, was er tut. Wenn du einen Zeiger auf eine Speicheradresse setzt, die dir nicht gehört, dann hast du wohl einen Grund dafür. Diese Philosophie zieht sich durch jede Seite des Originalwerks. Es ist eine Sprache für Experten, geschrieben von Experten. Doch die Realität sieht anders aus. Die Softwareindustrie besteht nicht nur aus Genies vom Schlage eines Dennis Ritchie. Sie besteht aus tausenden Entwicklern, die unter Zeitdruck stehen und komplexe Systeme bauen müssen. Die Freiheit, die das Buch verspricht, ist für den durchschnittlichen Programmierer oft nur die Freiheit, sich selbst in den Fuß zu schießen. Wir haben Jahrzehnte damit verbracht, Werkzeuge zu bauen, die die Fehler korrigieren sollen, die durch das Design der Sprache erst möglich wurden. Statische Analyseprogramme, Fuzzer und Laufzeit-Überwachungen sind im Grunde nur teure Pflaster auf einer Wunde, die 1978 aufgerissen wurde.
Man muss sich vor Augen führen, wie radikal der Ansatz damals war. Bevor Unix und C die Bühne betraten, wurden Betriebssysteme oft in Assembler geschrieben, was extrem mühsam und an eine spezifische Hardware gebunden war. Das Versprechen der Portabilität war das schlagende Argument. Dass man denselben Code auf verschiedenen Maschinen ausführen konnte, war eine Revolution. Aber dieser Vorteil wurde mit einem hohen Preis erkauft. Um portabel zu sein, musste C abstrakt genug sein, um auf verschiedenen Architekturen zu funktionieren, aber gleichzeitig so nah an der Hardware bleiben, dass keine Performance verloren ging. Dieser Spagat gelang, indem man auf fast alle Sicherheitsprüfungen verzichtete, die andere Sprachen jener Zeit bereits besaßen. Es war ein Kompromiss auf Kosten der Zuverlässigkeit, ein Pakt mit dem Teufel der Geschwindigkeit, dessen Zinsen wir heute mit jedem Sicherheitsupdate und jedem Zero-Day-Exploit bezahlen.
Warum wir uns von dem romantisierten Erbe lösen müssen
Es gibt eine starke Fraktion von Skeptikern, die argumentieren wird, dass moderne Sprachen wie Rust oder Go niemals die Performance von C erreichen können oder dass die Abstraktion den Programmierer von der Maschine entfremdet. Sie sagen, dass man die Hardware verstehen muss, um gute Software zu schreiben. Das ist ein valider Punkt, aber er ist unvollständig. Man kann Hardware verstehen, ohne eine Sprache zu verwenden, die Fehler provoziert. Die Vorstellung, dass man nur durch Schmerz und manuelle Speicherverwaltung ein wahrer Meister wird, ist eine Form von digitalem Elitarismus. Wir verlangen von Bauingenieuren auch nicht, dass sie ihre Berechnungen mit dem Abakus durchführen, nur um ein Gefühl für Zahlen zu bekommen. Wir nutzen Taschenrechner und Computerprogramme, um menschliches Versagen auszuschließen. In der Programmierung klammern wir uns jedoch an ein Modell, das Fehlbarkeit zum Feature erhebt.
Das Problem liegt tiefer als nur in der Syntax. Es liegt in der Art und Weise, wie wir über Software nachdenken. Das Vermächtnis, das durch C Programming Language Kernighan Ritchie zementiert wurde, ist die Idee, dass Effizienz über alles geht. In einer Welt, in der Speicherplatz knapp und CPU-Zyklen teuer waren, war das logisch. Heute jedoch, wo wir über Gigabytes an RAM und Multi-Core-Prozessoren verfügen, ist die menschliche Zeit und die Sicherheit des Systems weitaus wertvoller als die Einsparung von ein paar Bytes. Dennoch schreiben wir unsere kritischste Infrastruktur weiterhin in einer Sprache, die für eine Welt entworfen wurde, die es so nicht mehr gibt. Jedes Mal, wenn ein neuer Linux-Kernel oder ein Windows-Update erscheint, schleppen wir Altlasten mit uns herum, die direkt auf die Designentscheidungen der siebziger Jahre zurückgehen.
Die Kosten der Nostalgie
Wenn ich mir anschaue, wie viel Geld Unternehmen für die Cybersicherheit ausgeben, wird mir schwindelig. Ein erheblicher Teil dieser Kosten könnte vermieden werden, wenn wir aufhören würden, so zu tun, als sei die alte Schule der Programmierung unantastbar. Es ist eine unbequeme Wahrheit, dass ein Großteil der Sicherheitslücken in Browsern, Betriebssystemen und Netzwerkprotokollen auf Speicherfehler zurückzuführen ist, die in moderneren Sprachen schlicht physikalisch unmöglich wären. Die Verteidiger des Status quo argumentieren oft mit der bestehenden Codebasis. Man könne nicht einfach Millionen Zeilen Code umschreiben. Das stimmt. Aber man kann aufhören, neuen Code in alten, unsicheren Mustern zu verfassen. Wir brauchen einen kulturellen Wandel, der anerkennt, dass das, was früher genial war, heute eine Belastung sein kann. Die Romantik der Bell Labs darf nicht den Blick auf die technologischen Notwendigkeiten der Gegenwart verstellen.
Es gibt in Deutschland eine ausgeprägte Ingenieurskultur, die Gründlichkeit und Präzision schätzt. Paradoxerweise ist genau diese Kultur oft besonders anfällig für die C-Nostalgie. Man glaubt, durch Disziplin die Schwächen der Sprache ausgleichen zu können. Doch die Statistik ist unerbittlich. Selbst die besten Programmierer der Welt machen Fehler. Die Komplexität heutiger Systeme übersteigt das menschliche Vorstellungsvermögen bei weitem. Wenn ein System aus fünfzig Millionen Zeilen Code besteht, ist es statistisch gesehen sicher, dass sich irgendwo ein Fehler eingeschlichen hat, den Kernighan und Ritchie in ihrem Buch als Lehrbeispiel hätten verwenden können. Wir müssen akzeptieren, dass menschliche Disziplin keine skalierbare Lösung für Softwarequalität ist. Wir brauchen Strukturen, die Fehler verhindern, statt sie nur zu bestrafen oder mühsam im Nachhinein zu suchen.
Die Geschichte der Informatik ist voll von Werkzeugen, die für einen bestimmten Zweck geschaffen wurden und dann ihre eigene Bestimmung überlebten. C ist das prominenteste Beispiel dafür. Es war die Sprache der Systemprogrammierung für eine Ära der isolierten Rechner. Dass wir sie heute für vernetzte Autos, medizinische Geräte und Kraftwerkssteuerungen verwenden, ist eigentlich ein Wahnsinn, den wir nur deshalb akzeptieren, weil wir es schon immer so gemacht haben. Wir bewundern die Schlichtheit des Textes und die Klarheit der Gedanken, die daraus sprechen, aber wir ignorieren die Schattenseiten, die diese Klarheit mit sich bringt. Ein scharfes Messer ist ein wunderbares Werkzeug für einen Chirurgen, aber wir geben es nicht jedem Kleinkind in die Hand und wundern uns dann über die Schnittwunden.
Wir müssen anfangen, die Schöpfung von Kernighan und Ritchie als das zu betrachten, was sie ist: Ein historisches Dokument von immensem Wert, das uns gelehrt hat, wie man Hardware abstrahiert, aber keine Blaupause für die Zukunft der sicheren Softwareentwicklung. Die wahre Meisterschaft liegt heute nicht mehr darin, einen Pointer perfekt zu biegen, sondern darin, Systeme zu entwerfen, die so robust sind, dass sie den unvermeidlichen menschlichen Fehler verzeihen. Es ist an der Zeit, den Mythos zu entzaubern und zu erkennen, dass die Verehrung der Vergangenheit oft nur eine Ausrede ist, um die unbequemen Herausforderungen der Zukunft nicht annehmen zu müssen. Die Eleganz von einst ist zum Risiko von heute geworden, und nur wenn wir diesen Widerspruch aushalten, können wir Software bauen, die den Namen Ingenieurskunst wirklich verdient.
Effizienz ohne Sicherheit ist kein technischer Fortschritt, sondern ein historischer Irrtum, den wir uns in einer vernetzten Welt nicht mehr leisten können.
