Erlang (Programmiersprache)

Erlang ( / ˈ ɜːr l æ ŋ / UR -lang ) ist eine universelle , nebenläufige , funktionale Hochsprache mit einem Laufzeitsystem mit automatischer Speicherbereinigung . Der Begriff Erlang wird synonym mit Erlang/OTP oder Open Telecom Platform (OTP) verwendet. OTP besteht aus dem Erlang- Laufzeitsystem , mehreren sofort einsatzbereiten Komponenten (OTP), die hauptsächlich in Erlang geschrieben sind, und einer Reihe von Entwurfsprinzipien für Erlang-Programme. ^{[ 5 ]}

Das Erlang -Laufzeitsystem ist für Systeme mit folgenden Eigenschaften konzipiert:

• Verteilt
• Fehlertolerant
• Weiche Echtzeit
• Hochverfügbare , unterbrechungsfreie Anwendungen
• Hot-Swapping ermöglicht die Änderung von Code, ohne das System anzuhalten. ^{[ 6 ]}

Die Programmiersprache Erlang verfügt über Datenverarbeitung, Mustererkennung und funktionale Programmierung . ^{[ 7 ]} Die sequentielle Teilmenge der Erlang-Sprache unterstützt sofortige Auswertung , einfache Zuweisung und dynamische Typisierung .

Eine typische Erlang-Anwendung besteht aus Hunderten von kleinen Erlang-Prozessen.

Es handelte sich ursprünglich um eine proprietäre Software von Ericsson , die 1986 von Joe Armstrong , Robert Virding und Mike Williams entwickelt wurde ^{[ 8 ]} , aber 1998 als freie und Open-Source-Software veröffentlicht wurde. ^{[ 9 ] [ 10 ]} Erlang/OTP wird von der Produkteinheit Open Telecom Platform (OTP) bei Ericsson unterstützt und gepflegt .

Der Name Erlang , der Bjarne Däcker zugeschrieben wird, wurde von den Entwicklern der Telefonvermittlungsanlagen (für die die Sprache konzipiert wurde) als Anspielung auf den dänischen Mathematiker und Ingenieur Agner Krarup Erlang und als Silbenabkürzung von „Ericsson Language“ interpretiert. ^{[ 8 ] [ 11 ] [ 12 ]} Erlang wurde mit dem Ziel entwickelt, die Entwicklung von Telefonieanwendungen zu verbessern. ^{[ 13 ]} Die erste Version von Erlang wurde in Prolog implementiert und war von der Programmiersprache PLEX beeinflusst , die in früheren Ericsson-Vermittlungsanlagen verwendet wurde. Bis 1988 hatte sich Erlang als geeignet für die Entwicklung von Prototypen für Telefonvermittlungsanlagen erwiesen, doch der Prolog-Interpreter war viel zu langsam. Eine Gruppe innerhalb von Ericsson schätzte, dass er 40-mal schneller sein müsste, um für den Produktiveinsatz geeignet zu sein. 1992 begannen die Arbeiten an der BEAM Virtual Machine (VM), die Erlang mithilfe einer Mischung aus nativ kompiliertem und parallelisiertem Code in C kompiliert , um ein optimales Verhältnis zwischen Leistung und Speicherplatzbedarf zu erzielen. ^{[ 14 ]} Laut Mitentwickler Joe Armstrong gelangte die Sprache nach dem Scheitern der nächsten Generation von AXE-Telefonanlagen , AXE-N, im Jahr 1995 vom Laborprodukt in reale Anwendungen. Infolgedessen wurde Erlang für die nächste ATM-Telefonanlage ( Asynchronous Transfer Mode ), AXD, ausgewählt . ^{[ 8 ]}

Im Februar 1998 verbot Ericsson Radio Systems die interne Verwendung von Erlang für neue Produkte und begründete dies mit der Präferenz für offene Programmiersprachen. ^{[ 15 ]} Dieses Verbot veranlasste Armstrong und andere, ihre Kündigung zu planen. ^{[ 16 ]} Im März 1998 kündigte Ericsson die Vermittlungsstelle AXD301 an, ^{[ 8 ]} die über eine Million Zeilen Erlang-Code enthielt und eine hohe Verfügbarkeit von neun Neunen erreichen sollte . ^{[ 17 ]} Im Dezember 1998 wurde die Erlang-Implementierung als Open Source veröffentlicht, und der Großteil des Erlang-Teams verließ das Unternehmen, um die Firma Bluetail AB zu gründen. ^{[ 8 ]} Ericsson lockerte das Verbot schließlich und stellte Armstrong 2004 wieder ein. ^{[ 16 ]}

Im Jahr 2006 wurde die native Unterstützung für symmetrisches Multiprocessing in das Laufzeitsystem und die VM integriert. ^{[ 8 ]}

Erlang-Anwendungen bestehen aus sehr schlanken Erlang-Prozessen im Erlang-Laufzeitsystem. Das Erlang-Laufzeitsystem gewährleistet eine strikte Prozessisolation zwischen den Erlang-Prozessen (einschließlich Daten- und Speicherbereinigung, die von jedem Erlang-Prozess separat durchgeführt werden) und eine transparente Kommunikation zwischen Prozessen (siehe Standorttransparenz ) auf verschiedenen Erlang-Knoten (auf verschiedenen Hosts).

Joe Armstrong, Miterfinder der Erlang-Sequenz, fasste die Prinzipien der Prozesse in seiner Doktorarbeit zusammen: ^{[ 18 ]}

• Alles ist ein Prozess.
• Die Prozesse sind stark voneinander isoliert.
• Die Erstellung und Zerstörung von Prozessen ist ein ressourcenschonender Vorgang.
• Die Nachrichtenübermittlung ist die einzige Möglichkeit für Prozesse, miteinander zu interagieren.
• Prozesse haben eindeutige Namen.
• Wenn Sie den Namen eines Prozesses kennen, können Sie ihm eine Nachricht senden.
• Die Prozesse teilen keine Ressourcen.
• Die Fehlerbehandlung ist nicht lokal.
• Prozesse erfüllen ihren Zweck oder schlagen fehl.

Joe Armstrong bemerkte 2013 in einem Interview mit Rackspace: „Wenn Java ‚ einmal schreiben, überall ausführen ‘ ist , dann ist Erlang ‚einmal schreiben, für immer ausführen‘.“ ^{[ 19 ]}

Im Jahr 2014 berichtete Ericsson , dass Erlang in seinen Support-Knoten, in GPRS- , 3G- und LTE -Mobilfunknetzen weltweit sowie von Nortel und der Deutschen Telekom eingesetzt werde . ^{[ 20 ]}

Erlang wird in RabbitMQ verwendet . Wie Tim Bray , Leiter der Webtechnologien bei Sun Microsystems , in seiner Keynote auf der O'Reilly Open Source Convention (OSCON) im Juli 2008 erklärte:

Wenn jemand zu mir käme und mir viel Geld zahlen wollte, um ein groß angelegtes Nachrichtenverarbeitungssystem zu entwickeln, das wirklich ständig verfügbar sein muss und sich jahrelange Ausfallzeiten nicht leisten kann, würde ich ohne zu zögern Erlang als Programmiersprache wählen.

Erlang ist die Programmiersprache, die zum Codieren von WhatsApp verwendet wurde . ^{[ 21 ]}

Es ist auch die bevorzugte Sprache für Ejabberd – einen XMPP -Messaging-Server.

Elixir ist eine Programmiersprache, die in BEAM-Bytecode (über das Erlang Abstract Format) kompiliert wird. ^{[ 22 ]}

Seit seiner Veröffentlichung als Open Source hat sich Erlang über den Telekommunikationssektor hinaus verbreitet und sich in anderen Branchen wie FinTech, Gaming, Gesundheitswesen, Automobilindustrie, Internet der Dinge und Blockchain etabliert. Neben WhatsApp zählen auch Vocalink (ein MasterCard-Unternehmen), Goldman Sachs , Nintendo , AdRoll, Grindr , BT Mobile , Samsung , OpenX und SITA zu den Erfolgsgeschichten von Erlang . ^{[ 23 ] [ 24 ]}

Ein in Erlang implementierter Fakultätsalgorithmus :

- module ( fact ). % Dies ist die Datei 'fact.erl', Modul und Dateiname müssen übereinstimmen. - export ([ fac / 1 ]). % Dies exportiert die Funktion 'fac' mit Stelligkeit 1 (1 Parameter, kein Typ, kein Name).fac ( 0 ) -> 1 ; % Wenn 0, dann 1 zurückgeben, andernfalls (beachte das Semikolon ; bedeutet 'else'). fac ( N ) when N > 0 , is_integer ( N ) -> N * fac ( N - 1 ). % Rekursiv bestimmen und Ergebnis zurückgeben % (beachte den Punkt . bedeutet 'endif' oder 'Funktionsende'). %% Diese Funktion stürzt ab, wenn etwas anderes als eine nichtnegative ganze Zahl übergeben wird. %% Sie veranschaulicht die „Lass es abstürzen“-Philosophie von Erlang.

Ein endrekursiver Algorithmus, der die Fibonacci-Folge erzeugt :

%% Die Moduldeklaration muss mit dem Dateinamen "series.erl" übereinstimmen - Modul ( Serie ).%% Die Export-Anweisung enthält eine Liste aller Funktionen, die die öffentliche API des Moduls bilden. %% In diesem Fall stellt das Modul eine einzelne Funktion namens fib bereit, die ein Argument akzeptiert (d. h. eine Stelligkeit von 1 hat) . %% Die allgemeine Syntax für -export ist eine Liste, die den Namen und die Stelligkeit jeder öffentlichen Funktion enthält - export ([ fib / 1 ]).%% --------------------------------------------------------------------- %% Öffentliche API %% ---------------------------------------------------------------------%% Fälle behandeln, in denen fib/1 bestimmte Werte annimmt %% Die Reihenfolge, in der diese Funktionssignaturen deklariert werden, ist ein wesentlicher %% Bestandteil der Funktionalität dieses Moduls%% Wenn fib/1 eine negative Zahl erhält, wird das Atom err_neg_val zurückgegeben. %% Normalerweise wird solch defensiver Code aufgrund der Erlang -Philosophie „Lass es abstürzen“ nicht empfohlen, aber hier würde dies zu einer Endlosschleife führen. fib ( N ) when N < 0 -> err_neg_val ;%% Wenn fib/1 genau die ganze Zahl 0 übergeben wird, dann gib 0 zurück fib ( 0 ) -> 0 ;%% Für alle anderen Werte rufen Sie die private Funktion fib_int/3 auf, um %% die Berechnung fib ( N ) -> fib_int ( N - 1 , 0 , 1 ) durchzuführen .%% --------------------------------------------------------------------- %% Private API %% ---------------------------------------------------------------------%% Wenn fib_int/3 als erstes Argument 0 erhält, ist die Operation abgeschlossen, %% also wird der Wert im Argument B zurückgegeben. Das zweite Argument wird mit _ gekennzeichnet, um %% seinen Wert zu ignorieren. fib_int ( 0 , _, B ) -> B ;%% Für alle anderen Argumentkombinationen wird fib_int/3 rekursiv aufgerufen, wobei jeder Aufruf Folgendes bewirkt: %% - Zähler N dekrementieren %% - das dritte Argument als neues zweites Argument übergeben %% - die Summe des zweiten und dritten Arguments als neues %% drittes Argument übergeben fib_int ( N , A , B ) -> fib_int ( N - 1 , B , A + B ).

Lässt man die Kommentare weg, ergibt sich ein deutlich kürzeres Programm.

- Modul ( Serie ). - Export ([ fib / 1 ]).fib ( N ) when N < 0 -> err_neg_val ; fib ( 0 ) -> 0 ; fib ( N ) -> fib_int ( N - 1 , 0 , 1 ).fib_int ( 0 , _, B ) -> B ; fib_int ( N , A , B ) -> fib_int ( N - 1 , B , A + B ).

Quicksort in Erlang, unter Verwendung von List Comprehension : ^{[ 25 ]}

%% qsort:qsort(List) %% Sortiert eine Liste von Elementen - Modul ( qsort ). % Dies ist die Datei 'qsort.erl' - export ([ qsort / 1 ]). % Eine Funktion 'qsort' mit 1 Parameter wird exportiert (kein Typ, kein Name)qsort ([]) -> []; % Wenn die Liste [] leer ist, wird eine leere Liste zurückgegeben (nichts zu sortieren) qsort ([ Pivot | Rest ]) -> % Erstellt rekursiv eine Liste mit 'Front' für alle Elemente, die vor 'Pivot' stehen sollen, % dann 'Pivot' und dann 'Back' für alle Elemente, die nach 'Pivot' stehen sollen qsort ([ Front || Front <- Rest , Front < Pivot ]) ++ [ Pivot ] ++ qsort ([ Back || Back <- Rest , Back >= Pivot ]).

Das obige Beispiel ruft die Funktion rekursiv auf, qsortbis keine Elemente mehr zu sortieren sind. Der Ausdruck [Front || Front <- Rest, Front < Pivot]ist eine List Comprehension , d. h. „Erstelle eine Liste von Elementen, Frontsodass Frontjedes Element ein Element von ist Restund Frontkleiner als ist Pivot.“ ++ist der Verkettungsoperator für Listen.

Für komplexere Strukturen kann zur besseren Lesbarkeit eine Vergleichsfunktion verwendet werden.

Der folgende Code sortiert Listen nach Länge:

% Dies ist die Datei 'listsort.erl' (der Compiler ist so erstellt) - Modul ( listsort ). % Exportiere 'by_length' mit 1 Parameter (Typ und Name sind irrelevant) - export ([ by_length / 1 ]).by_length ( Lists ) -> % Use 'qsort/2' and provides an anonymous function as a parameter qsort ( Lists , fun ( A , B ) -> length ( A ) < length ( B ) end ).qsort ([], _) -> []; % Wenn die Liste leer ist, wird eine leere Liste zurückgegeben (der zweite Parameter wird ignoriert). qsort ([ Pivot | Rest ], Smaller ) -> % Partitioniert die Liste, wobei die 'Smaller'-Elemente vor 'Pivot' und die Nicht-'Smaller'-Elemente % nach 'Pivot' stehen, und sortiert die Teillisten. qsort ([ X || X <- Rest , Smaller ( X , Pivot )], Smaller ) ++ [ Pivot ] ++ qsort ([ Y || Y <- Rest , not ( Smaller ( Y , Pivot ))], Smaller ).

A Pivotwird aus dem ersten Parameter von A entnommen, qsort()und der Rest von A Listswird als bezeichnet Rest. Beachten Sie, dass der Ausdruck

[ X || X <- Rest , Smaller ( X , Pivot )]

ist formal identisch mit

[ Front || Front <- Rest , Front < Pivot ]

(im vorherigen Beispiel) außer der Verwendung einer Vergleichsfunktion im letzten Teil, die besagt: „Erstelle eine Liste von Elementen, Xsodass Xein Element von ist Restund Smallerwahr ist“, wobei Smallerzuvor wie folgt definiert wurde:

fun ( A , B ) -> length ( A ) < length ( B ) end

Die anonyme FunktionSmaller wird in der Parameterliste der zweiten Definition von `f` benannt qsort, sodass sie innerhalb dieser Funktion über diesen Namen aufgerufen werden kann. In der ersten Definition von `f` qsort, die den Basisfall einer leeren Liste behandelt, wird sie nicht benannt und benötigt daher weder diese Funktion noch einen Namen dafür.

Erlang kennt acht primitive Datentypen :

Ganze Zahlen

Ganze Zahlen werden als Folgen von Dezimalziffern geschrieben, zum Beispiel sind 12, 12375 und -23427 ganze Zahlen. Die Arithmetik mit ganzen Zahlen ist exakt und nur durch den verfügbaren Speicher des Rechners begrenzt. (Dies wird als Arithmetik mit beliebiger Genauigkeit bezeichnet .)

Atome

Atome werden in Programmen verwendet, um bestimmte Werte zu kennzeichnen. Sie werden als Zeichenketten aus aufeinanderfolgenden alphanumerischen Zeichen geschrieben, wobei das erste Zeichen ein Kleinbuchstabe ist. Atome können beliebige Zeichen enthalten, sofern sie in einfache Anführungszeichen eingeschlossen sind. Es gibt eine Escape-Konvention, die die Verwendung beliebiger Zeichen innerhalb eines Atoms erlaubt. Atome werden nicht vom automatischen Speicherbereinigungsprozess (Garbage Collection) freigegeben und sollten daher mit Vorsicht verwendet werden, insbesondere bei dynamischer Atomgenerierung.

Schwimmer

Gleitkommazahlen verwenden die IEEE 754 64-Bit-Darstellung .

Referenzen

Referenzen sind global eindeutige Symbole, deren einzige Eigenschaft darin besteht, dass sie auf Gleichheit verglichen werden können. Sie werden durch Auswertung der Erlang-Primitive erzeugt make_ref().

Binärdateien

Eine Binärdatei ist eine Folge von Bytes. Binärdateien bieten eine speichereffiziente Möglichkeit, Binärdaten zu speichern. In Erlang gibt es Primitive zum Verknüpfen und Zerlegen von Binärdateien sowie für die effiziente Ein- und Ausgabe von Binärdateien.

Pids

Pid ist die Abkürzung für Prozessbezeichner  – eine Pid wird von der Erlang-Primitive erstellt. spawn(...)Pids sind Referenzen auf Erlang-Prozesse.

Häfen

Ports dienen der Kommunikation mit der Außenwelt. Sie werden mit der integrierten Funktion erstellt open_port. Nachrichten können an Ports gesendet und von ihnen empfangen werden, diese Nachrichten müssen jedoch dem sogenannten „Portprotokoll“ entsprechen.

Spaß

Funs sind Funktionsabschlüsse . Funs werden durch Ausdrücke der Form erstellt: fun(...) -> ... end.

Und drei zusammengesetzte Datentypen:

Tupel

Tupel sind Container für eine feste Anzahl von Erlang-Datentypen. Die Syntax {D1,D2,...,Dn}kennzeichnet ein Tupel, dessen Argumente D1, D2, ... Dn.primitive oder zusammengesetzte Datentypen sein können. Auf jedes Element eines Tupels kann in konstanter Zeit zugegriffen werden.

Listen

Listen sind Container für eine variable Anzahl von Erlang-Datentypen. Die Syntax ` [Dh|Dt]list` bezeichnet eine Liste, deren erstes Element `n` ist Dhund deren restliche Elemente die Liste `n` bilden Dt. Die Syntax ` []leere Liste` bezeichnet eine leere Liste. Die Syntax ` leere Liste` [D1,D2,..,Dn]ist eine Kurzform für ` leere Liste` [D1|[D2|..|[Dn|[]]]]. Auf das erste Element einer Liste kann in konstanter Zeit zugegriffen werden. Das erste Element einer Liste wird als Kopf der Liste bezeichnet. Der Rest einer Liste, nachdem der Kopf entfernt wurde, wird als Rest der Liste bezeichnet .

Karten

Maps enthalten eine variable Anzahl von Schlüssel-Wert-Beziehungen. Die Syntax lautet #{Key1=>Value1,...,KeyN=>ValueN}:

Es werden zwei Formen von syntaktischem Zucker bereitgestellt:

Saiten

Zeichenketten werden als in doppelte Anführungszeichen gesetzte Listen von Zeichen geschrieben. Dies ist eine syntaktische Vereinfachung für eine Liste der ganzzahligen Unicode -Codepunkte für die Zeichen in der Zeichenkette. So ist beispielsweise die Zeichenkette "cat" eine Kurzform für [99,97,116]. ^{[ 26 ]}

Aufzeichnungen

Records bieten eine komfortable Möglichkeit, jedem Element eines Tupels ein Tag zuzuordnen. Dadurch kann man auf ein Element eines Tupels anhand seines Namens und nicht anhand seiner Position zugreifen. Ein Präprozessor nimmt die Record-Definition und ersetzt sie durch die entsprechende Tupel-Referenz.

Erlang ist mit einem Mechanismus ausgestattet, der es externen Prozessen erleichtert, Abstürze (oder Hardwarefehler) zu überwachen, anstatt wie in vielen anderen Programmiersprachen übliche interne Mechanismen zur Ausnahmebehandlung zu verwenden. Abstürze werden wie andere Meldungen gemeldet, was die einzige Möglichkeit für Prozesse darstellt, miteinander zu kommunizieren ^{[ 27 ]} , und Unterprozesse können kostengünstig gestartet werden (siehe unten ). Die Philosophie des „Lass es abstürzen“ bevorzugt einen vollständigen Neustart eines Prozesses, anstatt zu versuchen, sich von einem schwerwiegenden Fehler zu erholen ^{[ 28 ]} . Obwohl auch hier eine Fehlerbehandlung erforderlich ist, führt diese Philosophie zu weniger Code für defensive Programmierung, da Fehlerbehandlungscode stark kontextabhängig und spezifisch ist ^{[ 27 ] .}

Eine typische Erlang-Anwendung ist als Supervisor-Baumstruktur aufgebaut. Diese Architektur basiert auf einer Prozesshierarchie, deren oberster Prozess als „Supervisor“ bezeichnet wird. Der Supervisor erzeugt wiederum mehrere Kindprozesse, die entweder als Worker oder als weitere, untergeordnete Supervisoren fungieren. Solche Hierarchien können beliebig tief sein und bieten nachweislich eine hochskalierbare und fehlertolerante Umgebung, in der Anwendungsfunktionen implementiert werden können.

Innerhalb eines Supervisor-Baums sind alle Supervisor-Prozesse für die Verwaltung des Lebenszyklus ihrer Kindprozesse verantwortlich, einschließlich der Behandlung von Abstürzen dieser Kindprozesse. Jeder Prozess kann zum Supervisor werden, indem er zunächst einen Kindprozess erzeugt und erlang:monitor/2diesen anschließend aufruft. Stürzt der überwachte Prozess ab, erhält der Supervisor eine Nachricht mit einem Tupel, dessen erstes Element das Atom ist 'DOWN'. Der Supervisor ist dafür verantwortlich, solche Nachrichten zu empfangen und die erforderlichen Maßnahmen zur Behebung des Fehlers zu ergreifen.

Die größte Stärke von Erlang liegt in der Unterstützung von Parallelverarbeitung . Es verfügt über einen kleinen, aber leistungsstarken Satz an Primitiven zur Prozesserzeugung und -kommunikation. Erlang ist konzeptionell ähnlich wie die Sprache Occam , überträgt jedoch die Ideen der kommunizierenden sequenziellen Prozesse (CSP) in ein funktionales Framework und verwendet asynchrone Nachrichtenübermittlung. ^{[ 29 ]} Prozesse sind das primäre Mittel zur Strukturierung einer Erlang-Anwendung. Sie sind weder Betriebssystemprozesse noch Threads , sondern schlanke Prozesse , die von BEAM eingeplant werden. Wie Betriebssystemprozesse (aber im Gegensatz zu Betriebssystemthreads) teilen sie keinen Zustand untereinander. Der geschätzte minimale Overhead pro Prozess beträgt 300 Wörter . ^{[ 30 ]} Daher können viele Prozesse ohne Leistungseinbußen erzeugt werden. Im Jahr 2005 wurde ein Benchmark mit 20 Millionen Prozessen erfolgreich mit 64-Bit-Erlang auf einem Rechner mit 16 GB Arbeitsspeicher (RAM; insgesamt 800 Bytes pro Prozess) durchgeführt. ^{[ 31 ]} Erlang unterstützt symmetrisches Multiprocessing seit der Version R11B vom Mai 2006.

Während Threads in den meisten Sprachen externe Bibliotheken benötigen, bietet Erlang sprachspezifische Funktionen zur Erstellung und Verwaltung von Prozessen mit dem Ziel, die nebenläufige Programmierung zu vereinfachen. Obwohl die gesamte Nebenläufigkeit in Erlang explizit ist, kommunizieren Prozesse mittels Nachrichtenaustausch anstelle von gemeinsam genutzten Variablen, wodurch explizite Sperren überflüssig werden (intern wird jedoch weiterhin ein Sperrmechanismus von der virtuellen Maschine verwendet). ^{[ 32 ]}

Die Interprozesskommunikation erfolgt über ein asynchrones Nachrichtenübermittlungssystem ohne gemeinsame Ressourcen : Jeder Prozess verfügt über ein „Postfach“, eine Warteschlange mit Nachrichten, die von anderen Prozessen gesendet, aber noch nicht verarbeitet wurden. Ein Prozess verwendet die entsprechenden Primitiven, um Nachrichten abzurufen, die bestimmten Mustern entsprechen. Eine Nachrichtenverarbeitungsroutine prüft die Nachrichten nacheinander anhand jedes Musters, bis eine übereinstimmt. Sobald die Nachricht verarbeitet und aus dem Postfach entfernt wurde, setzt der Prozess seine Ausführung fort. Eine Nachricht kann beliebige Erlang-Strukturen enthalten, darunter Primitive (Ganzzahlen, Gleitkommazahlen, Zeichen, Atome), Tupel, Listen und Funktionen. receive

Das folgende Codebeispiel zeigt die integrierte Unterstützung für verteilte Prozesse:

% Erstelle einen Prozess und rufe die Funktion web:start_server(Port, MaxConnections) auf ServerProcess = spawn ( web , start_server , [ Port , MaxConnections ]),% Erstelle einen Remote-Prozess und rufe die Funktion % web:start_server(Port, MaxConnections) auf dem Rechner RemoteNode auf RemoteNode RemoteProcess = spawn ( RemoteNode , web , start_server , [ Port , MaxConnections ]),% Sende eine Nachricht an ServerProcess (asynchron). Die Nachricht besteht aus einem Tupel % mit dem Atom "pause" und der Zahl "10". ServerProcess ! { pause , 10 },% Empfange Nachrichten, die an diesen Prozess gesendet werden receive a_message -> do_something ; { data , DataContent } -> handle ( DataContent ); { hello , Text } -> io : format ( "Hallo-Nachricht erhalten: ~s " , [ Text ]); { goodbye , Text } -> io : format ( "Abschiedsnachricht erhalten: ~s " , [ Text ]) end .

Wie das Beispiel zeigt, können Prozesse auf entfernten Knoten erstellt werden, und die Kommunikation mit ihnen ist insofern transparent, als die Kommunikation mit entfernten Prozessen genau so funktioniert wie die Kommunikation mit lokalen Prozessen.

Parallelverarbeitung ist die primäre Methode der Fehlerbehandlung in Erlang. Stürzt ein Prozess ab, beendet er sich ordnungsgemäß und sendet eine Nachricht an den steuernden Prozess, der daraufhin Maßnahmen ergreifen kann, beispielsweise einen neuen Prozess starten, der die Aufgabe des alten Prozesses übernimmt. ^{[ 33 ] [ 34 ]}

Die offizielle Referenzimplementierung von Erlang verwendet BEAM . ^{[ 35 ]} BEAM ist in der offiziellen Erlang-Distribution Erlang/OTP enthalten. BEAM führt Bytecode aus, der zur Ladezeit in Thread-Code umgewandelt wird . Auf den meisten Plattformen ist außerdem ein Compiler für nativen Code enthalten, der vom High Performance Erlang Project (HiPE) der Universität Uppsala entwickelt wurde . Seit Oktober 2001 ist das HiPE-System vollständig in Ericssons Open-Source-System Erlang/OTP integriert. ^{[ 36 ]} Ab der Erlang-Version R11B-5 unterstützt BEAM auch die direkte Interpretation von Quellcode über einen abstrakten Syntaxbaum sowie Skripte.

Erlang unterstützt dynamische Softwareaktualisierung auf Sprachebene . Dazu wird Code als „Modul“-Einheit geladen und verwaltet; ein Modul ist eine Kompilierungseinheit . Das System kann zwei Versionen eines Moduls gleichzeitig im Speicher halten, und Prozesse können parallel Code aus beiden Versionen ausführen. Diese Versionen werden als „neue“ und „alte“ Version bezeichnet. Ein Prozess wechselt erst dann zur neuen Version, wenn er einen externen Aufruf an sein Modul tätigt.

Ein Beispiel für den Mechanismus des Hot-Code-Loadings:

%% Ein Prozess, dessen einzige Aufgabe darin besteht, einen Zähler zu führen. %% Erste Version - Modul ( Zähler ). - Export ([ Start / 0 , Codeschalter / 1 ]).start () -> loop ( 0 ).loop ( Sum ) -> receive { increment , Count } -> loop ( Sum + Count ); { counter , Pid } -> Pid ! { counter , Sum }, loop ( Sum ); code_switch -> ? MODULE : codeswitch ( Sum ) % Erzwingt die Verwendung von 'codeswitch/1' aus der neuesten MODULE-Version end .codeswitch(Sum)->loop(Sum).

For the second version, we add the possibility to reset the count to zero.

%% Second version-module(counter).-export([start/0,codeswitch/1]).start()->loop(0).loop(Sum)->receive{increment,Count}->loop(Sum+Count);reset->loop(0);{counter,Pid}->Pid!{counter,Sum},loop(Sum);code_switch->?MODULE:codeswitch(Sum)end.codeswitch(Sum)->loop(Sum).

Only when receiving a message consisting of the atom code_switch will the loop execute an external call to codeswitch/1 (?MODULE is a preprocessor macro for the current module). If there is a new version of the counter module in memory, then its codeswitch/1 function will be called. The practice of having a specific entry-point into a new version allows the programmer to transform state to what is needed in the newer version. In the example, the state is kept as an integer.

In practice, systems are built up using design principles from the Open Telecom Platform, which leads to more code upgradable designs. Successful hot code loading is exacting. Code must be written with care to make use of Erlang's facilities.

In 1998, Ericsson released Erlang as free and open-source software to ensure its independence from a single vendor and to increase awareness of the language. Erlang, together with libraries and the real-time distributed database Mnesia, forms the OTP collection of libraries. Ericsson and a few other companies support Erlang commercially.

Seit der Veröffentlichung als Open Source wird Erlang von mehreren Unternehmen weltweit eingesetzt, darunter Nortel und die Deutsche Telekom . ^{[ 37 ]} Obwohl Erlang ursprünglich für eine Marktlücke entwickelt wurde und lange Zeit eine eher unbekannte Sprache blieb, gewinnt sie aufgrund der Nachfrage nach parallelen Diensten zunehmend an Popularität. ^{[ 38 ] [ 39 ]} Erlang findet auch Anwendung beim Betrieb von Servern für Massive Multiplayer Online Role-Playing Games (MMORPGs). ^{[ 40 ]}

• Elixir – eine funktionale, nebenläufige, universelle Programmiersprache, die auf BEAM läuft.
• Luerl – Lua auf der BEAM-Plattform, entworfen und implementiert von einem der Schöpfer von Erlang.
• Lisp Flavored Erlang (LFE) – eine auf Lisp basierende Programmiersprache, die auf BEAM läuft.
• Mix (Baukasten)
• Phoenix (Webframework)
• Gleam (Programmiersprache) – eine universelle, nebenläufige, funktionale Hochsprache, die zu Erlang kompiliert wird.

• "Erlang: The Movie"
• Official website