Algol 68
Algol 68 ist eine Programmiersprache. Ihr Entwurf beruhte auf den Anforderungen, dass sie geeignet sein soll, Algorithmen darzustellen und zu verbreiten, diese effektiv auf einer Vielzahl unterschiedlicher Rechenanlagen auszuführen und um zu helfen, sie Studenten zu lehren.

Die Sprache Algol 68 stellte einen neuen Anlauf dar, beruhte jedoch auf den Erfahrungen mit Algol 60 und den Prinzipien dieser Sprache. Ziel war ein wesentlich breiterer Anwendungsbereich und eine stringentere Sprachdefinition. Die Definition wurde als Report on the Algorithmic Language ALGOL 68 erstmals 1968 veröffentlicht und 1976 im Revised Report grundlegend revidiert.

Der Bericht nennt als Ziele: Vollständigkeit und Klarheit der Beschreibung, Orthogonalität des Entwurfes, Sicherheit, Effizienz.

Im Vergleich zu Algol 60 wurden einige Konzepte vereinheitlicht; neu eingeführt wurde das Konzept eines Namens, ein Wert, der auf andere Werte referenziert, die Möglichkeit zur Definition von Strukturen und anderer Datentypen. Aus der geringeren Akzeptanz von Algol 60 verglichen mit FORTRAN wurde geschlossen, dass eine Definition von Ein- und Ausgabe die Verbreitung fördern könnte.

Kritiker wandten ein, die Sprache habe nicht mehr die Einfachheit von Algol 60 und sei zu schwierig zu implementieren. Konzepte, die in praktisch erfolgreicheren Sprachen wie C++ weitere Verbreitung fanden, wie Überladen von Operatoren, wurden erstmals syntaktisch definiert. Im Unterschied zu Algol 60 ist die Sprache weitestgehend ausdrucksorientiert, daher auch als frühes Beispiel einer funktionalen Programmiersprache anzusehen.

In der Beschreibung der Programmiersprache wurde ein neuartiges Beschreibungsverfahren, die 2-stufige Grammatik, auch Van-Wijngaarden-Grammatik genannt, entwickelt. Diese erlaubte es, alle Kontextbedingungen mit zu formalisieren.

Neu war auch das Konzept PRAGMAT, das Hinweise zur Optimierung für die Compiler erlaubte, ohne die Semantik eines Programms zu ändern, sodass die Programme trotz Optimierung portabel blieben.

Algol 68 wurde von einigen als akademisches Projekt betrachtet, weil längere Zeit brauchbare Compiler fehlten, die den gesamten Sprachstand implementierten.

Reservierte Symbole 
In Algol 68 gibt es folgende reservierten Symbole:
 mode, op, prio, proc,
 flex, heap, loc, long, ref, short,
 struct, union,
 of, at, is, isnt, true, false, empty, nil, skip,
 co, comment, pr, pragmat,
 case, in, ouse, out, esac,
 for, from, to, by, while, do, od,
 if, then, elif, else, fi
 par, begin, end, go, to, goto, exit.

Für einige dieser Symbole gibt es Abkürzungen:
 p is q     ↦ p :=: q
 r isnt nil ↦ r :/=: ∘
 skip ↦ ~
 at   ↦ @ 
 co   ↦ ¢
 case x in a, b ouse y in c, d, e out f esac ↦ ( x | a, b |: y | c, d, e | f )
 if x then a elif y then b else c fi         ↦ ( x | a |: y | b | c )
 begin a; b; c end                           ↦ ( a; b; c )

Die Bezeichnungen für Modes und Operatoren werden mit dem gleichen Zeichensatz geschrieben wie die reservierten Symbole, sind aber nicht reserviert, sondern können mit einer anderen Bedeutung deklariert werden, die dann innerhalb eines Blocks gilt. Folgende Modes sind ohne explizite Deklaration definiert:
 bits, bool, bytes, char, compl, int, real, sema, string, void,
 channel, file, format

Compiler-Anweisungen und Kommentare 
Compiler-Anweisungen werden in das Programm eingefügt. Sie enthalten typischerweise Hinweise für den Compiler, z. B.:
 pragmat heap=32 pragmat
 pr heap=32 pr

Kommentare können auf verschiedene Arten eingefügt werden:
 ¢ Der ursprüngliche Weg einen Kommentar hinzuzufügen (analog der englischen Phrase: Adding your 2 cents) ¢
 comment "bold" comment comment
 co Kommentar 1. Form co
 # Kommentar 2. Form #
 £ Dieser Kommentar benutzt das hash/pound Zeichen einer UK Tastatur £

Normalerweise können Kommentare in Algol 68 nicht geschachtelt werden. Diese Einschränkung kann umgangen werden, indem unterschiedliche Kommentarsymbole verwendet werden (z. B. Der Hash wird nur für kurzzeitiges Löschen verwendet).

Datentypen 
Algol 68 bezeichnet Datentypen als modes. Die grundlegenden Datentypen sind real, int, compl, bool, char, bits, bytes und void. Zum Beispiel:
 int n = 2;
 co n ist eine Konstante mit dem Wert 2. co
 real avogadro = 6.0221415⏨23; co Avogadrozahl co
 long long real pi = 3.14159 26535 89793 23846 26433 83279 50288 41971 69399 37510;
 compl square root of minus one = 0 ⊥ 1

Der Datentyp void umfasst nur einen einzigen Wert, nämlich empty, hat also keinen Informationsgehalt. Damit werden Ausdrücke und Funktionen charakterisiert, die kein verwertbares Ergebnis liefern; so werden die Konzepte Ausdruck und Anweisung vereinheitlicht, ebenso Funktion und Prozedur. Beispiele:
 exit     ¢ Ausdruck vom Mode void, entspricht der FORTRAN-Anweisung STOP ¢
 print(f) ¢ Ausdruck vom Mode void, da print keinen Funktionswert liefert ¢
 7*"8"    ¢ Ausdruck vom Mode string mit dem Wert "8888888"               ¢
 proc (int)int  doppelt     = (int i)int : i*2;          ¢ Funktion mit int-Ergebnis ¢
 proc (int)void wellenlinie = (int n)void: print(n*"~"); ¢ Prozedur (ohne Ergebnis)  ¢

Statt modes wie DOUBLE, beziehungsweise LONG und SHORT, etc. gibt es in Algol 68 Modifizierer. So wird zum Beispiel long real oder long long real statt DOUBLE geschrieben. Typattribute wie small real (kleinster real-Wert, der bei Addition zu 1.0 ein Ergebnis ungleich 1.0 liefert) und max long int (größter darstellbarer long-int-Wert) werden verwendet, um Programme an verschiedene Implementierungen anzupassen.

Deklarationen 

Alle Bezeichner, etwa für Konstanten, Namen (entspricht Variablen und Pointern in früheren Programmiersprachen) oder Funktionen, müssen vereinbart werden; die Vereinbarung muss nicht vor der ersten Verwendung gemacht werden, aber natürlich ist für deren Sichtbarkeits-Bereich die Blockstruktur zu beachten. Viele Standard-Bezeichner etwa print oder max intsind in einem fiktiven, das gesamte Programm umgebenden, Block deklariert.

Dazu dient einheitlich die sogenannte Äquivalenz-Deklaration, mit der einem Bezeichner eine Bedeutung, bestehend aus Mode und Wert, zugewiesen wird. Beispiele:
 co Konstanten co
   int  f = 5;               ¢ der Bezeichner f bezeichnet nun den int-Wert 5                          ¢
   real z = f/2;             ¢ der Bezeichner z bezeichnet nun den real-Wert 2.5                       ¢
   real r = random;          ¢ der Wert der Konstanten r wird erst zur Laufzeit des Programms bestimmt ¢
 co Variable  co
   ref int v = loc int;      ¢ v bezeichnet eine neu deklarierte lokale int-Variable                   ¢
   ref int w = loc int := f; ¢ w bezeichnet eine lokale int-Variable mit Anfangswert 5                 ¢
 co Funktionen co
   proc (real)real h = (real x)real: x/2; ¢ h bezeichnet eine real-Funktion mit real-Parameter         ¢

Konstanten, Variable, Pointer und Funktionen können jedoch auch anonym, also ohne Deklaration verwendet werden. Das bietet sich an, wenn man die betreffende Entity nur an einer Stelle im Programm benötigt. Beispiel:
 ¢ integral sei eine Funktion, die ein bestimmtes Integral über einer real-Funktion berechnet.   ¢
 ¢ Die zu integrierende Funktion kann man entweder namentlich oder anonym an integral übergeben; ¢
 ¢ die zu integrierende Funktion hat offensichtlich den Mode proc(real)real                      ¢
 print(("Integral x/2    von 0 bis 3 =", integral (h,   0, 3 )));                ¢ h siehe oben ¢
 print(("Integral sin(x) von 0 bis π =", integral (sin, 0, pi)));                ¢ sin und pi sind Standard-Bezeichner ¢
 print(("Integral (2x+1) von 0 bis 1 =", integral ((real x)real: 2*x+1, 0, 1))); ¢ Anonyme Funktion ¢

Ähnlich wie Bezeichner können Modes und Operatoren deklariert werden. Beispiele:
 mode rfun = proc(real)real; ¢ rfun ist der Mode einer real-Funktion mit real-Parameter ¢
                             ¢ Operatoren sind Funktionen in anderer Gestalt; also werden sie wie Funktionen deklariert: ¢
 op (string,int)string * = (string s, int n)string: n*s;
 print("/\"*17);             ¢ im Gültigkeitsbereich der obigen op-Deklaration druckt das dasselbe wie print(17*"/\") ¢

Für einige gängige Äquivalenz-Deklarationen gibt es Abkürzungen. Zum Beispiel:
 loc int v;                           ¢ statt ref int v = loc int – int-Variable ¢
 loc int w := f;                      ¢ statt ref int w = loc int := f – int-Variable mit Anfangswert ¢
 int w := f;                          ¢ statt ref int w = loc int := f ¢
 proc h = (real x)real: x/2;          ¢ statt proc (real)real h = (real x)real: x/2 ¢
 op * = (string s, int n)string: n*s; ¢ statt op (string,int)string * = (string s, int n)string: n*s ¢

Literatur 
 Adriaan van Wijngaarden et al.: Revised Report on the Algorithmic Language ALGOL 68. In: Acta Informatica. Vol. 5, No. 1/3, 1975, , S. 1–236, online (PDF, 1,4 MB).
 
 Andrew S. Tanenbaum: A Tutorial on ALGOL 68. In: ACM Computing Surveys. Vol. 8, No. 2, 1976, , S. 155–190.

 Sian Leitch: . (PDF; 1,36 MB).

Weblinks 
 
 An ALGOL 68 interpreter
 99 bottles of beer Beispielprogramm

Imperative Programmiersprache