Zum Hauptinhalt springen
Bethemesh
BiografieGeschichte der InformatikAnfänger

Ken Thompson: von Unix bis Go, Einfachheit als Methode

Wie Ken Thompson Unix, die Sprache B und Go durch dieselbe Suche nach Einfachheit, Effizienz und kombinierbaren Werkzeugen verband.

Veröffentlicht 24. August 2026Lesezeit : 5 minVon Yann Bastien
Ken Thompson links neben Dennis Ritchie im Jahr 1973
Inhalt anzeigen
  1. Von Multics zu Unix
  2. Wie Beschränkungen Einfachheit förderten
  3. Von B zu C
  4. Reguläre Ausdrücke, Plan 9 und UTF-8
  5. „Reflections on Trusting Trust“
  6. Warum Thompson mit Go wieder eine Sprache entwarf
  7. Ein Vermächtnis aus kombinierbaren Werkzeugen
  8. Zeitleiste
  9. Häufig gestellte Fragen
  10. Hat Ken Thompson Unix allein entwickelt?
  11. Wie unterscheiden sich Thompsons und Ritchies Beiträge?
  12. Wird B noch verwendet?
  13. Hat Thompson die Unix-Pipes erfunden?
  14. Welche Verbindung besteht zwischen Unix und Go?

Ein großer Teil der modernen Informatik beruht auf einer Idee, die Ken Thompson Ende der 1960er Jahre praktisch umsetzte: Ein leistungsfähiges System muss nicht kompliziert sein, wenn seine einfachen Bestandteile gut zusammenarbeiten. Diese Idee prägt Unix, durchzieht die Sprache B, bereitet C vor und erscheint Jahrzehnte später erneut in Go.

Thompson folgte dabei keinem einzigen theoretischen Programm. Er baute Werkzeuge für konkrete Probleme: einen kleinen Computer interaktiv nutzen, mit sehr wenig Speicher ein Betriebssystem schreiben, Text verarbeiten oder große Software schnell kompilieren. Die Kontinuität liegt in seiner Methode: kleine, verständliche und kombinierbare Mechanismen statt Systeme, die alles vorwegnehmen wollen.

Von Multics zu Unix

Kenneth Lane Thompson wurde 1943 in New Orleans geboren. Nach seinem Studium an der University of California, Berkeley, kam er 1966 zu den Bell Labs und arbeitete am Projekt Multics mit.

Multics sollte vielen Benutzern gleichzeitig eine interaktive Computerumgebung bieten, wurde jedoch komplex und teuer. Als Bell Labs 1969 ausstieg, wollte Thompson nicht Multics verkleinern, sondern dessen angenehmste Eigenschaften auf einer viel bescheideneren Maschine bewahren.

Auf einem PDP-7 entwickelte er 1969 ein Dateisystem, eine Kommando-Shell und die ersten Funktionen des Systems, das später Unix hieß. Dennis Ritchie stieß rasch dazu.

Wie Beschränkungen Einfachheit förderten

Der PDP-7 hatte wenig Speicher. Jede Abstraktion musste ihren Preis rechtfertigen. Thompson bevorzugte kleine Programme mit klaren Aufgaben. Entscheidend wurde, dass die Ausgabe eines Programms als Eingabe eines anderen dienen konnte.

Doug McIlroy hatte die Idee solcher Datenströme bei Bell Labs vertreten; Thompson implementierte 1973 die Pipes in Unix. Das Zeichen | verband Befehle zu kleinen Programmen. Dieses Prinzip prägt Unix-artige Systeme und Datenverarbeitung bis heute.

Von B zu C

Frühe Unix-Versionen waren in Assembler geschrieben und eng an den jeweiligen Prozessor gebunden. Thompson entwickelte B, eine kleine Sprache auf Grundlage von BCPL, die Teile dieser Hardwareabhängigkeit reduzieren sollte.

B zeigte jedoch Grenzen auf dem PDP-11. Dennis Ritchie ergänzte Typen und verbesserte das Datenmodell, woraus Anfang der 1970er Jahre C entstand. Die Rollen sind klar: Thompson schuf B und das technische Umfeld; Ritchie war der Hauptdesigner von C.

Gemeinsam konnten sie den größten Teil von Unix in C neu schreiben. Dadurch wurde das System wesentlich portabler und C verbreitete sich zusammen mit Unix an Universitäten und später in der Industrie. Mehr dazu bieten die Biografie von Dennis Ritchie und die Geschichte von C.

Reguläre Ausdrücke, Plan 9 und UTF-8

Thompsons Einfluss reicht weit über Unix-Kernel und B hinaus. Er entwickelte den Texteditor ed und half, reguläre Ausdrücke als praktische Notation für Textmuster zu verbreiten.

Später arbeitete er an Plan 9, einem experimentellen verteilten Betriebssystem. 1992 entwarf er mit Rob Pike UTF-8, eine Unicode-Codierung, die mit ASCII kompatibel blieb. UTF-8 wurde schließlich zur dominierenden Zeichenkodierung des Webs.

Diese Arbeiten verbindet dieselbe Frage: Wie definiert man eine Darstellung, die einfach genug für den alltäglichen Einsatz ist und sich dennoch auf größere Anforderungen erweitern lässt?

„Reflections on Trusting Trust“

1983 erhielten Thompson und Ritchie den Turing Award. In seinem Vortrag Reflections on Trusting Trust beschrieb Thompson einen manipulierten Compiler, der heimlich eine Hintertür in ein Login-Programm einfügen und zugleich seine eigene Manipulation an zukünftige Compiler-Versionen weitergeben konnte.

Die Demonstration zeigt eine tiefe Grenze des Vertrauens in Software: Quellcode zu prüfen reicht nicht, wenn die Werkzeugkette, die ihn übersetzt, selbst kompromittiert ist. Reproduzierbare Builds und moderne Supply-Chain-Sicherheit greifen genau dieses Problem auf.

Warum Thompson mit Go wieder eine Sprache entwarf

Thompson kam 2006 zu Google. Dort begegnete ihm ein neues Skalierungsproblem: riesige Codebasen, lange Kompilierzeiten und schwer beherrschbare Nebenläufigkeit.

2007 begannen Thompson, Rob Pike und Robert Griesemer mit Go. Die Sprache setzt auf schnelle Builds, automatische Speicherverwaltung, standardisierte Formatierung und eingebaute Nebenläufigkeitsmechanismen. Die Syntax bleibt bewusst überschaubar, damit Code großer Teams lesbar bleibt.

Go ist weder eine Kopie von C noch ein neues Unix. Es überträgt eine Methode auf einen anderen Maßstab: Einfachheit als Antwort auf Komplexität. 2009 wurde das Projekt als Open Source veröffentlicht und verbreitete sich besonders in Netzwerkdiensten, Infrastruktur und verteilten Systemen.

Ein Vermächtnis aus kombinierbaren Werkzeugen

Unix lebt in Linux, macOS, BSD-Systemen, Android und Serverinfrastrukturen weiter. C bleibt für Systemsoftware zentral. UTF-8 ermöglicht weltweiten Textaustausch. Go ist in Cloud- und Netzwerksoftware verbreitet.

Das verbindende Element ist weniger eine Liste von Erfindungen als eine Konstruktionsweise: Komponenten sollen wenig tun, verständlich bleiben und über klare Schnittstellen unerwartet kombiniert werden können.

Zeitleiste

  • 1943: Geburt von Kenneth Lane Thompson in New Orleans.
  • 1966: Eintritt bei Bell Labs und Mitarbeit an Multics.
  • 1969: erste Unix-Version auf dem PDP-7.
  • 1969–1970: Entwicklung von B aus BCPL.
  • 1973: Pipes in Unix und weitgehende Neufassung des Systems in C mit Dennis Ritchie.
  • 1983: Turing Award mit Ritchie und Reflections on Trusting Trust.
  • 1992: Entwicklung von UTF-8 mit Rob Pike.
  • 2006: Wechsel zu Google.
  • 2007: Beginn der Entwicklung von Go mit Robert Griesemer und Rob Pike.
  • 2009: Veröffentlichung von Go als Open-Source-Projekt.

Häufig gestellte Fragen

Hat Ken Thompson Unix allein entwickelt?

Er schrieb 1969 die erste Version und war die treibende Kraft am Anfang. Dennis Ritchie und weitere Bell-Labs-Forscher machten Unix anschließend zu einer kollektiven Leistung.

Wie unterscheiden sich Thompsons und Ritchies Beiträge?

Thompson schuf das ursprüngliche Unix und B. Ritchie war Hauptdesigner von C und zentral an der Neufassung von Unix in C beteiligt.

Wird B noch verwendet?

Kaum. Historisch ist es wichtig als direkter Vorgänger von C.

Hat Thompson die Unix-Pipes erfunden?

Doug McIlroy formulierte und propagierte die Idee; Thompson implementierte sie 1973 in Unix.

Welche Verbindung besteht zwischen Unix und Go?

Keine direkte technische Abstammung. Beide zeigen jedoch Thompsons Vorliebe für kleine Sprach- und Systemkonzepte, die Komplexität durch klare Kombination beherrschbar machen.

War dieser Artikel hilfreich?

Quellen und Referenzen

Sammlung

Programmiersprachen

17 / 26

  1. 01Grace Hopper: von frühen Compilern zu COBOL
  2. 02John Backus: FORTRAN, BNF und die Abkehr vom Maschinencode
  3. 03Dennis Ritchie: die Sprache C im Herzen von Unix
  4. 04FORTRAN: der Beweis, dass ein Compiler mit Assembler konkurrieren kann
  5. 05Die Sprache C: Systeme portabel machen, ohne die Maschine zu verbergen
  6. 06Niklaus Wirth: von Pascal bis Oberon – Entwurf durch Einfachheit
  7. 07Bjarne Stroustrup: C++ entwerfen, ohne auf Leistung zu verzichten
  8. 08Pascal: Programmieren lernen, indem Struktur sichtbar wird
  9. 09C++: von C with Classes zum modernen C++
  10. 10Objektorientierte Programmierung: Objekte, Nachrichten und wiederverwendbare Abstraktionen
  11. 11Guido van Rossum: Python für lesbaren Code entwickeln
  12. 12Brendan Eich: JavaScript vom Netscape-Prototyp zum Webstandard
  13. 13James Gosling: der Ingenieur hinter Java
  14. 14Python: Lesbarkeit, Batteries included und ein globales Ökosystem
  15. 15Java: einmal schreiben, überall ausführen
  16. 16JavaScript: die Sprache, die das Web interaktiv machte
  17. 17Ken Thompson: von Unix bis Go, Einfachheit als Methode
  18. 18John McCarthy: Lisp und die Idee, mit Symbolen zu programmieren
  19. 19Alan Kay: Smalltalk und der Computer als persönliches Medium
  20. 20Barbara Liskov: Abstraktion als Grundlage modularer Software
  21. 21Robin Milner: ML, rechnergestützte Beweise und Sprachen der Interaktion
  22. 22Brian Kernighan: AWK, Unix und die Kunst, Code zu erklären
  23. 23Anders Hejlsberg: von Turbo Pascal zu C# und TypeScript
  24. 24Larry Wall: Perl, die Sprache, die die Werkzeuge des Internets verband
  25. 25Yukihiro Matsumoto: Ruby und das Glück der Programmierenden
  26. 26Rasmus Lerdorf: PHP und die Demokratisierung des dynamischen Webs