Die Evolution der Programmiersprachen Wie wir lernten, mit Computern zu reden

Anbieter zum Thema

MicroConsult Academy GmbH

Rust, Python oder C gehören heute zum Standardrepertoire eines Computer-Programmierers. Doch der weg von der direkten Einspeisung binärer Befehle in Systemregister bis zum modernen Vibe Coding war weit.

Schon Ada Lovelace beschrieb 1843 für Charles Babbages nie fertiggestellte Analytical Engine einen Ablauf zur Berechnung von Bernoulli-Zahlen. Dieses gilt für gewöhnlich als das erste Computer-Programm. Auch wenn Lovelace damit einem Leser verständlich machen konnte, wie ein solches Programm aufgebaut werden könnte, war aber mangels eines fertigen Rechners eine Frage noch weitgehend offen: Wie können wir mit dem Computer „reden“, damit er versteht, wie unsere Anweisungen umzusetzen sind? Und wie können wir dies auf eine Art und Weise tun, die auch für Menschen möglichst natürlich und nachvollziehbar bleiben? Als rund ein Jahrhundert später die ersten elektronischen Universalrechner entstanden, ließ sich diese Idee zunächst nur eingeschränkt umsetzen.

Als Programmieren noch bedeutete, den Computer umzubauen

Beim 1945 fertiggestellten ENIAC existierte zunächst kein Programm, das einfach aus einem Speicher geladen wurde. Für neue Berechnungen mussten Kabel umgesteckt sowie Schalter und Funktionstabellen eingestellt werden. Die sechs Frauen, die zu seinen ersten Programmierern gehörten – Kay McNulty, Betty Jennings, Betty Snyder, Marlyn Wescoff, Fran Bilas und Ruth Lichterman – erhielten dafür anfangs weder Programmiersprache noch ausführliche Schulungen. Sie arbeiteten sich anhand von Schalt- und Blockdiagrammen in die Maschine ein und übertrugen ihre Abläufe anschließend auf Hunderte Steckverbindungen und Tausende Schalter.

Dass Frauen in dieser Frühphase eine zentrale Rolle spielten, war kein Zufall. „Computer“ war zuvor eine Berufsbezeichnung gewesen: Hunderte meist weibliche mathematische Hilfskräfte berechneten etwa ballistische Tabellen mit mechanischen Rechenmaschinen. Einige dieser „human computers“ wurden nun zu Programmiererinnen elektronischer Rechner. Software galt zunächst weniger als prestigeträchtige Ingenieursarbeit denn als Fortsetzung mathematischer Rechenarbeit.

Mit dem Stored-Program-Prinzip konnten Befehle schließlich selbst im Speicher liegen. Doch programmiert wurde zunächst in Maschinencode: Zahlenfolgen, die unmittelbar einer Rechnerarchitektur entsprachen. Eine der ersten Antworten darauf kam wiederum von einer Frau. Kathleen Hylda Valerie Britten, später Kathleen Booth, arbeitete ab 1946 am Birkbeck College an frühen Rechnern. 1947 entwickelte sie mit Andrew Booth ein symbolisches Codiersystem für den ARC und war an Assembler und Autocode der Birkbeck-Rechner beteiligt. Ihre Arbeit wird häufig als eine der ersten, teils als die erste Assemblersprache bezeichnet – wegen parallel entstandener Systeme ist die Prioritätsfrage nicht völlig eindeutig. Statt numerischer Operationscodes konnten nun symbolische Kürzel und Adressen verwendet werden: Der Programmierer musste die Maschine weiterhin verstehen, aber nicht mehr ausschließlich in ihren Zahlen denken.

FORTRAN, COBOL und BASIC: Gemeinsame Sprachen für Maschinen und Anwender

Der nächste Sprung bestand darin, sich vom konkreten Befehlssatz des Rechners zu lösen. Eine treibende Person war Grace Hopper. Für den UNIVAC entwickelte sie 1952 A-0, ein frühes Compiler-System; später folgten MATH-MATIC und FLOW-MATIC. Letzteres beschrieb Geschäftsabläufe in einer stärker an Englisch orientierten Form und beeinflusste die ab 1959 entwickelte Sprache COBOL erheblich. Hopper war nicht deren alleinige Erfinderin – COBOL entstand im CODASYL-Komitee –, doch ihr Grundgedanke wurde prägend: Der Mensch beschreibt das Problem verständlich, der Computer übernimmt die Übersetzung.

Fast zeitgleich entwickelte John Backus bei IBM FORTRAN („Formula Translation“) für wissenschaftlich-technische Berechnungen. Als die Sprache 1957 für den IBM 704 erschien, war ihr optimierender Compiler der Schlüssel zum Erfolg. Viele Programmierer bezweifelten, dass automatisch erzeugter Code mit handgeschriebenem Assembler mithalten könne. Das FORTRAN-Team erzeugte jedoch Code, dessen Effizienz nahe an handoptimierten Programmen lag – und machte die Hochsprache damit wirtschaftlich ernstzunehmend.

Von nun an entstanden Sprachen für unterschiedliche Anwender und Denkweisen. FORTRAN prägte Wissenschaft und Technik, COBOL Geschäfts- und Verwaltungssoftware. John McCarthys LISP schlug 1958 einen anderen Weg ein: Programme und Daten konnten als Listen behandelt werden, Rekursion und symbolische Verarbeitung rückten ins Zentrum – eine frühe Wurzel funktionaler Programmierung.

1964 folgten zwei besonders unterschiedliche Ansätze. John Kemeny und Thomas Kurtz entwickelten BASIC am Dartmouth College, um Programmieren auch Studenten und Nicht-Spezialisten zugänglich zu machen. Zusammen mit Time-Sharing wurde Programmierung interaktiver; ein Jahrzehnt später passte BASIC ideal zur Heimcomputerrevolution. Beim Altair 8800 erfolgte die Eingabe in der Grundversion noch über Kippschalter, doch bereits der zeitgenössische Artikel stellte die Vorteile von Assembler sowie FORTRAN und BASIC gegenüber Maschinencode heraus. Bill Gates, Paul Allen und Monte Davidoff machten Altair BASIC 1975 schließlich zu einem frühen kommerziell bedeutenden Softwareprodukt für Mikrocomputer.

IBMs PL/I ging fast in die Gegenrichtung: Die Mitte der 1960er entwickelte Sprache sollte wissenschaftliche FORTRAN-Aufgaben ebenso abdecken wie COBOL-artige Geschäftsverarbeitung und zugleich Blockstruktur, Rekursion, Exceptions und Multitasking bieten. Der Anspruch war nahezu universal – und entsprechend komplex. Schon hier zeigte sich ein bis heute aktueller Konflikt: Soll eine Sprache möglichst viele Aufgaben lösen oder für einen klaren Zweck möglichst einfach bleiben?

Vom Programmiersprachen-Babylon zur strukturierten Programmierung

In den 1960er und 1970er Jahren wurde aus der Leiter von „niedrigen“ zu „höheren“ Sprachen endgültig ein Stammbaum. ALGOL 60 etablierte eine systematische Blockstruktur und beeinflusste unter anderem Pascal und C. Simula ergänzte ALGOL-Ideen um Klassen und Objekte und gilt als erste für objektorientierte Programmierung entworfene Sprache; Smalltalk machte das Objekt in den 1970ern zum Mittelpunkt eines kompletten Systems. Prolog setzte auf logische Regeln, SQL auf deklarative Datenabfragen: Der Programmierer beschreibt stärker, welches Ergebnis benötigt wird, statt jeden Rechenschritt vorzugeben.

Dabei gab es auch Entwicklungen, die sich rückblickend als Sackgassen erwiesen. Ein Beispiel hierfür ist Forth. Charles „Chuck“ Moore entwickelte die stackbasierte Sprache um 1970 aus seiner Arbeit an kleinen Rechnern und Steuerungssystemen. Statt immer umfangreichere Hochsprachen zu bauen, setzte Forth auf einen winzigen Sprachkern, Stapel und die Möglichkeit, neue „Wörter“ aus vorhandenen zu definieren. 1971 lief eine vollständige Implementierung am 11-Meter-Radioteleskop des National Radio Astronomy Observatory. Gerade auf ressourcenarmen Systemen wurde diese radikale Einfachheit attraktiv.

Mit wachsenden Programmen wurde Komplexität zum entscheidenden Problem. Edsger W. Dijkstra gehörte zu den wichtigsten Vertretern der Idee, Programmierung müsse eine methodische, nachvollziehbare Disziplin werden. Sein 1968 veröffentlichter Text, berühmt unter dem redaktionell vergebenen Titel „Go To Statement Considered Harmful“, richtete sich gegen unkontrollierte Sprünge im Programmablauf. Das Ziel war größer als die Abschaffung eines Befehls: Programme sollten aus klaren Kontrollstrukturen bestehen, deren Verhalten sich systematisch verstehen ließ.

Strukturierte Programmierung mit Sequenzen, Schleifen, Entscheidungen und Prozeduren prägte Sprachen wie Pascal. Der nächste große Fortschritt führte dann paradoxerweise wieder näher an die Hardware: Eine Sprache sollte genügend Struktur für große Programme besitzen, aber effizient genug bleiben, um damit Betriebssysteme zu schreiben.

C und C++: Durchbruch für objektorientierte Sprachen

Diese Sprache war C. Dennis Ritchie entwickelte sie zwischen 1969 und 1973 bei den Bell Labs aus der Linie BCPL und B, eng verbunden mit Ken Thompsons Unix. C bot Datentypen, Funktionen und Kontrollstrukturen, gab Programmierern über Zeiger und direkte Speicherzugriffe aber viel Kontrolle. 1973 wurde der größte Teil von Unix in C neu geschrieben. Betriebssystemsoftware musste damit nicht mehr für jede Prozessorarchitektur vollständig in Assembler neu entstehen: C verband Portabilität mit bemerkenswerter Hardware-Nähe.

Diese Balance erklärt die enorme Langlebigkeit. C wurde Fundament für Betriebssysteme, Compiler, Treiber und Embedded Software und beeinflusste zahllose Nachfolger. „Heute dominierend“ gilt allerdings nur mit Einschränkung: In der gesamten Softwarelandschaft besitzen Python, JavaScript oder Java enorme Bedeutung, während C vor allem bei System- und Embedded-Software prägend bleibt. Das beigefügte IEEE-Spectrum-Ranking von 2024 zeigt sogar einen Rückgang von C, während C++ stark bleibt und Rust zulegt.

Bjarne Stroustrup wollte Ende der 1970er eine Schwäche von C adressieren: Große Systeme ließen sich effizient programmieren, aber nur begrenzt durch stärkere Abstraktionen ordnen. Stroustrup kannte Simula und schätzte dessen Klassenkonzept, war aber mit der Laufzeiteffizienz unzufrieden. 1979 begann er bei Bell Labs mit „C with Classes“; 1983 entstand der Name C++, 1985 erschien die erste kommerzielle Version. Sein Ziel war, Datenabstraktion und objektorientierte Programmierung mit der Effizienz von C zu verbinden.

Objektorientierung war keineswegs neu, wurde aber in den 1980er und vor allem 1990er Jahren zum Mainstream. C++ brachte sie in System- und Anwendungssoftware, Java machte Klassen und Objekte ab 1995 zum Kern einer bewusst portablen Plattform. Statt unmittelbar für einen Prozessor wurde für die Java Virtual Machine kompiliert; Garbage Collection und Standardbibliotheken nahmen Entwicklern weitere Aufgaben ab. Gleichzeitig entstanden Python, JavaScript, PHP und Ruby. Mit dem Web wurden Entwicklungszeit, Wartbarkeit, Bibliotheken und schnelle Bereitstellung oft wichtiger als maximale Ausführungsgeschwindigkeit.

In den 2000er Jahren kam deshalb weniger ein einzelnes neues Paradigma hinzu als eine Vermischung vorhandener Ansätze. C#, Java und später C++ übernahmen funktionale Konzepte; dynamische Sprachen erhielten leistungsfähige Laufzeiten und Frameworks. Objektorientierte, imperative, funktionale und deklarative Elemente konnten nun in derselben Sprache nebeneinanderstehen. Gleichzeitig rückten Nebenläufigkeit, verteilte Systeme sowie stärkere Typ- und Sicherheitsprüfungen in den Mittelpunkt.

Smartphone, Cloud und Speichersicherheit: Ansprüche an moderne Programmiersprachen

Mit Smartphone und Tablet folgte in den 2010er Jahren der nächste Schub. Mobile Software musste auf energiebegrenzter Hardware laufen und zugleich Touch-Oberflächen, Sensoren, Funkverbindungen und große Betriebssystem-Frameworks beherrschen. Apple führte 2014 Swift als moderne Alternative zu Objective-C ein. Hohe Leistung sollte mit Typsicherheit und zugänglicher Syntax verbunden werden; inzwischen ist Swift die bevorzugte Sprache für Apple-Plattformen. Auf Android wurde Kotlin 2017 offiziell unterstützt, 2019 erklärte Google die Entwicklung zunehmend „Kotlin-first“. Null-Safety, kompakte Syntax und Koroutinen zeigen, wie moderne Sprachen typische Fehler bereits durch ihr Design vermeiden wollen.

Noch deutlicher wird der Wandel bei Go und Rust. Go entstand ab 2007 bei Google aus den Erfahrungen von Robert Griesemer, Rob Pike und Ken Thompson mit großen Codebasen, Multicore-Prozessoren und verteilten Systemen. Die Sprache setzt auf Einfachheit, schnelle Übersetzung, einheitliche Werkzeuge, Garbage Collection und leichtgewichtige Nebenläufigkeit – und damit vor allem auf die alltäglichen Probleme großer Softwareteams.

Rust setzt an einer anderen Schwachstelle an – und führt damit zurück zu C. Graydon Hoares Projekt wurde 2010 bei Mozilla öffentlich vorgestellt und sollte hohe Geschwindigkeit und Hardwarekontrolle mit stärkerer Speichersicherheit verbinden. Das Ownership- und Borrowing-Modell lässt den Compiler prüfen, wem Speicher gehört und wie Referenzen verwendet werden. Viele klassische Fehlerklassen aus C und C++ sollen so bereits beim Übersetzen abgefangen werden, ohne zwingend einen Garbage Collector einzusetzen.

Damit hat sich der Anspruch an Programmiersprachen erneut verschoben. Die frühen Hochsprachen befreiten Menschen von numerischen Opcodes; FORTRAN machte mathematische Aufgaben ausdrückbar, COBOL Geschäftsprozesse, BASIC Programmierung zugänglich, C Systemsoftware portabel und C++ große Programme besser strukturierbar. Moderne Sprachen versuchen zusätzlich, ganze Fehlerklassen zu verhindern und Parallelität sowie verteilte Systeme beherrschbar zu machen.

Neue Sprachen lösen die alten dabei nicht einfach ab. FORTRAN wird weiterhin in Wissenschaft und Hochleistungsrechnen gepflegt, COBOL in jahrzehntealten Geschäfts- und Banksystemen; selbst das 2024 aus dem IEEE-Spectrum-Index gefallene Forth lebt in Nischen weiter. Gleichzeitig steht Python in aktuellen Rankings weit vorne, während C und C++ unterhalb vieler moderner Softwarestapel weiterarbeiten.

Vielleicht ist genau das die wichtigste Konstante in fast acht Jahrzehnten Sprachgeschichte: Es gibt nicht die eine „beste“ Programmiersprache. Jede Generation zieht die Grenze zwischen Mensch und Maschine neu. Assembler gab Maschinenbefehlen Namen. Hochsprachen versteckten den konkreten Prozessor. Objektorientierung und Module halfen, wachsende Programme zu ordnen. Mobile Plattformen banden Sprache und Ökosystem enger zusammen, Rust verlagert heute Teile der Fehlervermeidung in das Typsystem. Die Geschichte des Programmierens ist damit weniger die Geschichte davon, wie Menschen Computer besser bedienen lernten – sondern wie sie Computer dazu brachten, immer mehr Arbeit des Programmierens selbst zu übernehmen. (sg)

(ID:50959157)