Aplikacionet Erlang janë ndërtuar nga procese shumë të lehta Erlang në sistemin e ekzekutimit Erlang. Sistemi i ekzekutimit Erlang siguron izolim të rreptë të proceseve (kjo përfshin mbledhjen e të dhënave dhe mbeturinave, të ndara individualisht për secilin proces Erlang) dhe komunikim transparent midis proceseve (shih transparenca e vendndodhjes) në nyje të ndryshme Erlang (në hostë të ndryshëm).

Joe Armstrong, bashkëshpikësi i Erlang, përmblodhi parimet e proceseve në disertacionin e tij të doktoraturës :^[20]

• Çdo gjë është një proces.
• Proceset janë të izoluara fort.
• Krijimi dhe shkatërrimi i proceseve është një operacion i lehtë.
• Kalimi i mesazheve është e vetmja mënyrë që proceset të bashkëveprojnë.
• Proceset kanë emra unikë.
• Nëse e dini emrin e një procesi, mund t'i dërgoni një mesazh.
• Proceset nuk ndajnë burime.
• Trajtimi i gabimeve nuk është lokal.
• Proceset bëjnë atë që duhet të bëjnë ose dështojnë.

Joe Armstrong tha në një intervistë me Rackspace në vitin 2013: "Nëse Java është ' shkruaj një herë, ekzekuto kudo ', atëherë Erlang është 'shkruaj një herë, ekzekuto përgjithmonë'."^[21]

Në vitin 2014, Ericsson raportoi se Erlang po përdorej në nyjet e saj mbështetëse, dhe në rrjetet mobile GPRS, 3G dhe LTE në mbarë botën, si dhe nga Nortel dhe Deutsche Telekom.^[22]

Erlang përdoret në RabbitMQ. Siç e shprehu Tim Bray, drejtor i Teknologjive Web në Sun Microsystems, në fjalimin e tij kryesor në Konventën e Burimit të Hapur O'Reilly (OSCON) në korrik 2008:   Nëse dikush do të vinte tek unë dhe do të më ofronte shumë para për të ndërtuar një sistem të madh për menaxhimin e mesazheve që duhet të jetë gjithmonë në funksion dhe nuk guxon të bjerë nga puna për vite me radhë, unë pa hezitim do të zgjidhja Erlang për ta ndërtuar. Erlang është gjuha programuese që përdoret për të koduar WhatsApp^[23]

Është gjithashtu gjuha e zgjedhur për Ejabberd - një server mesazhesh XMPP.

Elixir është një gjuhë programuese që kompilohet në kod bajtesh BEAM (nëpërmjet Erlang Abstract Format).^[24]

Që kur u publikua si burim i hapur, Erlang është përhapur përtej telekomunikacionit, duke u vendosur në tregje të tjera vertikale si FinTech, lojërat, kujdesi shëndetësor, automobilistike, Interneti i Gjërave dhe blockchain. Përveç WhatsApp, ka edhe kompani të tjera të listuara si histori suksesi të Erlang, duke përfshirë Vocalink (një kompani e MasterCard), Goldman Sachs, Nintendo, AdRoll, Grindr, BT Mobile, Samsung, OpenX dhe SITA.^[25][26]

Një algoritëm faktorial i zbatuar në Erlang:

-module(fact). % This is the file 'fact.erl', the module and the filename must match
-export([fac/1]). % This exports the function 'fac' of arity 1 (1 parameter, no type, no name)

fac(0) -> 1; % If 0, then return 1, otherwise (note the semicolon ; meaning 'else')
fac(N) when N > 0, is_integer(N) -> N * fac(N-1).
% Recursively determine, then return the result
% (note the period . meaning 'endif' or 'function end')
%% This function will crash if anything other than a nonnegative integer is given.
%% It illustrates the "Let it crash" philosophy of Erlang.

Një algoritëm rekursiv i bishtit që prodhon sekuencën Fibonacci:

%% The module declaration must match the file name "series.erl" 
-module(series).

%% The export statement contains a list of all those functions that form
%% the module's public API. In this case, this module exposes a single
%% function called fib that takes 1 argument (I.E. has an arity of 1)
%% The general syntax for -export is a list containing the name and
%% arity of each public function
-export([fib/1]).

%% ---------------------------------------------------------------------
%% Public API
%% ---------------------------------------------------------------------

%% Handle cases in which fib/1 receives specific values
%% The order in which these function signatures are declared is a vital
%% part of this module's functionality

%% If fib/1 receives a negative number, then return the atom err_neg_val
%% Normally, such defensive coding is discouraged due to Erlang's 'Let
%% it Crash' philosophy, but here the result would be an infinite loop.
fib(N) when N < 0 -> err_neg_val;

%% If fib/1 is passed precisely the integer 0, then return 0
fib(0) -> 0;

%% For all other values, call the private function fib_int/3 to perform
%% the calculation
fib(N) -> fib_int(N-1, 0, 1).

%% ---------------------------------------------------------------------
%% Private API
%% ---------------------------------------------------------------------

%% If fib_int/3 receives 0 as its first argument, then we're done, so
%% return the value in argument B. The second argument is denoted _ to
%% disregard its value.
fib_int(0, _, B) -> B;

%% For all other argument combinations, recursively call fib_int/3
%% where each call does the following:
%% - decrement counter N
%% - pass the third argument as the new second argument
%% - pass the sum of the second and third arguments as the new
%%  third argument
fib_int(N, A, B) -> fib_int(N-1, B, A+B).

Heqja e komenteve e bënë një program shumë më të shkurtër.

-module(series).
-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).

Renditje e shpejtë në Erlang, duke përdorur përfitim listash:^[27]

%% qsort:qsort(List)
%% Sort a list of items
-module(qsort).   % This is the file 'qsort.erl'
-export([qsort/1]). % A function 'qsort' with 1 parameter is exported (no type, no name)

qsort([]) -> []; % If the list [] is empty, return an empty list (nothing to sort)
qsort([Pivot|Rest]) ->
  % Compose recursively a list with 'Front' for all elements that should be before 'Pivot'
  % then 'Pivot' then 'Back' for all elements that should be after 'Pivot'
  qsort([Front || Front <- Rest, Front < Pivot]) ++ 
  [Pivot] ++
  qsort([Back || Back <- Rest, Back >= Pivot]).

Shembulli i mësipërm thërret në mënyrë rekursive funksionin qsort derisa të mos mbetet asgjë për t’u renditur. Shprehja [Front || Front <- Rest, Front < Pivot] është një përftim listash (list comprehension), që do të thotë: “Ndërto një listë elementësh Front të tillë që Front është element i Rest dhe Front është më i vogël se Pivot.” ++ është operatori i bashkimit të listave.

Një funksion krahasimi mund të përdoret për struktura më të ndërlikuara për hir të lexueshmërisë.

Kodi i mëposhtëm do të rendiste listat sipas gjatësisë:

% This is file 'listsort.erl' (the compiler is made this way)
-module(listsort).
% Export 'by_length' with 1 parameter (don't care about the type and name)
-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([], _)-> []; % If list is empty, return an empty list (ignore the second parameter)
qsort([Pivot|Rest], Smaller) ->
  % Partition list with 'Smaller' elements in front of 'Pivot' and not-'Smaller' elements
  % after 'Pivot' and sort the sublists.
  qsort([X || X <- Rest, Smaller(X,Pivot)], Smaller)
  ++ [Pivot] ++
  qsort([Y || Y <- Rest, not(Smaller(Y, Pivot))], Smaller).

Një Pivot merret nga parametri i parë i dhënë qsort() dhe pjesa tjetër e Lists quhet Rest . Vini re se shprehja

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

nuk është ndryshe në formë nga

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

(në shembullin e mëparshëm) përveç përdorimit të një funksioni krahasimi në pjesën e fundit, duke thënë "Ndërtoni një listë elementësh X të tillë që X të jetë anëtar i Rest, dhe Smaller është true", me Smaller të përcaktuar më parë si

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

Funksioni anonim emërtohet Smaller në listën e parametrave të përkufizimit të dytë të qsort në mënyrë që të mund të referencohet me atë emër brenda atij funksioni. Ai nuk emërtohet në përkufizimin e parë të qsort, i cili merret me rastin bazë të një liste bosh dhe kështu nuk ka nevojë për këtë funksion, e lëre më për një emër për të.

Erlang është projektuar me një mekanizëm që e bën të lehtë për proceset e jashtme të monitorojnë rrëzimet (ose dështimet e harduerit), në vend të një mekanizmi brenda procesit si trajtimi i përjashtimeve që përdoret në shumë gjuhë të tjera programimi. Rrëzimet raportohen si çdo mesazh tjetër.Që është e vetmja mënyrë se si proceset mund të komunikojnë me njëri-tjetrin, dhe nënproceset mund të krijohen me kosto shumë të ulët (shih më poshtë). Filozofia “le të rrëzohet” preferon që një proces të rifillohet plotësisht, në vend që të përpiqet të rikuperohet nga një dështim serioz.Edhe pse përsëri kërkohet trajtimi i gabimeve, kjo filozofi rezulton në më pak kod të dedikuar për programim mbrojtës, pasi kodi për trajtimin e gabimeve është zakonisht shumë kontekstual dhe specifik.

Forca kryesore e Erlang është mbështetja për konkurencën. Ai ka një grup të vogël, por të fuqishëm primitivësh për të krijuar procese dhe për të komunikuar midis tyre.Erlang është konceptualisht i ngjashëm me gjuhën Occam, megjithëse riformulon idetë e Komunikimit të Proceseve Sekuenciale (CSP) në një kornizë funksionale dhe përdor kalimin asinkron të mesazheve. Proceset janë mjeti kryesor për të strukturuar një aplikacion Erlang.Ato nuk janë as procese të sistemit operativ dhe as fije, por procese të lehta që planifikohen nga BEAM.Ashtu si proceset e sistemit operativ (por ndryshe nga fijet e sistemit operativ), ato nuk ndajnë gjendje me njëra-tjetrën. Shpenzimi minimal i vlerësuar për secilin është 300 fjalë. Kështu, shumë procese mund të krijohen pa ulur performancën. Në vitin 2005, një test me 20 milionë procese u krye me sukses me Erlang 64-bit në një makinë me 16 GB memorie me akses të rastësishëm (RAM; gjithsej 800 bajt/proces).Erlang ka mbështetur shumëpërpunimin simetrik që nga lëshimi R11B në maj 2006.

Ndërsa fijet kanë nevojë për mbështetje nga biblioteka të jashtme në shumicën e gjuhëve,Erlang ofron veçori të nivelit gjuhësor për të krijuar dhe menaxhuar procese me qëllim thjeshtimin e programimit të njëkohshëm.Megjithëse e gjithë bashkëkohësia është e qartë në Erlang,proceset komunikojnë duke përdorur kalimin e mesazheve në vend të variablave të përbashkëta,gjë që eliminon nevojën për bllokime të qarta (një skemë bllokimi përdoret ende brenda makinës virtuale).

Komunikimi ndër-proces funksionon përmes një sistemi të mesazheve asinkrone me parimin “shared-nothing”:çdo proces ka një “kuti postare”, një radhë mesazhesh që janë dërguar nga procese të tjera dhe që ende nuk janë konsumuar.Një proces përdor primitivin receive për të marrë mesazhet që përputhen me modelet e dëshiruara. Një rutinë e trajtimit të mesazheve i teston mesazhet me radhë kundrejt secilit model, derisa njëri prej tyre të përputhet.Kur mesazhi konsumohet dhe hiqet nga kutia postare, procesi rifillon ekzekutimin.Një mesazh mund të përfshijë çdo strukturë Erlang, duke përfshirë primitivat (numra të plotë, numra devijues, karaktere, atome), tuple, lista dhe funksione.

Shembulli i kodit më poshtë tregon mbështetjen e integruar për proceset e shpërndara:

 % Create a process and invoke the function web:start_server(Port, MaxConnections)
 ServerProcess = spawn(web, start_server, [Port, MaxConnections]),

 % Create a remote process and invoke the function
 % web:start_server(Port, MaxConnections) on machine RemoteNode
 RemoteProcess = spawn(RemoteNode, web, start_server, [Port, MaxConnections]),

 % Send a message to ServerProcess (asynchronously). The message consists of a tuple
 % with the atom "pause" and the number "10".
 ServerProcess ! {pause, 10},

 % Receive messages sent to this process
 receive
     a_message -> do_something;
     {data, DataContent} -> handle(DataContent);
     {hello, Text} -> io:format("Got hello message: ~s", [Text]);
     {goodbye, Text} -> io:format("Got goodbye message: ~s", [Text])
 end.

Siç tregon shembulli, proceset mund të krijohen në nyje të largëta dhe komunikimi me to është transparent, në kuptimin që komunikimi me proceset e largëta funksionon saktësisht njësoj si komunikimi me proceset lokale.

Bashkëkohësia mbështet metodën kryesore të trajtimit të gabimeve në Erlang.Kur një proces rrëzohet, ai del në mënyrë të rregullt dhe i dërgon një mesazh procesit kontrollues, i cili më pas mund të ndërmarrë veprime, si për shembull nisjen e një procesi të ri që merr përsipër detyrën e procesit të vjetër.

Implementimi zyrtar i referencës së Erlang përdor BEAM. BEAM është përfshirë në shpërndarjen zyrtare të Erlang, të quajtur Erlang/OTP. BEAM ekzekuton bytecode i cili konvertohet në kod të filetuar në kohën e ngarkimit. Ai gjithashtu përfshin një përpilues kodi vendas në shumicën e platformave, të zhvilluar nga Projekti Erlang me Performancë të Lartë (HiPE) në Universitetin Uppsala. Që nga tetori i vitit 2001, sistemi HiPE është integruar plotësisht në sistemin Erlang/OTP me burim të hapur të Ericsson. Ai gjithashtu mbështet interpretimin, direkt nga kodi burimor nëpërmjet pemës abstrakte të sintaksës, nëpërmjet skriptit që nga versioni R11B-5 i Erlang.

Erlang mbështet Përditësimin Dinamik të Softuerit në nivel gjuhe. Për ta zbatuar këtë, kodi ngarkohet dhe menaxhohet si njësi “moduli”; moduli është një njësi kompilimi. Sistemi mund të mbajë dy versione të një moduli në memorie në të njëjtën kohë, dhe proceset mund të ekzekutojnë kod njëkohësisht nga secili. Versionet referohen si versioni “i ri” dhe “i vjetër”. Një proces nuk do të kalojë në versionin e ri derisa të bëjë një thirrje të jashtme në modulin e tij.

Një shembull i mekanizmit të ngarkimit të kodit të nxehtë:

 %% A process whose only job is to keep a counter.
 %% First version
 -module(counter).
 -export([start/0, codeswitch/1]).

 start() -> loop(0).

 loop(Sum) ->
  receive
    {increment, Count} ->
     loop(Sum+Count);
    {counter, Pid} ->
     Pid ! {counter, Sum},
     loop(Sum);
    code_switch ->
     ?MODULE:codeswitch(Sum)
     % Force the use of 'codeswitch/1' from the latest MODULE version
  end.

 codeswitch(Sum) -> loop(Sum).

Për versionin e dytë, shtojmë mundësinë për ta rivendosur numërimin në 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).

Vetëm kur merr një mesazh që përbëhet nga atomi code_switch, cikli do të ekzekutojë një thirrje të jashtme te codeswitch/1 (?MODULE është një makro e paraprocesorit për modulin aktual). Nëse ka një version të ri të modulit të numëruesit në memorie, atëherë do të thirret funksioni i tij codeswitch/1.Praktika e të pasurit një pike hyrëse specifike në një version të ri i lejon programuesit të transformojë gjendjen në atë që nevojitet në versionin më të ri.Në shembull, gjendja mbahet si një numër i plotë.

Në praktikë, sistemet ndërtohen duke përdorur parimet e projektimit nga Platforma e Telekomit të Hapur, gjë që çon në dizajne më të përditësueshme të kodit.Ngarkimi i suksesshëm i kodit të nxehtë është i vështirë.Kodi duhet të shkruhet me kujdes për të shfrytëzuar lehtësitë e Erlang-ut.

Në vitin 1998, Ericsson publikoi Erlang si softuer falas dhe me burim të hapur për të siguruar pavarësinë e tij nga një shitës i vetëm dhe për të rritur ndërgjegjësimin për gjuhën. Erlang, së bashku me bibliotekat dhe bazën e të dhënave të shpërndarë në kohë reale Mnesia, formon koleksionin OTP të bibliotekave. Ericsson dhe disa kompani të tjera e mbështesin Erlang komercialisht.

Që nga publikimi me kod të hapur, Erlang është përdorur nga disa firma në të gjithë botën, duke përfshirë Nortel dhe Deutsche Telekom.^[28] Edhe pse Erlang u krijua për të mbushur një vend të caktuar dhe ka mbetur një gjuhë e panjohur për pjesën më të madhe të ekzistencës së tij, popullariteti i tij po rritet për shkak të kërkesës për shërbime të njëkohshme.^[29][30] Erlang ka gjetur njëfarë përdorimi në vendosjen e serverave masivë të lojërave online me role (MMORPG) për shumë lojtarë.^[31]

• Elixir – një gjuhë programimi funksionale, konkurrente dhe e përgjithshme që funksionon mbi BEAM.

• Luerl – Lua në BEAM, e projektuar dhe implementuar nga një prej krijuesve të Erlang-ut.

• Lisp Flavored Erlang (LFE) – një gjuhë programimi e bazuar në Lisp që funksionon mbi BEAM.
• Mix – mjet ndërtimi (build tool).
• Phoenix – kornizë (framework) për zhvillimin e aplikacioneve web.
• Gleam – një gjuhë programimi e nivelit të lartë, funksionale, konkurrente dhe e përgjithshme, që kompilohet në Erlang.

• "Erlang: Filmi"

Stampa:Programming languages [[Kategoria:Gjuhë programimi]] [[Kategoria:Ericsson]] [[Kategoria:Faqe me adresa nga Wayback Machine që përdorin stampën e arkivës së rrjetit]] [[Kategoria:Faqe me përkthime të pashqyrtuara]]