| Erlang | |
|---|---|
 | |
| Paradigms | Multi-paradigm:concurrent,functional |
| Designed by |
|
| Developer | Ericsson |
| First appeared | 1986; 39 years ago (1986) |
| Stable release | |
| Typing discipline | Dynamic,strong |
| License | Apache License 2.0 |
| Filename extensions | .erl, .hrl |
| Website | www |
| Majorimplementations | |
| Erlang | |
| Influenced by | |
| Lisp,PLEX,[2]Prolog,Smalltalk | |
| Influenced | |
| Akka,Clojure,[3]Dart,Elixir,F#,Opa,Oz,Reia,Rust,[4]Scala,Go | |
| |
Erlang (/ˈɜːrlæŋ/UR-lang) is ageneral-purpose,concurrent,functionalhigh-levelprogramming language, and agarbage-collectedruntime system. The term Erlang is used interchangeably with Erlang/OTP, orOpen Telecom Platform (OTP), which consists of the Erlangruntime system, several ready-to-use components (OTP) mainly written in Erlang, and a set ofdesign principles for Erlang programs.[5]
The Erlangruntime system is designed for systems with these traits:
The Erlangprogramming language has data,pattern matching, andfunctional programming.[7] The sequential subset of the Erlang language supportseager evaluation,single assignment, anddynamic typing.
A normal Erlang application is built out of hundreds of small Erlang processes.
It was originallyproprietary software withinEricsson, developed byJoe Armstrong, Robert Virding, and Mike Williams in 1986,[8] but was released asfree and open-source software in 1998.[9][10] Erlang/OTP is supported and maintained by the Open Telecom Platform (OTP) product unit atEricsson.
The nameErlang, attributed to Bjarne Däcker, has been presumed by those working on the telephony switches (for whom the language was designed) to be a reference to Danish mathematician and engineerAgner Krarup Erlang and asyllabic abbreviation of "Ericsson Language".[8][11][12] Erlang was designed with the aim of improving the development of telephony applications.[13] The initial version of Erlang was implemented inProlog and was influenced by the programming languagePLEX used in earlier Ericsson exchanges. By 1988 Erlang had proven that it was suitable for prototyping telephone exchanges, but the Prolog interpreter was far too slow. One group within Ericsson estimated that it would need to be 40 times faster to be suitable for production use. In 1992, work began on theBEAMvirtual machine (VM), which compiles Erlang to C using a mix of natively compiled code andthreaded code to strike a balance between performance and disk space.[14] According to co-inventor Joe Armstrong, the language went from laboratory product to real applications following the collapse of the next-generationAXE telephone exchange namedAXE-N in 1995. As a result, Erlang was chosen for the nextAsynchronous Transfer Mode (ATM) exchangeAXD.[8]
In February 1998, Ericsson Radio Systems banned the in-house use of Erlang for new products, citing a preference for non-proprietary languages.[15] The ban caused Armstrong and others to make plans to leave Ericsson.[16] In March 1998 Ericsson announced the AXD301 switch,[8] containing over a million lines of Erlang and reported to achieve ahigh availability ofnine "9"s.[17] In December 1998, the implementation of Erlang was open-sourced and most of the Erlang team resigned to form a new company, Bluetail AB.[8] Ericsson eventually relaxed the ban and re-hired Armstrong in 2004.[16]
In 2006, nativesymmetric multiprocessing support was added to the runtime system and VM.[8]
Erlang applications are built of very lightweight Erlang processes in the Erlang runtime system. The Erlang runtime system provides strictprocess isolation between Erlang processes (this includes data and garbage collection, separated individually by each Erlang process) and transparent communication between processes (seeLocation transparency) on different Erlang nodes (on different hosts).
Joe Armstrong, co-inventor of Erlang, summarized the principles of processes in hisPhDthesis:[18]
Joe Armstrong remarked in an interview with Rackspace in 2013: "IfJava is 'write once, run anywhere', then Erlang is 'write once, run forever'."[19]
In 2014,Ericsson reported Erlang was being used in its support nodes, and inGPRS,3G andLTE mobile networks worldwide and also byNortel andDeutsche Telekom.[20]
Erlang is used inRabbitMQ. AsTim Bray, director of Web Technologies atSun Microsystems, expressed in his keynote atO'Reilly Open Source Convention (OSCON) in July 2008:
If somebody came to me and wanted to pay me a lot of money to build a large scale message handling system that really had to be up all the time, could never afford to go down for years at a time, I would unhesitatingly choose Erlang to build it in.
Erlang is the programming language used to codeWhatsApp.[21]
It is also the language of choice forEjabberd – anXMPP messaging server.
Elixir is a programming language that compiles into BEAM byte code (via Erlang Abstract Format).[22]
Since being released as open source, Erlang has been spreading beyond telecoms, establishing itself in other vertical markets such as FinTech, gaming, healthcare, automotive,Internet of Things and blockchain. Apart from WhatsApp, there are other companies listed as Erlang's success stories, includingVocalink (a MasterCard company),Goldman Sachs,Nintendo, AdRoll,Grindr,BT Mobile,Samsung,OpenX, andSITA.[23][24]
Afactorial algorithm implemented in 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)whenN>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.
A tail recursive algorithm that produces theFibonacci sequence:
%% 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)whenN<0->err_neg_val;%% If fib/1 is passed precisely the integer 0, then return 0fib(0)->0;%% For all other values, call the private function fib_int/3 to perform%% the calculationfib(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 argumentfib_int(N,A,B)->fib_int(N-1,B,A+B).
Omitting the comments gives a much shorter program.
-module(series).-export([fib/1]).fib(N)whenN<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, usinglist comprehension:[25]
%% 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]).
The above example recursively invokes the functionqsort until nothing remains to be sorted. The expression[Front || Front <- Rest, Front < Pivot] is alist comprehension, meaning "Construct a list of elementsFront such thatFront is a member ofRest, andFront is less thanPivot."++ is the list concatenation operator.
A comparison function can be used for more complicated structures for the sake of readability.
The following code would sort lists according to length:
% 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 parameterqsort(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).
APivot is taken from the first parameter given toqsort() and the rest ofLists is namedRest. Note that the expression
[X||X<-Rest,Smaller(X,Pivot)]
is no different in form from
[Front||Front<-Rest,Front<Pivot]
(in the previous example) except for the use of a comparison function in the last part, saying "Construct a list of elementsX such thatX is a member ofRest, andSmaller is true", withSmaller being defined earlier as
fun(A,B)->length(A)<length(B)end
Theanonymous function is namedSmaller in the parameter list of the second definition ofqsort so that it can be referenced by that name within that function. It is not named in the first definition ofqsort, which deals with the base case of an empty list and thus has no need of this function, let alone a name for it.
Erlang has eight primitivedata types:
make_ref().spawn(...) Pids are references to Erlang processes.open_port. Messages can be sent to and received from ports, but these messages must obey the so-called "port protocol."fun(...) -> ... end.And three compound data types:
{D1,D2,...,Dn} denotes a tuple whose arguments areD1, D2, ... Dn. The arguments can be primitive data types or compound data types. Any element of a tuple can be accessed in constant time.[Dh|Dt] denotes a list whose first element isDh, and whose remaining elements are the listDt. The syntax[] denotes an empty list. The syntax[D1,D2,..,Dn] is short for[D1|[D2|..|[Dn|[]]]]. The first element of a list can be accessed in constant time. The first element of a list is called thehead of the list. The remainder of a list when its head has been removed is called thetail of the list.#{Key1=>Value1,...,KeyN=>ValueN}.Two forms ofsyntactic sugar are provided:
[99,97,116].[26]Erlang is designed with a mechanism that makes it easy for external processes to monitor for crashes (or hardware failures), rather than an in-process mechanism likeexception handling used in many other programming languages. Crashes are reported like other messages, which is the only way processes can communicate with each other,[27] and subprocesses can be spawned cheaply (seebelow). The "let it crash" philosophy prefers that a process be completely restarted rather than trying to recover from a serious failure.[28] Though it still requires handling of errors, this philosophy results in less code devoted todefensive programming where error-handling code is highly contextual and specific.[27]
A typical Erlang application is written in the form of a supervisor tree. This architecture is based on a hierarchy of processes in which the top level process is known as a "supervisor". The supervisor then spawns multiple child processes that act either as workers or more, lower level supervisors. Such hierarchies can exist to arbitrary depths and have proven to provide a highly scalable and fault-tolerant environment within which application functionality can be implemented.
Within a supervisor tree, all supervisor processes are responsible for managing the lifecycle of their child processes, and this includes handling situations in which those child processes crash. Any process can become a supervisor by first spawning a child process, then callingerlang:monitor/2 on that process. If the monitored process then crashes, the supervisor will receive a message containing a tuple whose first member is the atom'DOWN'. The supervisor is responsible firstly for listening for such messages and for taking the appropriate action to correct the error condition.
Erlang's main strength is support forconcurrency. It has a small but powerful set of primitives to create processes and communicate among them. Erlang is conceptually similar to the languageoccam, though it recasts the ideas ofcommunicating sequential processes (CSP) in a functional framework and uses asynchronous message passing.[29] Processes are the primary means to structure an Erlang application. They are neitheroperating systemprocesses northreads, butlightweight processes that are scheduled by BEAM. Like operating system processes (but unlike operating system threads), they share no state with each other. The estimated minimal overhead for each is 300words.[30] Thus, many processes can be created without degrading performance. In 2005, a benchmark with 20 million processes was successfully performed with 64-bit Erlang on a machine with 16 GBrandom-access memory (RAM; total 800 bytes/process).[31] Erlang has supportedsymmetric multiprocessing since release R11B of May 2006.
Whilethreads need external library support in most languages, Erlang provides language-level features to create and manage processes with the goal of simplifying concurrent programming. Though all concurrency is explicit in Erlang, processes communicate usingmessage passing instead of shared variables, which removes the need for explicitlocks (a locking scheme is still used internally by the VM).[32]
Inter-process communication works via ashared-nothingasynchronousmessage passing system: every process has a "mailbox", aqueue of messages that have been sent by other processes and not yet consumed. A process uses thereceive primitive to retrieve messages that match desired patterns. A message-handling routine tests messages in turn against each pattern, until one of them matches. When the message is consumed and removed from the mailbox the process resumes execution. A message may comprise any Erlang structure, including primitives (integers, floats, characters, atoms), tuples, lists, and functions.
The code example below shows the built-in support for distributed processes:
% 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 RemoteNodeRemoteProcess=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 processreceivea_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.
As the example shows, processes may be created on remote nodes, and communication with them is transparent in the sense that communication with remote processes works exactly as communication with local processes.
Concurrency supports the primary method of error-handling in Erlang. When a process crashes, it neatly exits and sends a message to the controlling process which can then take action, such as starting a new process that takes over the old process's task.[33][34]
The officialreference implementation of Erlang usesBEAM.[35] BEAM is included in the official distribution of Erlang, called Erlang/OTP. BEAM executesbytecode which is converted tothreaded code at load time. It also includes a native code compiler on most platforms, developed by the High Performance Erlang Project (HiPE) atUppsala University. Since October 2001 the HiPE system is fully integrated in Ericsson's Open Source Erlang/OTP system.[36] It also supports interpreting, directly from source code viaabstract syntax tree, via script as of R11B-5 release of Erlang.
Erlang supports language-levelDynamic Software Updating. To implement this, code is loaded and managed as "module" units; the module is acompilation unit. The system can keep two versions of a module in memory at the same time, and processes can concurrently run code from each. The versions are referred to as the "new" and the "old" version. A process will not move into the new version until it makes an external call to its module.
An example of the mechanism of hot code loading:
%% 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 versionend.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 atomcode_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 thecounter 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 asfree 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 databaseMnesia, forms the OTP collection of libraries. Ericsson and a few other companies support Erlang commercially.
Since the open source release, Erlang has been used by several firms worldwide, includingNortel andDeutsche Telekom.[37] Although Erlang was designed to fill a niche and has remained an obscure language for most of its existence, its popularity is growing due to demand for concurrent services.[38][39]Erlang has found some use in fieldingmassively multiplayer online role-playing game (MMORPG) servers.[40]
{{cite book}}:|journal= ignored (help)Erlang is conceptually similar to the occam programming language, though it recasts the ideas of CSP in a functional framework and uses asynchronous message passing.
The largest user of Erlang is (surprise!) Ericsson. Ericsson use it to write software used in telecommunications systems. Many dozens of projects have used it, a particularly large one is the extremely scalable AXD301 ATM switch. Other commercial users listed as part of the FAQ include: Nortel, Deutsche Flugsicherung (the German nationalair traffic control organisation), and T-Mobile.
Virtually all language use shared state concurrency. This is very difficult and leads to terrible problems when you handle failure and scale up the system...Some pretty fast-moving startups in the financial world have latched onto Erlang; for example, the Swedish www.kreditor.se.
I do not believe that other languages can catch up with Erlang anytime soon. It will be easy for them to add language features to be like Erlang. It will take a long time for them to build such a high-quality VM and the mature libraries for concurrency and reliability. So, Erlang is poised for success. If you want to build a multicore application in the next few years, you should look at Erlang.
| International | |
|---|---|
| National | |
| Other | |
