Erlang (Programmiersprache)

Erlang
Erlang logo.svg
Paradigmen Multi-Paradigma: gleichzeitig, funktional
Entworfen von
Entwickler Ericsson
Erstmals erschienen 1986; Vor 36 Jahren
Stabile Version
24.1.6[1] Edit this on Wikidata / 18. November 2021; vor 8 Monaten
Disziplin tippen Dynamisch, stark
Lizenz Apache -Lizenz 2.0
Dateiname -Erweiterungen .erl, .hrl
Webseite www.erlang.org
Haupt Implementierungen
Erlang
Beeinflusst von
Lispeln, Plex,[2] Prolog, Smalltalk
Beeinflusst
Akka, Clojure,[3] Pfeil, Elixier, F#, Opa, Oz, Reia, Rost, Scala, gehen
  • Erlang -Programmierung bei Wikibooks

Erlang (/ˈɜːrlæŋ/ Ur-ang) ist ein allgemeiner Zweck, gleichzeitig, funktional Programmiersprache, und ein garbage gesammelt Laufzeitsystem. Der Begriff Erlang wird austauschbar mit Erlang/OTP verwendet, oder Offene Telekommunikationsplattform (OTP), das aus dem Erlang besteht Laufzeitsystem, mehrere nutzende Komponenten (OTP) Design-Prinzipien Für Erlang -Programme.[4]

Der Erlang Laufzeitsystem ist für Systeme mit diesen Eigenschaften ausgelegt:

Der Erlang Programmiersprache hat unveränderlich Daten, Musteranpassung, und Funktionelle Programmierung.[6] Die sequentielle Teilmenge der Erlang -Sprache unterstützt eifrige Bewertung, einzelne Zuordnung, und Dynamisches Typing.

Eine normale Erlang -Anwendung wird aus Hunderten kleiner Erlang -Prozesse gebaut.

Es war ursprünglich proprietäre Software innerhalb Ericsson, entwickelt von Joe Armstrong, Robert Virding und Mike Williams im Jahr 1986,[7] wurde aber freigelassen als Kostenlose und Open-Source-Software In 1998.[8][9] Erlang/OTP wird von der Open Telecom Platform (OTP) -Produkteinheit unter unterstützt und verwaltet Ericsson.

Geschichte

Der Name Erlang, der Bjarne Däcker zugeschrieben wird, wurde von denen vermutet Agner Krarup Erlang und ein Silbenabkürzung von "Ericsson Sprache".[7][10][11] Erlang wurde mit dem Ziel entwickelt, die Entwicklung von Telefonieanwendungen zu verbessern.[12] Die erste Version von Erlang wurde in implementiert Prolog und wurde von der Programmiersprache beeinflusst Plex Wird in früheren Ericsson -Börsen verwendet. Bis 1988 hatte Erlang bewiesen, dass es für den Prototyping -Telefonbörsen geeignet war, aber der Prolog -Dolmetscher war viel zu langsam. Eine Gruppe innerhalb von Ericsson schätzte, dass sie 40 -mal schneller sein müsste, um für den Produktionsgebrauch geeignet zu sein. Im Jahr 1992 begannen die Arbeiten an der STRAHL Virtuelle Maschine (VM), die Erlang mit einer Mischung aus nativ kompilierten Code und COSK -MISME zum Kompilieren des Codes und des kompilierten Thread -Code ein Gleichgewicht zwischen Leistung und Speicherplatz zu erreichen.[13] Laut dem Co-Erfinder Joe Armstrong wurde die Sprache vom Laborprodukt zu echten Anwendungen nach dem Zusammenbruch der nächsten Generation übergeht Axt Telefonaustausch genannt Axe-n 1995 wurde Erlang für den nächsten ausgewählt asynchroner Übertragungsmodus (ATM) Austausch AXD.[7]

Robert Dirding und Joe Armstrong, 2013
Mike Williams

Im Februar 1998 verbot Ericsson Radio Systems die interne Verwendung von Erlang für neue Produkte und zitierte eine Präferenz für nicht proprietäre Sprachen.[14] Das Verbot führte dazu, dass Armstrong und andere Pläne machten, Ericsson zu verlassen.[15] Im März 1998 kündigte Ericsson den AXD301 -Switch an,[7] mit über einer Million Zeilen von Erlang enthält und berichtet, a zu erreichen hohe Verfügbarkeit von neun "9" s.[16] Im Dezember 1998 wurde die Umsetzung von Erlang offen und der größte Teil des Erlang-Teams zurückgetreten, um ein neues Unternehmen Bluetail AB zu bilden.[7] Ericsson entspannte sich schließlich das Verbot und hat Armstrong im Jahr 2004 neu verabreicht.[15]

Im Jahr 2006 eingeborener Symmetrische Multiprozessierung Der Laufzeitsystem und VM wurde Support hinzugefügt.[7]

Prozesse

Erlang -Anwendungen sind aus sehr leichten Erlang -Prozessen im Erlang -Laufzeitsystem gebaut. Erlang -Prozesse können als "lebende" Objekte angesehen werden (Objekt orientierte Programmierung) mit Datenkapselung und Nachrichtenübergang, aber in der Lage, das Verhalten während der Laufzeit zu ändern. Das Erlang -Laufzeitsystem bietet streng Prozessisolation Zwischen Erlang -Prozessen (dies umfasst Daten und Müllsammlung, die von jedem Erlang -Prozess einzeln getrennt sind) und die transparente Kommunikation zwischen den Prozessen auf verschiedenen Erlang -Knoten (auf verschiedenen Hosts).

Joe Armstrong, Co-Erventor von Erlang, fasste die Prinzipien von Prozessen in seinem zusammen PhD These:[17]

  • Alles ist ein Prozess.
  • Prozesse sind stark isoliert.
  • Die Erstellung und Zerstörung der Prozesse ist eine leichte Operation.
  • Das Passieren von Nachrichten ist die einzige Möglichkeit für die Interaktion von Prozessen.
  • Prozesse haben eindeutige Namen.
  • Wenn Sie den Namen eines Prozesses kennen, können Sie ihm eine Nachricht senden.
  • Prozesse teilen keine Ressourcen.
  • Fehlerbehandlung ist nicht lokal.
  • Prozesse tun das, was sie tun oder scheitern sollen.

Joe Armstrong bemerkte 2013 in einem Interview mit Rackspace: "Wenn Java ist 'Schreiben Sie einmal, rennen Sie irgendwohin"Dann ist Erlang" einmal schreiben, für immer rennen ".[18]

Verwendungszweck

Im Jahr 2014, Ericsson berichtete Erlang wurde in seinen Unterstützungsknoten und in verwendet GPRS, 3g und Lte Mobilfunknetze weltweit und auch von Nortel und T-Mobile.[19]

Wie Tim Bray, Direktor von Web Technologies bei Sun Microsystems, ausgedrückt in seiner Keynote bei O'Reilly Open Source Convention (Oscon) Im Juli 2008:

Wenn jemand zu mir kam und mir viel Geld bezahlen wollte, um ein großes Nachrichtenabwicklungssystem aufzubauen, das wirklich die ganze Zeit aufstehen musste, konnte ich es mir nie leisten, jahrelang unterzugehen Bauen Sie es in.

Erlang ist die Programmiersprache, die zum Code verwendet wird WhatsApp.[20]

Seit der Freigabe als Open Source verbreitet sich Erlang über die Telekommunikation hinaus und etabliert sich in anderen vertikalen Märkten wie Fintech, Gaming, Gesundheitswesen, Automobil, Internet der Dinge und Blockchain. Abgesehen von WhatsApp gibt es andere Unternehmen, die als Erlangs Erfolgsgeschichten aufgeführt sind: Vocalink (eine Mastercard -Firma), Goldman Sachs, Nintendo, Adroll, Grindr, BT Mobile, Samsung, OpenX, und Sita.[21][22]

Beispiele für funktionale Programmierungen

Fakultät

A Fakultät Algorithmus in Erlang implementiert:

-Modul(Tatsache). % Dies ist die Datei 'fact.erl', das Modul und der Dateiname müssen übereinstimmen -Export[FAC/1]). % Dies exportiert die Funktion 'FAC' von Arity 1 (1 Parameter, kein Typ, kein Name). FAC(0) -> 1; % Wenn 0, dann zurückkehren 1, sonst (beachten Sie das Semikolon; bedeutet "else") FAC(N) Wenn N > 0, is_integer(N) -> N * FAC(N-1). % Rekursiv bestimmen und dann das Ergebnis zurückgeben % (beachten Sie den Zeitraum. bedeutet "endif" oder "Funktionsende") %% Diese Funktion stürzt ab, wenn etwas anderes als eine nichtnegative Ganzzahl gegeben wird. %% Es zeigt die Philosophie von Erlang "Let It Crash".

Fibonacci-Folge

Ein schwanzrekursiver Algorithmus, der die produziert Fibonacci-Folge:

%% Die Moduldeklaration muss mit der Dateinamen "Series.erl" übereinstimmen  -Modul(Serie). %% Die Exportanweisung enthält eine Liste all dieser Formfunktionen, die Form ausführen %% Die öffentliche API des Moduls. In diesem Fall enthält dieses Modul eine einzelne %% Funktion namens FIB, das 1 Argument nimmt (d. H. Eine Arität von 1) %% Die allgemeine Syntax für -export ist eine Liste, die den Namen und den Namen enthält und %% Arity jeder öffentlichen Funktion -Export[Flunkerei/1]). %% --------------------------------------------------------------------- %% öffentliche API %% --------------------------------------------------------------------- %% Handle Fälle, in denen FIB/1 bestimmte Werte empfängt %% Die Reihenfolge, in der diese Funktionssignaturen deklariert werden, ist von entscheidender Bedeutung %% Teil der Funktionalität dieses Moduls %% Wenn FIB/1 genau die Ganzzahl 0 übergeben wird, kehren Sie dann 0 zurück Flunkerei(0) -> 0; %% Wenn FIB/1 eine negative Zahl empfängt, geben Sie das Atom err_neg_val zurück %% Normalerweise wird eine solche defensive Codierung aufgrund von Erlangs 'let entmutigt %% es Crash 'Philosophie; In diesem Fall sollten wir jedoch explizit %% verhindern eine Situation, die Erlangs Laufzeitmotor zum Absturz bringt Flunkerei(N) Wenn N < 0 -> Err_neg_val; %% Wenn FIB/1 eine Ganzzahl von weniger als 3 übergeben wird, kehren Sie 1 zurück 1 %% Die vorangegangenen zwei Funktionssignaturen verarbeiten alle Fälle, in denen n <1, %% So behandelt diese Funktion Signatur Fälle, in denen n = 1 oder n = 2 Flunkerei(N) Wenn N < 3 -> 1; %% Für alle anderen Werte rufen Sie die private Funktion fib_int/3 auf, um durchzuführen %% die Berechnung Flunkerei(N) -> fib_int(N, 0, 1). %% --------------------------------------------------------------------- %% Private API %% --------------------------------------------------------------------- %% Wenn fib_int/3 als erstes Argument eine 1 erhält, dann sind wir fertig, also %% RECHT den Wert in Argument B zurück, da wir uns nicht an der interessieren %% Wert des zweiten Arguments bezeichnen dies mit _, um a anzuzeigen %% "egal" Wert fib_int(1, _, B) -> B; %% Für alle anderen Argumentkombinationen rufen Sie rekursiv FIB_INT/3 auf %% wobei jeder Anruf Folgendes macht: %% - Decrement -Zähler n %% - Nehmen Sie den vorherigen Fibonacci -Wert in Argument B und bestehen ihn als %% Argument a %% - Berechnen Sie den Wert der aktuellen Fibonacci -Zahl und bestehen Sie ihn %% als Argument B fib_int(N, A, B) -> fib_int(N-1, B, A+B).

Hier ist das gleiche Programm ohne die erklärenden Kommentare:

-Modul(Serie). -Export[Flunkerei/1]). Flunkerei(0) -> 0; Flunkerei(N) Wenn N < 0 -> Err_neg_val; Flunkerei(N) Wenn N < 3 -> 1; Flunkerei(N) -> fib_int(N, 0, 1). fib_int(1, _, B) -> B; fib_int(N, A, B) -> fib_int(N-1, B, A+B).

Schnelle Sorte

Schnelle Sorte in Erlang verwendet Listenverständnis:[23] 

%% QSORT: QSORT (Liste) %% sortieren 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, geben Sie eine leere Liste zurück (nichts zu sortieren) QSORT[Drehzahl|Sich ausruhen])) ->  % Komponieren rekursiv eine Liste mit 'Front' für alle Elemente, die vor 'Pivot' vorliegen sollten.  % dann 'Pivot' dann 'zurück' für alle Elemente, die nach 'Pivot' sein sollten  QSORT[Vorderseite || Vorderseite <- Sich ausruhen, Vorderseite < Drehzahl])) ++   [Drehzahl] ++  QSORT[Der Rücken || Der Rücken <- Sich ausruhen, Der Rücken > = Drehzahl]).

Das obige Beispiel ruft die Funktion rekursiv auf QSORT Bis nichts zu sortiert bleibt. Der Ausdruck [Vorne || Vorne <- Ruhe, vorne <pivot] ist ein Listenverständnis, bedeutet "Erstellen Sie eine Liste von Elementen Vorderseite so dass Vorderseite ist ein Mitglied von Sich ausruhen, und Vorderseite ist weniger als Drehzahl. " ++ ist die Liste des Verkettungsbetreibers.

Eine Vergleichsfunktion kann für kompliziertere Strukturen zur Lesbarkeit verwendet werden.

Der folgende Code würde Listen nach Länge sortieren:

% Dies ist Datei 'listSort.erl' (der Compiler wird auf diese Weise erstellt) -Modul(Listort). % Export 'By_Length' mit 1 Parameter (kümmert sich nicht um den Typ und den Namen) -Export[By_length/1]). By_length(Listen) -> % Verwenden Sie 'QSORT/2' und liefert eine anonyme Funktion als Parameter  QSORT(Listen, Spaß(A,B) -> Länge(A) < Länge(B) Ende). QSORT([], _)-> []; % Wenn die Liste leer ist, geben Sie eine leere Liste zurück (ignorieren Sie den zweiten Parameter). QSORT[Drehzahl|Sich ausruhen], Kleiner) ->  % Partitionsliste mit 'kleineren' Elementen vor 'Pivot' und nicht 'Smaller' Elementen  % nach 'Pivot' und sortieren die Unterscheiben.  QSORT[X || X <- Sich ausruhen, Kleiner(X,Drehzahl)], Kleiner)  ++ [Drehzahl] ++  QSORT[Y || Y <- Sich ausruhen, nicht(Kleiner(Y, Drehzahl))], Kleiner).

A Drehzahl wird aus dem ersten Parameter entnommen QSORT () und der Rest von Listen benannt Sich ausruhen. Beachten Sie, dass der Ausdruck

[X || X <- Sich ausruhen, Kleiner(X,Drehzahl)]

ist in Form nicht anders als

[Vorderseite || Vorderseite <- Sich ausruhen, Vorderseite < Drehzahl]

(im vorherigen Beispiel) mit Ausnahme der Verwendung einer Vergleichsfunktion im letzten Teil: "Konstruieren Sie eine Liste von Elementen X so dass X ist ein Mitglied von Sich ausruhen, und Kleiner ist wahr ", mit Kleiner früher als definiert als

Spaß(A,B) -> Länge(A) < Länge(B) Ende

Das Anonyme Funktion benannt Kleiner in der Parameterliste der zweiten Definition von QSORT so dass es in dieser Funktion mit diesem Namen verwiesen werden kann. Es ist in der ersten Definition von nicht benannt QSORT, der sich mit dem Basisfall einer leeren Liste befasst und daher diese Funktion nicht benötigt, geschweige denn einen Namen dafür.

Datentypen

Erlang hat acht primitiv Datentypen:

Ganzzahlen
Ganzzahlen werden als Sequenzen von Dezimalstellen geschrieben, beispielsweise sind 12, 12375 und -23427 Ganzzahlen. Die ganzzahlige Arithmetik ist genau und nur durch den verfügbaren Speicher auf der Maschine begrenzt. (Das nennt man willkürliche Präzisionsarithmetik.))
Atome
Atome werden innerhalb eines Programms verwendet, um unterschiedene Werte zu bezeichnen. Sie werden als Zeichenfolgen aufeinanderfolgender alphanumerischer Zeichen geschrieben, wobei der erste Charakter Kleinbuchstaben ist. Atome können jeden Charakter enthalten, wenn sie in einzelnen Zitate eingeschlossen sind, und es gibt eine Fluchtkonvention, die es ermöglicht, in einem Atom ein Zeichen zu verwenden. Atome werden niemals Müll gesammelt und sollten mit Vorsicht verwendet werden, insbesondere wenn die dynamische Atomerzeugung verwendet wird.
Schwimmt
Schwimmende Punktnummern verwenden die IEEE 754 64-Bit-Darstellung.
Verweise
Referenzen sind global einzigartige Symbole, deren einzige Eigenschaft ist, dass sie für die Gleichheit verglichen werden können. Sie werden durch Bewertung des Erlang -Primitivs erstellt make_ref ().
Binärdateien
Eine Binärdatei ist eine Abfolge von Bytes. Binärdateien bieten eine platzeffiziente Möglichkeit, binäre Daten zu speichern. Erlang -Primitive existieren zum Komponieren und Zersetzen von Binärdateien sowie für eine effiziente Eingabe/Ausgabe von Binärdateien.
Pids
PID ist kurz für Prozesskennung- Eine PID wird vom Erlang Primitiv erzeugt laichen(...) PIDs sind Verweise auf Erlang -Prozesse.
Häfen
Ports werden verwendet, um mit der externen Welt zu kommunizieren. Ports werden mit der integrierten Funktion erstellt Open_port. Nachrichten können an Ports gesendet und empfangen werden. Diese Nachrichten müssen jedoch dem sogenannten "Port-Protokoll" gehorchen.
Spaß
Spaß sind Funktion Schließungen. Spaß werden durch Ausdrücke der Form erstellt: lustig (...) -> ... Ende.

Und drei zusammengesetzte Datentypen:

Tupel
Tupel sind Container für eine feste Anzahl von Erlang -Datentypen. Die Syntax {D1, d2, ..., dn} bezeichnet ein Tupel, dessen Argumente sind D1, D2, ... dn. Die Argumente können primitive Datentypen oder zusammengesetzte Datentypen sein. 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] bezeichnet eine Liste, deren erstes Element ist Dhund deren verbleibende Elemente die Liste sind Dt. Die Syntax [] bezeichnet eine leere Liste. Die Syntax [D1, D2, .., DN] ist kurz für [D1 | [d2 | .. | [dn | []]]]]. Auf das erste Element einer Liste kann in konstanter Zeit zugegriffen werden. Das erste Element einer Liste heißt die Kopf der Liste. Der Rest einer Liste, wenn sein Kopf entfernt wurde Schwanz der Liste.
Karten
Karten enthalten eine variable Anzahl von Schlüsselwertverbänden. Die Syntax ist#{Key1 => value1, ..., keyn => valuen}.

Zwei Formen von syntethischer Zucker sind zur Verfügung gestellt:

Saiten
Saiten werden als doppelt zitierte Zeichenlisten geschrieben. Dies ist syntaktischer Zucker für eine Liste der Ganzzahl Unicode Codepunkte für die Zeichen in der Zeichenfolge. So ist beispielsweise die Zeichenfolge "Katze" für die Kurzschrift für [99,97,116].[24]
Aufzeichnungen
Aufzeichnungen bieten eine bequeme Möglichkeit, ein Tag mit jedem der Elemente in einem Tupel zu assoziieren. Auf diese Weise kann man sich auf ein Element eines Tupels nennen und nicht per Position beziehen. Ein Vorkompiler übernimmt die Datensatzdefinition und ersetzt sie durch die entsprechende Tupelreferenz.

Erlang hat keine Methode, um Klassen zu definieren, obwohl es extern gibt Bibliotheken verfügbar.[25]

Codierungsstil "es zum Absturz bringen"

Erlang ist mit einem Mechanismus konzipiert, der es externen Prozessen leicht macht Ausnahmebehandlung Wird in vielen anderen Programmiersprachen verwendet. Abstürze werden wie andere Nachrichten gemeldet, so wie Prozesse nur miteinander kommunizieren können.[26] und Subprozesse können billig hervorgebracht werden. Die Philosophie "let it Crash" bevorzugt, dass ein Prozess vollständig neu gestartet wird, anstatt zu versuchen, sich von einem ernsthaften Versagen zu erholen.[27] Obwohl es immer noch Fehler behandelt werden muss, führt diese Philosophie zu weniger Code, der sich widmet Defensivprogrammierung Wo Fehlerbehandlungscode sehr kontextbezogen und spezifisch ist.[26]

Supervisorbäume

Eine typische Erlang -Anwendung ist in Form eines Supervisorbaums geschrieben. Diese Architektur basiert auf einer Hierarchie von Prozessen, in denen der oberste Ebene als "Supervisor" bezeichnet wird. Der Vorgesetzte erzeugt dann mehrere Kinderprozesse, die entweder als Arbeiter oder mehr als Supervisoren auf niedrigerer Ebene fungieren. Solche Hierarchien können in willkürlichen Tiefen existieren und haben gezeigt, dass sie eine hoch skalierbare und fehlertolerante Umgebung bieten, in der Anwendungsfunktionen implementiert werden können.

In einem Vorgesetztenbaum sind alle Vorgesetzten für die Verwaltung des Lebenszyklus ihrer Kinderprozesse verantwortlich, und dies umfasst die Handhabungssituationen, in denen diese Kinderprozesse abstürzen. Jeder Prozess kann ein Vorgesetzter werden, indem er zuerst einen Kinderprozess hervorbringt und dann anruft Erlang: Monitor/2 zu diesem Prozess. Wenn der überwachte Prozess abfällt, erhält der Vorgesetzte eine Nachricht mit einem Tupel, dessen erstes Mitglied das Atom ist 'NIEDER'. Der Vorgesetzte ist zunächst dafür verantwortlich, nach solchen Nachrichten zu hören und zweitens die entsprechende Maßnahme zur Korrektur der Fehlerbedingung.

Parallelitäts- und Verteilungsorientierung

Erlangs Hauptstärke ist Unterstützung für Parallelität. Es hat eine kleine, aber leistungsstarke Gruppe von Primitiven, um Prozesse zu erstellen und unter ihnen zu kommunizieren. Erlang ähnelt konzeptionell der Sprache occam, obwohl es die Ideen von neu formuliert Kommunizieren von sequentiellen Prozessen (CSP) in einem funktionalen Framework und verwendet asynchrone Nachrichtenübergabe.[28] Prozesse sind das Hauptmittel zur Strukturierung einer Erlang -Anwendung. Sie sind weder Betriebssystem Prozesse Noch Themen, aber leichte Prozesse, die von Strahl geplant sind. Wie Betriebssystemprozesse (jedoch im Gegensatz zu Betriebssystem -Threads) teilen sie keinen Zustand miteinander. Der geschätzte minimale Overhead beträgt jeweils 300 Wörter.[29] Somit können viele Prozesse ohne Abbauleistung erstellt werden. Im Jahr 2005 wurde ein Benchmark mit 20 Millionen Prozessen erfolgreich mit 64-Bit-Erlang auf einer Maschine mit 16 GB durchgeführt Arbeitsspeicher (RAM; insgesamt 800 Bytes/Prozess).[30] Erlang hat unterstützt Symmetrische Multiprozessierung Seit Veröffentlichung R11b vom Mai 2006.

Während Themen Erlang benötigt externe Bibliotheksunterstützung in den meisten Sprachen und bietet Funktionen auf Sprachebene, um Prozesse zu erstellen und zu verwalten, um die gleichzeitige Programmierung zu vereinfachen. Obwohl alle Parallelität in Erlang explizit sind, kommunizieren Prozesse mit Verwendung Nachrichtenübergang anstelle von gemeinsam genutzten Variablen, was die Notwendigkeit expliziten beseitigt Schlösser (Ein Verriegelungsschema wird immer noch intern von der VM verwendet).[31]

Interprozesskommunikation funktioniert über a geteilt asynchron Nachrichtenübergang System: Jeder Prozess hat eine "Mailbox", a Warteschlange von Nachrichten, die von anderen Prozessen gesendet und noch nicht konsumiert wurden. Ein Prozess verwendet die erhalten Primitiv, um Nachrichten abzurufen, die die gewünschten Muster übereinstimmen. Ein Routine zur Nachrichtentwicklung testet die Nachrichten wiederum gegen jedes Muster, bis einer von ihnen übereinstimmt. Wenn die Nachricht aus dem Mailbox verzehrt und entfernt wird, wird die Ausführung fortgesetzt. Eine Nachricht kann jede Erlang -Struktur umfassen, einschließlich Primitiven (Ganzzahlen, Schwimmer, Zeichen, Atome), Tupeln, Listen und Funktionen.

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

 % Erstellen Sie einen Prozess und rufen Sie das Funktionsnetz auf: start_server (Port, MaxConnections).  Serverprozess = laichen(Netz, start_server, [Hafen, MaxConnections]),,  % Erstellen Sie einen Remote -Prozess und rufen Sie die Funktion auf  % Web: start_server (Port, MaxConnections) auf Maschinen -Remotenode  Fernbedienung = laichen(Remotenode, Netz, start_server, [Hafen, MaxConnections]),,  % Senden Sie eine Nachricht an ServerProcess (asynchron). Die Nachricht besteht aus einem Tupel  % mit dem Atom "Pause" und der Zahl "10".  Serverprozess ! {Pause, 10},  % Empfangen Nachrichten, die an diesen Prozess gesendet werden  erhalten  eine Nachricht -> etwas tun;  {Daten, DataContent} -> handhaben(DataContent);  {hallo, Text} -> io:Format("HADE HALLO MODULE: ~ s", [Text]);  {Auf Wiedersehen, Text} -> io:Format("Hab Goodbye Nachricht: ~ s", [Text]))  Ende.

Wie das Beispiel zeigt, können Prozesse auf Remote -Knoten erstellt werden, und die Kommunikation mit ihnen ist transparent in dem Sinne, dass die Kommunikation mit Remote -Prozessen genau wie die Kommunikation mit lokalen Prozessen funktioniert.

Die Parallelität unterstützt die primäre Methode der Fehlerbehandlung in Erlang. Wenn ein Prozess abstürzt, beendet er eine Nachricht und sendet eine Nachricht an den Steuerungsprozess, der dann Maßnahmen ergreifen kann, z. B. einen neuen Prozess, der die Aufgabe des alten Prozesses übernimmt.[32][33]

Implementierung

Die offizielle Referenzimplementierung von Erlang verwendet Strahl.[34] Beam ist in der offiziellen Verteilung von Erlang, Erlang/OTP, enthalten. Strahl wird ausgeführt Bytecode welches auf konvertiert wird Thread -Code Zur Ladezeit. Es enthält außerdem einen nativen Code -Compiler auf den meisten Plattformen, das vom High Performance Erlang Project (HIPE) bei entwickelt wurde Uppsala Universität. Seit Oktober 2001 ist das HIPE -System vollständig in das Open -Source -Erlang/OTP -System von Ericsson integriert.[35] Es unterstützt auch die Interpretation, direkt vom Quellcode über den Quellcode Zusammenfassung Syntaxbaum, über Skript als R11b-5-Veröffentlichung von Erlang.

Lade- und Module des Heißcodes

Erlang unterstützt Sprachniveau Dynamische Software -Aktualisierung. Um dies zu implementieren, wird der Code als "Modul" -Inits geladen und verwaltet. Das Modul ist a Kompilierungseinheit. Das System kann gleichzeitig zwei Versionen eines Moduls im Speicher aufbewahren, und Prozesse können gleichzeitig Code von jedem ausführen. Die Versionen werden als "neue" und "alte" Version bezeichnet. Ein Vorgang wird erst in die neue Version übergehen, wenn er einen externen Aufruf an sein Modul tätigt.

Ein Beispiel für den Mechanismus des Ladens des Hotcode:

  %% Ein Prozess, dessen einzige Aufgabe es ist, einen Zähler zu behalten.  %% Erste Version  -Modul(Zähler).  -Export[Anfang/0, Codesschalter/1]).  Anfang() -> Schleife(0).  Schleife(Summe) ->  erhalten  {Zuwachs, Zählen} ->  Schleife(Summe+Zählen);  {Zähler, PID} ->  PID ! {Zähler, Summe},  Schleife(Summe);  code_switch ->  ?MODUL:Codesschalter(Summe)  % Erzwingen Sie die Verwendung von 'codesschalter/1' aus der neuesten Modulversion  Ende.  Codesschalter(Summe) -> Schleife(Summe).

Für die zweite Version fügen wir die Möglichkeit hinzu, die Anzahl auf Null zurückzusetzen.

  %% zweite Version  -Modul(Zähler).  -Export[Anfang/0, Codesschalter/1]).  Anfang() -> Schleife(0).  Schleife(Summe) ->  erhalten  {Zuwachs, Zählen} ->  Schleife(Summe+Zählen);  zurücksetzen ->  Schleife(0);  {Zähler, PID} ->  PID ! {Zähler, Summe},  Schleife(Summe);  code_switch ->  ?MODUL:Codesschalter(Summe)  Ende.  Codesschalter(Summe) -> Schleife(Summe).

Nur wenn eine Nachricht aus dem Atom besteht code_switch Wird die Schleife einen externen Anruf zum Codeswitch/1 ausführen ((?MODUL ist ein Präprozessor -Makro für das aktuelle Modul). Wenn es eine neue Version der gibt Zähler Modul im Speicher, dann wird die Funktion codeswitch/1 aufgerufen. Die Praxis, einen bestimmten Einstieg in eine neue Version zu haben, ermöglicht es dem Programmierer, den Status in das zu verwandeln, was in der neueren Version benötigt wird. Im Beispiel wird der Staat als Ganzzahl aufbewahrt.

In der Praxis werden Systeme mit Designprinzipien der Open Telecom Platform aufgebaut, was zu mehr Code -Upstading -Designs führt. Erfolgreiches Hotcode -Laden ist anspruchsvoll. Der Code muss mit Sorgfalt geschrieben werden, um die Einrichtungen von Erlang zu nutzen.

Verteilung

1998 veröffentlichte Ericsson Erlang als Kostenlose und Open-Source-Software Um seine Unabhängigkeit von einem einzelnen Anbieter zu gewährleisten und das Bewusstsein für die Sprache zu schärfen. Erlang, zusammen mit Bibliotheken und der in Echtzeit verteilten Datenbank Mnesiabildet die OTP -Sammlung von Bibliotheken. Ericsson und einige andere Unternehmen unterstützen Erlang kommerziell.

Seit der Open -Source -Veröffentlichung wurde Erlang von mehreren Firmen weltweit verwendet, einschließlich Nortel und T-Mobile.[36] Obwohl Erlang eine Nische füllen sollte und für den größten Teil seiner Existenz eine dunkle Sprache geblieben ist, wächst seine Popularität aufgrund der Nachfrage nach gleichzeitigen Diensten.[37][38] Erlang hat einige Verwendung beim Feld gefunden Massiv Multiplayer Online-Rollenspielspiel (MMORPG) Server.[39]

Siehe auch

Verweise

  1. ^ https://github.com/erlang/otp/releases/tag/otp-24.1.6.
  2. ^ Konferenzen, N. D. C. (4. Juni 2014). "Joe Armstrong - funktionales Programmieren Der lange Weg zur Aufklärung: Eine historische und persönliche Erzählung". Vimeo.
  3. ^ "Clojure: Lisp trifft Java mit einer Seite von Erlang - O'Reilly Radar". radar.orilly.com.
  4. ^ "Erlang - Einführung". Erlang.org.
  5. ^ Armstrong, Joe; Däcker, Bjarne; Lindgren, Thomas; Millroth, Håkan. "Open-Source Erlang-Weißes Papier". Archiviert von das Original am 25. Oktober 2011. Abgerufen 31. Juli 2011.
  6. ^ Anhalterungstour durch den Strahl - Robert Virding http://www-
  7. ^ a b c d e f Armstrong, Joe (2007). Geschichte von Erlang. HOPL III: Verfahren der dritten ACM -Sigplan -Konferenz über die Geschichte der Programmiersprachen. ISBN 978-1-59593-766-7.
  8. ^ "Wie Tech -Giganten Open -Source -Programmierliebe verbreiten - cio.com". 8. Januar 2016.
  9. ^ "Erlang/OTP als Open Source, 1998-12-08 veröffentlicht". Archiviert von das Original am 9. Oktober 1999.
  10. ^ "Erlang, der Mathematiker?".
  11. ^ "Kostenloses Online -Wörterbuch von Computing: Erlang".
  12. ^ "Geschichte von Erlang". Erlang.org.
  13. ^ Armstrong, Joe (August 1997). "Die Entwicklung von Erlang". ACM Sigplan nennt. 32 (8): 196–203. doi:10.1145/258948.258967. ISBN 0897919181. S2CID 6821037.
  14. ^ Däcker, Bjarne (Oktober 2000). Gleichzeitige funktionelle Programmierung für Telekommunikation: Eine Fallstudie zur Technologieeinführung (PDF) (These). Royal Institute of Technology. p. 37.
  15. ^ a b "Frage zu Erlangs Zukunft". 6. Juli 2010.
  16. ^ "Parallelität orientierte Programmierung in Erlang" (PDF). 9. November 2002.
  17. ^ http://erlang.org/download/armstrong_thesis_2003.pdf[Bare URL PDF]
  18. ^ McGreggor, Duncan (26. März 2013). Rackspace schaut sich die Erlang -Programmiersprache für verteiltes Computing an (Video). Rackspace Studios, SFO. Archiviert vom Original am 11. Dezember 2021. Abgerufen 24. April 2019.
  19. ^ "Ericsson". Ericsson.com. 4. Dezember 2014. Abgerufen 7. April 2018.
  20. ^ "In Erlang, der seltenen Programmiersprache hinter WhatsApps Erfolg". fastcompany.com. 21. Februar 2014. Abgerufen 12. November 2019.
  21. ^ "Welche Unternehmen verwenden Erlang und warum? #Mytopdogstatus". Erlang-Solutions.com. 11. September 2019. Abgerufen 15. März 2020.
  22. ^ "Welche neuen Unternehmen verwenden Erlang und Elixir? #Mytopdogstatus". Erlang-Solutions.com. 2. März 2020. Abgerufen 24. Juni 2020.
  23. ^ "Erlang - Auflistung von Verständnissen". Erlang.org.
  24. ^ "String- und Charakter -Literale". Abgerufen 2. Mai 2015.
  25. ^ "ECT-ERLANG-Klasse Transformation-Hinzufügen von objektorientiertem Programmieren zu Erlang-Google Project Hosting". Abgerufen 2. Mai 2015.
  26. ^ a b Verraes, Mathias (9. Dezember 2014). "Lass es abstürzen". Mathias Verraes 'Blog. Abgerufen 10. Februar 2021.
  27. ^ "Reaktive Designmuster -". www.reactivedesignPatterns.com. Abgerufen 10. Februar 2021.
  28. ^ Armstrong, Joe (September 2010). "Erlang". Kommunikation der ACM. 53 (9): 68–75. doi:10.1145/1810891.1810910. Erlang ähnelt konzeptionell der OCCAM -Programmiersprache, obwohl es die Ideen von CSP in einem funktionalen Framework neu setzt und asynchrones Nachrichtenübergang verwendet.
  29. ^ "Effizienzhandbuch für Erlang - Prozesse". Archiviert von das Original am 27. Februar 2015.
  30. ^ Wiger, ULF (14. November 2005). "Stresstesting Erlang". comp.lang.functional.misc. Abgerufen 25. August 2006.
  31. ^ "Lockfreie Nachrichtenwarteschlange". Abgerufen 23. Dezember 2013.
  32. ^ Armstrong, Joe. "Erlang Robustheit". Archiviert von das Original am 23. April 2015. Abgerufen 15. Juli 2010.
  33. ^ "Erlang Überwachungsgrundsätze". Archiviert von das Original am 6. Februar 2015. Abgerufen 15. Juli 2010.
  34. ^ "Erlang - Kompilierung und Code -Laden". Erlang.org. Abgerufen 21. Dezember 2017.
  35. ^ "High Performance Erlang". Abgerufen 26. März 2011.
  36. ^ "Wer nutzt Erlang für die Produktentwicklung?". Häufig gestellte Fragen zu Erlang. Abgerufen 16. Juli 2007. Der größte Benutzer von Erlang ist (Überraschung!) Ericsson. Ericsson schreibt es, um Software zu schreiben, die in Telekommunikationssystemen verwendet wird. Viele Dutzende von Projekten haben es verwendet, ein besonders großes ist der extrem skalierbare AXD301 -Atmschalter. Weitere kommerzielle Benutzer, die im Rahmen der FAQ aufgeführt sind Luftraumüberwachung Organisation) und T-Mobile.
  37. ^ "Programmieren von Erlang". Abgerufen 13. Dezember 2008. Praktisch alle Sprachgebrauch verwenden die Parallelität der gemeinsamen Status. Dies ist sehr schwierig und führt zu schrecklichen Problemen, wenn Sie mit dem Versagen umgehen und das System skalieren ... einige ziemlich schnell bewegende Startups in der Finanzwelt haben sich an Erlang eingesperrt. Zum Beispiel der schwedische www.kreditor.se.
  38. ^ "Erlang, der nächste Java". Archiviert von das Original am 11. Oktober 2007. Abgerufen 8. Oktober 2008. Ich glaube nicht, dass andere Sprachen Erlang bald einholen können. Es ist für sie einfach, Sprachfunktionen hinzuzufügen, um wie Erlang zu sein. Es wird lange dauern, bis sie eine so hochwertige VM und die reifen Bibliotheken für Parallelität und Zuverlässigkeit aufbauen. Erlang ist also für den Erfolg bereit. Wenn Sie in den nächsten Jahren eine Multicore -Anwendung erstellen möchten, sollten Sie sich Erlang ansehen.
  39. ^ Clarke, Gavin (5. Februar 2011). "Battlestar Galactica -Tierärzte benötigt für Online -Rollenspiele". Musik und Medien. Die Reg. Abgerufen 8. Februar 2011.

Weitere Lektüre

Externe Links