CLU (Programmiersprache)

CLU ist eine Programmiersprache, die zwischen 1974 und 1975 am Massachusetts Institute of Technology von Barbara Liskov und ihren Studenten entwickelt wurde. CLU war laut Liskov die erste implementierte Programmiersprache, die eine direkte sprachliche Unterstützung für Datenabstraktion bot, welches ein Schlüsselelement in der Entwicklung der objektorientierten Programmiersprachen war.

Die Idee zur Datenabstraktion kam im Zuge von Arbeiten zur Programmiermethodologie auf. Das primäre Ziel des Projekts, welches zur Entwicklung von CLU führte, war die Forschung zur Programmiermethodologie voranzutreiben. Gemäß eigenen Angaben sahen die Entwickler der Sprache ihr Ziel nicht in der Verbreitung derselben, sondern eher in der Verbreitung der Konzepte zur Softwareentwicklung; die in CLU umgesetzt wurden. Ihren Erfolg bemaßen sie im Einfluss, den ihre Publikationen auf der Entwicklung zukünftiger Programmiersprachen und ihrer Anwendung in der Praxis haben sollten. CLU erhielt somit einen symbolischen Charakter. Die Entwicklung von CLU wurde von der DARPA und der National Science Foundation unterstützt.

CLU ist nicht auf sogenannte low-level Programmierung ausgelegt, die man z. B. bei der Entwicklung von Betriebssystemen und ihren Komponenten anwendet. Die Sprache sollte erfahrene Programmierer ansprechen. Obwohl sie nicht als Lernsprache zu akademischen Zwecken wie Pascal gedacht ist, lässt sie sich auch als solche nutzen. CLU favorisiert die Lesbarkeit und Verständlichkeit von Softwaresystemen gegenüber der Einfachheit, funktionierenden Kode schreiben zu können. Es ist technisch gesehen als Werkzeug zur Entwicklung im großen Stil gedacht. Dabei wurde der Schwerpunkt auf der Entwicklung von großen Softwaresystemen gelegt, die mehrere Entwickler benötigen und deren Umfang mehrere tausend bis hunderttausend Zeilen Kode beinhaltet.

Entwicklung der Sprache

CLU wurde ursprünglich von vier Personen entwickelt: Barbara Liskov sowie die Studenten Russ Atkinson, Craig Schaffert und Alan Snyder. Steve Zilles war stark in den ersten Arbeiten zu CLU involviert. Ab 1974 verstärkte er aber seine Aktivitäten auf die Spezifikationen von abstrakten Typen und fungierte zum Schluss mehr und mehr als interessierter Schaulustiger und Kritiker des Entwurfprozesses. Mit der Zeit kamen weitere Studenten hinzu, u. A. Bob Scheifler und Eliot Moss. Die Entwicklung war stark auf Teamarbeit ausgerichtet. Es ist somit nicht möglich, einzelne Sprachelemente einzelnen Entwicklern zuzuordnen. Die Implementation erfolgte parallel zum Sprachentwurf. Es wurde nie zugelassen, dass die Implementation den Entwurf der Sprachelemente bestimmte. Die Fertigstellung von Sprachelementen wurde solange verzögert, bis der Entwurf derjenigen fertiggestellt war.

Es wurden verschiedene Programmiersprachen studiert um abzuklären, welche von ihnen eventuell als Basis für CLU in Frage käme. Die Entwickler kamen zum Schluss, dass keine der Sprachen geeignet wäre, da keine von ihnen Datenabstraktion unterstützt. Die Entwickler wollten wissen, wohin diese Idee sie bringen würde, ohne sich darüber sorgen zu müssen, wie es mit vorher existierenden Eigenschaften aufeinander wirken könnte. Dennoch wurden verschiedene Sprachelemente von vorhandenen Programmiersprachen übernommen. Das semantische Modell lehnt sich größtenteils an Lisp an; die Syntax wurde von ALGOL übernommen.

Sprachelemente

Cluster

Eines der wichtigsten Elemente von CLU ist das Konzept des Clusters. Dieses entspricht einem Objekt in einer objektorientierten Sprache wie C++ und weist ungefähr dieselbe Syntax auf.

Als Beispiel sei hier eine Implementation für komplexe Zahlen angeführt:

    complex_number = cluster is add, subtract, multiply, ...
        rep = record [ real_part: real, imag_part: real ]
        add = proc ... end add;
        subtract = proc ... end subtract;
        multiply = proc ... end multiply;
        ...
    end complex_number;

Obwohl das Konzept der Clusters ein dazumals fortschrittliches Werkzeug zur Strukturierung von Programmkode darstellte, existiert keinerlei Mechanismus, um die Cluster selbst zu strukturieren. Das bedeutet, dass Clusternamen global sind und keine Gruppierungen sowie Verschachtelungen von Cluster möglich sind. CLU unterstützt keine implizite Typkonvertierung: in einem Cluster wechseln die expliziten Konvertierungen mit den Befehlen up und down zwischen dem abstrakten Typ und der Representation. Des Weiteren wird ein universeller Datentyp any, sowie eine Prozedur force[] zur Verfügung gestellt. Die Prozedur überprüft, ob ein Objekt einen bestimmten Typ besitzt. Objekte können die Eigenschaften mutable und immutable aufweisen. Letztere werden als sogenannte native Datentypen wie z. B. Integer definiert.

Weitere Sprachelemente

Viele Funktionen von objektorientierten Sprachen wie z. B. die Vererbung wurden aus Entwurfsgründen absichtlich nicht implementiert, andererseits unterstützt CLU Sprachelemente wie die Ausnahmebehandlung, Iteratoren und parametrisierte Typen.

Ausnahmebehandlung (Exception Handling)

→ Hauptartikel: Ausnahmebehandlung

CLU unterstützt ebenfalls die Ausnahmebehandlung. Es bietet ein Mechanismus an, welcher auf dem Terminierungsmodell von Ausnahmen basiert. Ein Funktionsaufruf kann sich selbst unter verschiedenen Bedingungen beenden, eine der Bedingungen ist die Terminierung der Funktion mit einem definierten normalen Rückgabewert. Jeder andere Wert stellt eine Ausnahme dar. Der Mechanismus von CLU ist in seiner Behandlung von unbehandelten Ausnahmen ungewöhnlich. Die meisten Mechanismen zur Ausnahmebehandlung reichen diese durch den Baum an Funktionsaufrufen in einem Programmkode weiter: Wenn die Funktion, in der die Ausnahme ausgelöst wurde, diese nicht behandelt, wird sie der im Baum vorhergehenden Funktion weitergereicht. In CLU hingegen werden alle unbehandelten Ausnahmen in sogenannte "Failures" umgewandelt und als solche weitergereicht. Auf vielen Versuchen in anderen Programmiersprachen basierend werden Ausnahmen mit signal aufgeworfen und mit except abgefangen. Da der Fokus auf den Typentwurf gelegt wurde, existiert auch keine Möglichkeit, Aufzählungstypen zu erstellen.

Iteratoren

→ Hauptartikel: Iterator

Ein weiteres wichtiges Element von CLU sind die Iteratoren. Diese bezeichnen einen Zeiger, mit dem über die Elemente einer Liste bzw. durch die Elemente einer Menge iteriert werden kann. Iteratoren waren an ein Konstrukt namens Generator angelehnt, welches in der Programmiersprache Alphard angewendet wurde. Die Entwickler von CLU lernten die Idee der Generatoren im Rahmen einer Konferenz mit der Alphard Group kennen. Das Konzept interessierte die CLU-Entwickler, da es verschiedene Probleme bezüglich der Datenabstraktion löste. Allerdings befürchteten sie auch, dass dieses Konstrukt zu Komplex wäre. Trotzdem entwarf Russ Atkinson, von den Generatoren inspiriert, das Konzept der Iteratoren in CLU während eines Rückfluges von der Konferenz nach Boston. Er beschrieb diese in einer so genannten "Design note" im September 1975. Iteratoren in CLU stellen "Black Boxen" dar, die unabhängig von den Daten, auf denen sie angewendet werden, eine Programmierschnittstelle zur Verfügung stellen. Somit würden z. B. die Iteratoren für komplexe Zahlen und diejenigen für integer Datenfelder identisch sein. Iteratoren sind mittlerweile ein weit verbreitetes Sprachelement in vielen modernen Programmiersprachen.

Mehrfache Zuweisung

CLU unterstützt des Weiteren die mehrfache Zuweisung, mit welcher mehr als eine Variable auf der linken Seite des Zuweisungsoperators stehen kann. Z. B. würde x,y = y,x Werte zwischen den Variablen x und y austauschen. In derselben Art und Weise können Funktionen mehrere Werte wie z. B. x,y,z = f(t) zurückliefern.

Einfluss auf andere Programmiersprachen

• Python und Ruby übernahmen verschiedene Konzepte von CLU wie z. B. die yield Anweisung und die mehrfache Zuweisung.
• CLU und Ada waren die maßgeblichen Vorbilder für Vorlagen in C++.
• Die Mechanismen der Ausnahmebehandlung von CLU beeinflusste modernere Programmiersprachen wie C++ und Java.
• Alle Objekte von CLU existieren im Heap und die Speicherverwaltung läuft automatisch ab. Dies beeinflusste Java in direkter Form.
• Python und C# bieten das Konzept der Generatoren an, welche zuerst als Iteratoren in CLU auftauchten.
• Lua übernahm die Mehrfachzuweisung sowie das mehrfache Zurückgeben von Funktionswerten von CLU.

Literatur

• Barbara Liskov: A History of CLU, 1992 (engl., Postscript-Format, ca. 150 kB)

Weblinks

• clu2c ein Programm um CLU-Kode in C zu übersetzen. (engl.)
• CLU Vergleich mit "99 bottles of beer" Demo. Demo-Algorithmusseite zu verschiedenen Programmiersprachen
• CLU-Website der Programming Methodology Group am MIT (engl.)
• Dictionary of Programming Languages CLU im Wörterbuch der Programmiersprachen (engl.)