Erlang – Einführung
Erlang ist eine mehrzweck (general-purpose) Programmierspache, welche vor allem das Paradigma der Nebenläufigkeit (Concurrency) implementiert. Ferner ist sie stark von der funktionalen Programmierung beeinflusst worden, wobei man hier aber nicht sagen kann, dass es sich bei Erlang um eine rein funktionale Sprache handelt. Um sich von allgegenwärtigen OO-Sprachen abzugrenzen, wird der Begriff der “Concurrency Oriented Programming Language” gebraucht, um den Fokus auf die Entwicklung von nebenläufigen, oft auf mehrere Prozessoren oder gar Netzwerke verteilten Applikationen zu betonen. Was Objekte für OO-Sprachen wie C++, Java oder C# sind, sind Prozesse für Erlang. Jedoch sind Prozesse in der Erlang-Welt nicht mit OO-Prozessen bzw. “Threads” zu vergleichen. So gibt es in Erlang kein Shared Memory und Locks sind auch nicht vorhanden. In Erlang läuft so ziemlich alles anders ab. So sind auch Variablen auch nicht so sehr “variabel”, wie man es von anderen Sprachen gewohnt ist. Auch was den allgemeinen Aufbau der Sprache angeht, so schaut man beim ersten Male fast wirklich “in die Röhre”, wenn man so eine erl-Datei in den Editor geladen hat.
Um den Schrecken aber nicht allzu sehr zu steigern (denn schließlich sollen ja paar Leute dieses Tutorial lesen), kümmern wir uns erst einmal um die Einrichtung der Erlang-Umgebung. Vergleichbar mit der JVM für Java oder .NET für C#, muss auch für Erlang bestimmte Vorarbeit geleistet werden, um an die Sprache (und den ganzen Rest) ranzukommen. Denn Erlang ist nicht nur eine Sprache, sondern auch eine Laufzeitumgebung (so ähnlich wie JVM oder .NET) wie auch eine Bibliothek. Da diese Dreigliedrigkeit aber eine recht hohe Komplexität in sich birgt, werden wir uns Schritt für Schritt der Programmiersprache Erlang nähern und mittels Erlang-Shell die Laufzeitumgebung Erlang kennenlernen, wie auch die Erlang-Bibliothek.
Die erste Anlaufstelle für Erlang/OTP is www.erlang.org (ja, eigentlich heißt es nicht bloß “Erlang”, sondern immer Erlang/OTP…Erklärung kommt später noch). Dort geht man auf Downloads und lädt sich die entsprechenden Binaries (es gibt sie für verschiedene Systeme, in diesem Tutorial wird Win32-Version eingesetzt). Die Installation wird per Installer durchgeführt und bereitet keinerlei Schwierigkeiten. Wer auf Linux-Version setzt, kann z.B. unter Debian (oder auch Ubuntu) mit einem einfachen apt-get install erlang die ganzen Binaries holen. Wer zuerst das ganze System lokal kompiliert haben möchte, muss mehrere Schritte gehen:
$ tar -xzf otp_src_R12B-4.tar.gz
$ cd otp_src_R12B-4
$ ./configure
$ make
$ sudo make install
Bei der Installation unter Windows wird man folgendes Fenster zu sehen bekommen:
Erlang-Installer erkennt automatisch, ob bestimmte DLLs bereits unter Windows vorhanden sind.
Danach geht es weiter zum Einrichten des Install-Verzeichnisses.
Noch den Menüeintrag setzen und mit der Installation kann begonnen werde.
Die wichtigste Schnittstelle zu Erlang ist sicherlich die Erlang-Shell, welche von der Kommandozeile aus per erl.exe aufgerfuen wird. Es existiert auch eine eigenständige Shell-Applikation, die über Windows-Menüs aufgerufen werden kann (werl.exe). Um ein ordentliches Arbeiten innerhalb der DOS-Konsole zu gewährleisten, sollte die PATH-Variable unter Windows um den Pfad zum Erlang-BIN-Verzeichnis gesetzt werden (z.B. C:/Programme/erl5.6.4/bin).
Wie man unschwer erkennen kann, ist meine Shell etwas “gesprächiger” als erwartet, da hier einige Verzeichnisse zusätzlich ausgegeben wurden. Dies liegt an der Anpassung einer speziellen .erlang Datei aus dem usr-Verzeichnis der Erlang-Installation. Diese Datei benutze ich vor allem, um eigene Quellcode-Verzeichnisse der Erlang-Shell bekannt zu machen. So muss ich dann bei der Kompilierung von der Shell aus keine langen Pfadangaben machen. Zusätzlich habe ich der .erlang-Datei die Pfadangabe einiger Emacs-Module angehängt (diese werden aber jetzt (noch) übersprungen). Erlang ist schon ungewöhnlich genug. Wenn ich jetzt noch mit Emacs anfangen würde, dann würde das Tutorial wirklich niemand mehr lesen wollen 
Eine mögliche .erlang-Datei könnte bspw. so ausschauen:
io:format(“Lese .erlang aus ~p~n~n”,
[element(2, file:get_cwd())]).
% Erlang Code Path
io:format(“Wechsle ins “).
c:cd(“K:/desk/eigene/Codes/erlang”).
io:format(“\nQuellcodes sind in ~p~n~n”, [element(2, file:get_cwd())]).
Hier wird eine Ausgabe getätigt (io:format) inklusive der Information zum Verzeichnis, in welchem sich .erlang befindet (file:get_cwd()). Danach wechselt die Shell mit c:cd() ins Quellcode-Verzeichnis und gibt wieder eine Information per io:format aus. Wie man merkt, sind einige der Sachen schon “bekannt” und erinnern sehr stark an bekannte DOS oder POSIX-Kommandos. Dennoch werden wir nicht von diesen Befehlen aus die Sprache Erlang anfassen und widmen uns lieber der Shell und ihren Besonderheiten. Denn, wer Erlang programmieren will, der macht es zuerst über die Shell. Es bringt bei Erlang wirklich nicht viel, wenn man sich auf irgendwelche Codes stürzt, diese schnell “mal eben” in irgendeinen Editor eingibt und dann versucht zu kompilieren. Erstens, es würde nicht einfach so gehen, denn selbst der Erlang-Compiler will von der Shell aus bedient werden (zumindest für den Anfang) und zweitens ist Erlang an einigen Stellen derart besonders, dass diese abgetippten Programme eh nicht verstanden werden könnten, selbst wenn sie zum Laufen gebracht worden wären. Also, ab zur Shell, ein paar Befehle eingeben:
So, in der ersten Zeile haben wir 10 + 100, dann eine weitere Zeile mit einem Punkt und dann dahinter das Ergebnis 110. Was hat das zu bedeuten? Ganz einfach zwei Dinge: in Erlang kann man direkt rechnen, ohne viele Umwege (also nix da mit int x = 10; int y = 100; int ergebnis = x + y;). Und was die Befehlsfolge angeht, so muss jede Anweisung mit einem Punkt enden, damit sie auch richtig interpretiert werden kann. Daher tat die Maschine nichts, als wir 100 eingegeben haben, denn es gab (noch) keinen Abschlusspunkt! Beim zweiten Versuch mit gleichen Operanden sehen wir, dass es sofort zum Ergebnis kommt. Das ist aber noch nicht die Welt und an sich auch keine Überraschung, denn auch andere Sprachen können “sowas”
Übrigens, vorangegangene Befehle können in der Erlang-Shell einfach mit den Pfeiltasten wieder hervorgeholt werden. Oder aber mit Emacs-Befehlen (CTRL+P, CTRL+N). Im Allgemeinen ist das Editorsystem Emacs sehr empfehlenswert, wenn man mit Erlang zu tun hat. So existieren einige sehr gute Module für Erlang (mit Debugging-Möglichkeiten, Shell-Integration etc.). Jedoch kann z.Zt. auf Emacs verzichtet werden, da wir noch lernen, mit Erlang zu gehen. Fliegen werden wir (hoffentlich) später. Jetzt geben wir Folgendes in Erlang ein und tauchen so langsam in die seltsame Welt ein:
Wie wir sehen, muss bei Variablendeklaration kein expliziter Datentyp angegeben werden. Denn Erlang ist eine dynamisch getypte Sprache und somit entfällt das Vorgeben der zu erwarteten Datentypen. Jedoch ist dies nicht die ganze Wahrheit, denn passt jetzt auf, was passiert, wenn man versucht, der angeblichen “Variablen” VariableX einen neuen Wert zuzuweisen.
Da meldet sich die Shell mit der Info, dass Werte nicht übereinstimmen! Aber, wir wollten doch nicht vergleichen, sondern zuweisen. Was ist denn hier passiert? Eigentlich ist die Erklärung ganz einfach zu verstehen, es sei den, man hat ein Leben lang nur mit “gewöhnlichen” Sprachen zu tun gehabt. Also, das Gleichheitszeichen ist kein Zuweisungsoperator, nicht einmal beim ersten Male, als VariableX = 10. stand. Nein, es gibt keine eigentlichen Zuweisungen in Erlang, denn auch die VariableX ist keine Variable, da man ihren Wert nicht wie bei vielen anderen Sprachen beliebig ändern kann. Vielmehr ist Erlang beim Interpretieren von Anweisungen an “Pattern Matching” angelehnt. D.h., dass beim ersten Male die Shell eben den Wert auf der rechten Seite (10) dem Pattern VariableX gleichgesetzt hat (oder in der Erlang-Terminologie “variable was bound“). In Erlang gibt es also nur gebundene und ungebundene Variablen. Alles andere entfällt. Deshalb gab es auch beim zweiten Versuch eine Fehlermeldung, weil eine gebundene Variable vor einen neuen Wert gesetzt wurde und gemäß Pattern Matching dieser Ausdruck als unwahr zu gelten hatte. Und das ist wiederum der Grund für die auf den ersten Blick seltsame Fehlermeldung, die besagt, dass der rechtsseitige Wert keine Entsprechung auf der linken Seite hatte. Dies ist sicherlich eine der wichtigsten (und wohl auch ungewöhnlichsten) Eigenschaften von Erlang. Variablen sind nämlich viel mehr den mathematischen Variablen ähnlich (so wie wir es eben in der Schule gelernt haben) und Operatoren wie das Gleichheitszeichen sind wirklich zum Vergleichen da und nicht für die gewohnte Wertezuweisung. Also, verkürzt: es gibt nur ungebundene und gebundene Variablen und alles wird per Pattern-Matching (Musterüberprüfung) erledigt. Und da Mathematik in ihrer abstraktesten Definition nichts anderes als die “Wissenschaft von Mustern” sei, ist es wohl mehr als logisch, dass mathematisch-orientierte Erlang-Variablen eben nach “Musterüberprüfung” verarbeitet werden und nicht durch stumpfe Wertezuweisung. In der Tat ist jede Erlang-Variable nichts anderes als ein gewöhnliches Pattern (“Muster”) und dementsprechend geht der Erlang-Interpreter so vor, wenn er zum ersten Mal auf einen Ausdruck wie z.B. VariableX = 10. stößt:
MUSTER “VariableX” erkannt, jedoch ist “VariableX” noch UNGEBUNDEN.
Setze MUSTER “VariableX” in VERBINDUNG zu 10, weil ein GLEICHHEITSZEICHEN zwischen diesen beiden steht.
Kommt es später zu einem neuen Pattern wie VariableX = 200., gibt es sofort eine Fehlermeldung, da eben das zuvor erkannte Muster nicht mehr auf diesem neuen abgebildet werden kann. Würdet ihr jetzt aber noch einmal VariableX = 10. eingeben, so gäbe es keine Fehlermeldung, sondern bloß die Ausgabe 10. D.h. das erste Muster ist als wahr erkannt worden.
So, das wär’s dann für’s Erste und ich hoffe, dass ein paar von euch dabei geblieben sind und tatsächlich diese abschließenden Worte lesen. Ganz zu Anfang dieses ersten Tutorials versprach ich zu erklären, was Erlang/OTP bedeutet. Ganz einfach: OTP steht für “The Open Telecommunication Platform” und stammt aus den Laboren der Firma Ericsson, welche auch die Sprache Erlang entwickelt hat. OTP ist eine spezielle Middleware mit dem Fokus auf den Aufbau von verteilten, hochverfügbaren Systemen. Dies bedeutet, dass Erlang zu Anfang für kommerzielle Projekte eingesetzt wurde. Erst später ist die Sprache zum OpenSource erklärt worden. Somit ist Erlang eine der wenigen Sprachen, die in einer kontrollierten Umgebung entwickelt, später dann bei einem internationalen Konzern auf “Herz und Nieren” geprüft (vor allem was Skalierbarkeit, Geschwindigkeit und Concurrency angeht) und erst danach in die OpenSource-Hände übergeben wurde.
Der Name “Erlang” selbst ist zu Ehren des Wissenschaftlers Agner Krarup Erlang als Bezeichner für die Sprache gewählt worden (auch wenn die Ähnlichkeit zu “Ericsson Language” nicht von der Hand zu weisen ist).
Weiterführende Informationen:
