C.Isab, Software-Archäologe
Sprache zur Formulierung von Rechenvorschriften, d.h. von Datenstrukturen und Algorithmen, die von einem Computer ausgeführt werden können.Häufig werden heute 5 Generationen von Programmiersprachen unterschieden:
1. Generation: Maschinensprachen
Befehle werden direkt in einer Maschinensprache notiert, d.h. als Folge von
Zahlencodes. Da sich der Befehlssatz von Rechner mit unterschiedlichen
Prozessoren im allgemeinen unterscheidet, sind in Maschinensprache geschriebene
Programme nur sehr schwer übertragbar. Die direkte Programmierung in einer
Maschinensprache wird heute kaum noch verwendet.
Einige Programmiersysteme für höhere Programmiersprachen gestatten es, Maschinenbefehle in den Quelltext zu integrieren. Die Anwendung beschränkt sich dann auf solche Fälle, in denen es aus funktionalen oder Effektivitätsgründen unumgänglich oder nützlich ist, maschinennah zu programmieren.
2. Generation: Assembler
Anstelle von Zahlencodes wird mit Hilfe von symbolischen Bezeichnern codiert.
Eine Assembleranweisung wird in genau einen Maschinenbefehl umgesetzt. Auch
Assemblerprogramme sind deshalb im allgemeinen an einen bestimmten
Prozessortyp gebunden.
Makroassembler gestatten die Bildung von parametrisierbaren Befehlsgruppen.
Eine Makroanweisung wird im allgemeinen in mehr als einen Maschinenbefehl
umgesetzt.
Der Anteil der Assemblerprogrammierung ist im Sinken. Der Möglichkeit der Erstellung effektiver Programme steht die erschwerte Wartbarkeit von Assemblerprogrammen gegenüber. Maschinennahe Programmierung - die Domäne von Assembler - kann heute überwiegend durch höhere Programmiersprachen abgedeckt werden. Hierfür kommt z.B. C in Frage, auf dem PC zum Teil auch Turbo Pascal.
Einige Programmiersysteme für höhere Programmiersprachen gestatten es, Assemblerbefehle in den Quelltext zu integrieren. Die Anwendung kann sich dann auf die Situationen beschränken, in denen es aus funktionalen oder Effektivitätsgründen notwendig oder nützlich ist, maschinennah zu programmieren.
3. Generation: höhere Programmiersprachen (high level language)
Sprachen der 3. Generation unterstützen unmittelbar die Notation von
Algorithmen, sie sind weitgehend anwendungsneutral und maschinenunabhängig.
Erste höhere Programmiersprachen entstanden ab Mitte der fünfziger Jahre (FORTRAN, COBOL, ALGOL-60). Weitere Sprachen dieser Generation sind zum Beispiel PASCAL, MODULA-2, PL1, C, ADA, BASIC, SIMULA.
4. Generation: Fourth Generation Language (4GL)
Sprachen der 4. Generation sind anwendungsbezogen (applikative Sprachen). Sie
stellen i.a. die wichtigsten Gestaltungsmittel von Sprachen der 3. Generation
zur Verfügung, zusätzlich jedoch Sprachmittel zur Auslösung von
relativ komplexen, anwendungsbezogenen Operationen, beispielsweise zum Zugriff
auf Datenbanken und zur Gestaltung von Benutzeroberflächen.
Sprachen der 4. Generation gehören häufig zum Umfeld von Datenbanksystemen. Eine relativ weit verbreitete Sprache dieser Art ist z.B. NATURAL.
5. Generation: (Very High Level Language, VHLL)
Sprachen der 5.Generation gestatten das Beschreiben von Sachverhalten, von
Problemen. Sie kommen vor allem im Bereich der KI (künstliche Intelligenz)
zum Einsatz. Die Wahl des Problemlösungsweges kann (entsprechend dem
Sprachkonzept) dem jeweiligen System (weitgehend) überlassen werden.
Bekanntestes Beispiel für eine Sprache der 5. Generation ist PROLOG.
Sprachen der 1. Generation sind zwangsläufig hardwareabhängig. Auch
Sprachen der 2. Generation sind stark hardwarebezogen. Sprachen beider
Generationen werden daher auch als maschinenorientierte Sprachen
bezeichnet.
Mit den Sprachen der 3. bis 5. Generation wird eine weitgehende
Hardwareunabhängigkeit angestrebt.
Die Darstellung der Problemlösung (3. Generation) bzw. des Problems selbst
(4. und vor allem 5. Generation) rückt stärker in den Mittelpunkt.
Diese Sprachen lassen sich auch als problemorientierte Sprachen
kennzeichnen.
Das folgende Schema skizziert aus subjektiver Sicht die wichtigsten
Programmiersprachen in ihren Verwandschaftsverhältnissen. Die zeitliche
Abfolge der Entwicklung wird angedeutet.
Achtung:
Die Verwandschaftsverhältnisse sind in sich sehr verschieden und
keineswegs komplett erfaßt.
+------------------+
| Maschinensprache |
+------------------+
|
v
+-------------+
| Assembler |
+-------------+
|
+-----------------------+--------------+---------------+
| | | |
| | v |
| | +-------------+ |
| | | FORTRAN | |
V V +-------------+ V
+-------------+ +-------------+ | | +-------------+
| ALGOL 60 | | LISP | | | | COBOL |
+-------------+ +-------------+ | | +-------------+
| | | |
+--+-------------+---------------+-----+--+---+ | |
| | | | | | | |
v v v v | v v v
+-------------+ +-------------+ +-------------+ | +-------------+
| SIMULA 67 | | ALGOL 68 | | BASIC | | | PL/1 |
+-------------+ +-------------+ +-------------+ | +-------------+
| | |
| +---------------+ |
| v V v
| +-------------+ +-------------+ +-------------+
| | C | | Pascal | | Prolog |
| +-------------+ +-------------+ +-------------+
| | | | |
| | | +------------+-----+
v | v v v
+--------------+ | +-------------+ +-------------+
| Smalltalk-80 | | | Ada | | Modula-2 |
+--------------+ | +-------------+ +-------------+
| | | |
+----------+ | | |
v v v v v
+-------------+ +-------------+ +-------------+ +-------------+
| Eiffel | | C++ | | Oberon | | Modula-3 |
+-------------+ +-------------+ +-------------+ +-------------+
|
v
+-------------+
| Java |
+-------------+
Gegenwärtig spielen vor allem die folgenden Programmiersprachen eine
Rolle, die alle als prozedural einzustufen sind (die Reihenfolge ist
alphabetisch):