Startseite
Geschichten
Betriebssysteme
Die Entwicklung der Betriebssysteme
von Boris Jakubaschk

Betriebssysteme sind historisch gesehen sehr eng mit der jeweiligen Rechnerarchitektur verbunden. Man kann daher die wesentlichen Entwicklungsstufen der Betriebssysteme mit den Generationen der Hardwareevolution in Verbindung setzen.

Die ersten Rechner - ganz ohne Betriebssystem
In den 40er und 50er Jahren des vergangenen Jahrhunderts, also der Zeit von Zuses Z3, des relaisbasierten „Mark I“ und des röhrenbasierten „Eniac“ benötigte jeder Rechner eine eigene Projektgruppe für Programmentwurf und -erstellung, für das Operating und die Wartung des Rechners. Dabei geschah die eigentliche Steuerung der Basisfunktionen sowie die Programmierung ausschließlich in Maschinensprache oder, was durchaus nicht die Ausnahme war, dem Einbau von neuen Steckkarten mit fest verdrahteter Steuerlogik. Assemblersprachen waren genau so wenig bekannt wie Betriebssysteme.

Im Laufe der Zeit schufen sich die Programmierer etwas Erleichterung: Schnell war klar, dass bestimmte Programmteile immer wieder in ähnlicher Form benötigt wurden. Es lag also nahe, solche Programmteile zu identifizieren und dann in einer Art Bibliothek allen anderen Programmierern des gleichen Systems zugänglich zu machen. Dieses Verfahren ist bis heute unter dem Namen "Funktionsbibliothek" gebräuchlich - Programme nutzen die Fähigkeiten des Betriebssystems über von diesem bereitgestellte Bibliotheken, die Application Programmers Interfache (API) genannt werden. Damals waren Funktionsbibliotheken allerdings durchaus im Sinne einer Bücherei zu verstehen: Zu jeder Funktion wurde ein Stapel Lochkarten vorgehalten, auf denen sie abgespeichert war. Um die Funktion in ein Programm einzubinden, wurden einfach die entsprechenden Lochkarten mit dazugepackt. Später waren dann wesentliche Funktionen bereits fest im Computer eingespeichert und konnten von Programmen aus als Unterprogramme genutzt werden. Mit etwas gutem Willen kann man dies als allererste Ausprägung eines Betriebssystems sehen.

Eine weitere Vereinfachung brachte die Einführung von Programmiersprachen. Die Programmierer konnten ihre Programme damit in einer relativ gut lesbaren Notation erstellen. Um sie dem Computer begreiflich zu machen, war dann allerdings eine Übersetzung in die von diesem verwendete Maschinensprache notwendig. Dafür gab es wiederum ein Programm, das "Compiler" genannt wurde. Die ersten weit verbreiteten Programmiersprachen waren Cobol (eher im wirtschaftlichen Bereich) und Fortran (hauptsächlich für Berechnungen und technische Anwendungen). Selbst Maschinenspracheprogrammierer nutzten bald eine leichter lesbare Variante, bei der die Maschinenbefehle in Form von Kürzeln (sogenannten Mnemonics) notiert wurden. Dies wurde dann als "Assembler" bezeichnet.

Transistoren und einfache Stapelverarbeitungssysteme
Mit der Einführung von Transistoren wurden Rechner so zuverlässig, dass sie in größeren Stückzahlen industriell gefertigt wurden und der Betrieb ohne die permanente Anwesenheit eines Technikers möglich war. Damit wurden die Geräte zunehmend auch an gewerbliche Kunden verkauft, während sie zuvor meist direkt vom Hersteller oder an einer Universität betrieben wurden und nur die Rechenzeit verkauft wurde.

Die Rechner wurden in klimatisierten Räumen untergebracht und von einem ganzen Stab professioneller Operatoren betreut. Ausschließlich sehr große Unternehmen, Behörden und Forschungseinrichtungen konnten sich den Preis von mehreren Millionen Dollar leisten. Um ein Programm zur Ausführung zu bringen, musste ein Programmierer dieses zunächst auf Papier entwickeln, anschließend auf Lochkarte codieren und diese dann im Eingaberaum einem Operator übergeben. Das Ergebnis konnte er dann, sofern er keinen Fehler im Programm hatte, mehrere Stunden später im Ausgaberaum abholen. Wenn beispielsweise ein Fortran-Compiler für die Programmausführung benötigt wurde, so musste der Operator diesen aus einer „Box“ mit Lochkarten oder Bändern holen und ebenfalls einlesen. So wurde ein großer Teil der teuren Rechenzeit durch das Laufen der Operatoren verschwendet. auf Grund der enorm hohen Kosten früher Rechner versuchte man diesen Ablauf zu optimieren. Hierzu wurden die anstehenden Jobs im Eingaberaum gesammelt und mittels eines kleineren, relativ billigen Rechners auf ein Magnetband eingelesen. Dieses wurde zusammen mit den evt. benötigten Zusatzprogrammen (z.B. Compiler) zum eigentlichen Rechner gebracht und vom Operator mit einer speziellen Befehlsfolge geladen und abgearbeitet. Außerdem war es notwendig, die einzelnen Jobs logisch voneinander zu trennen, d.h. Beginn und Ende deutlich zu kennzeichnen. Nachfolgend entstanden die ersten Betriebssysteme, z.B. FMS (Fortran Monitor System) oder IBSYS, das Betriebssystem der IBM 7094.



Die Struktur eines typischen Eingabe-Jobs lässt sich grob wie folgt skizzieren. Den Anfang kennzeichnet die $Job–Karte, auf der die maximale Laufzeit des Programms, eine Abrechnungsnummer sowie der Name des Programmierers angegeben ist. Danach folgte eine Liste der zusätzlich benötigten Hilfsmittel, beispielsweise einem Fortran-Compiler, der durch das Betriebssystem von einem separaten Systemband geladen werden musste. Dieser Karte folgte das zu übersetzende Programm sowie eine $Load-Karte, mit der das Betriebssystem veranlasst wurde, das soeben übersetzte Objektprogramm zu laden. Als nächstes folgte die $RUN-Karte, die das Betriebssystem aufforderte, das geladene Programm auszuführen und auf die unmittelbar folgenden Daten anzuwenden. Schließlich markiert die $END-Karte das Ende des Jobs. Diese Kontrollkarten sind quasi der Vorläufer heutiger Job-Controllsprachen.

ICs und erste komplexe Betriebssysteme:
Zu diesem Zeitpunkt waren die verschiedenen Produkte eines Herstellers untereinander völlig inkompatibel. Das war insbesondere deswegen problematisch, weil viele Anwender zunächst kleinere Rechner kauften und diese später durch leistungsfähigere Maschinen ersetzen wollten, natürlich unter der Maßgabe, dass die bereits erstellten Programme darauf ebenso laufen sollten. IBM versuchte dieses Problem zu lösen, in dem sie das System/360 einführte. Hierbei handelte es sich um eine Serie von software-kompatiblen Rechnern – eine Rechnerfamilie, die den Anforderungen der unterschiedlichen Kundengruppen (technisch-wissenschaftliche versus kommerzielle Anwendungen) gerecht werden sollte. Damit die Anwendungsprogramme der Kunden auf allen Rechnern der Produktfamilie ablaufen konnten, mussten rechnerübergreifend bestimmte Basisfunktion einheitlich zur Verfügung gestellt werden. Mit OS/360 entstand das erste richtige Betriebssystem, etwa um den Faktor 3 bis 4 komplexer als FMS, mit Millionen von Zeilen Assemblercode und von Tausenden von Programmierern entwickelt.

Mit OS/360 und den anderen Betriebssytemen dieser Generation wurden wesentliche Schlüsseltechniken heutiger Betriebssysteme erstmalig realisiert. Musste die IBM 7094 während Ein- und Ausgabeoperationen noch in einem speziellen Wartezustand auf deren Beendigung warten, so sah OS 360 bereits einen Mehrprogrammbetrieb vor. Gerade bei der kommerziellen Datenverarbeitung kann die mit der Ein-/Ausgabe verbundene Wartezeit durchaus 80 oder 90 Prozent der gesamten Rechnerzeit beanspruchen. Die Lösung bestand darin, dass ein Programm, welches auf die Beendigung seiner Ein-/Ausgabe warten musste, quasi auf eine Warteposition gesetzt wurde, so dass die CPU zwischenzeitlich ein anderes Programm abarbeiten konnte. Hierzu war es erforderlich, dass mehrere Programme gleichzeitig im Arbeitsspeicher gehalten werden konnten. Eine weitere wichtige Eigenschaft der „neuen“ Betriebssysteme war die Fähigkeit, die Ausgabedaten auf Platten zwischenzuspeichern, was als Spooling (Simultaneous Peripheral On Line) bezeichnet wird.

Da für viele Anwendungen zwischen dem Abschicken eines Jobs und der Ausgabe mehrere Stunden lagen, sehnten sich viele Programmierer in die guten alten Zeiten zurück, in denen der Rechner ihnen in einem vorreservierten Zeitfenster ausschließlich zur Verfügung stand. Der Drang nach kurzen Antwortzeiten führte dazu, dass Betriebssysteme einen Multiuserbetrieb unterstützten, in dem die einzelnen Anwender über ein Terminal im „Timesharing“-Verfahren Zugriff auf den Rechner erhielten.

PCs und erste Netzwerkbetriebssysteme:
Der nächste Schritt in der Entwicklung der Betriebssysteme brach mit dem Zeitalter der Personal Computer an. Da der überwiegende Anteil der Benutzer von PCs nur sehr wenig Kenntnisse über Computer und deren interne Abläufe hatte, änderten sich auch die Anforderungen an die darauf eingesetzten Betriebssysteme. Es sollte benutzerfreundlich, leicht erlernbar und möglichst unkompliziert sein. Neben zahllosen proprietären Systemen setzte sich in den späten 70er Jahren ein Produkt von Digital Research als erster Industriestandard durch: CP/M. Es wurde auch von IBM als Betriebssystem für den IBM PC favorisiert, es kam aber kein Vertragsabschluss mit dem Chef von Digital Research, Gary Kildall, zustande. So wählte IBM eine andere Lösung, nämlich das von Microsoft angebotene MS-DOS, das zuvor von der Firma SCP als QDOS (Quick and Dirty Operating System) mit CP/M und Unix als Vorbildern entwickelt wurde und anfangs seinem Namen angeblich durchaus gerecht wurde. MS-DOS verdrängte CP/M in den 80er Jahren schnell vom Markt und mit ihm fast alle anderen Systeme.

Die zunehmende Vernetzung führte dann ab Mitte der 80er Jahre zu der Entwicklung von Netzwerkbetriebssystemen, während in den 90er Jahren rein textorientierte Benutzeroberflächen sukzessive durch grafische Benutzerschnittstellen abgelöst wurden.