HOME

TheInfoList



OR:

Erlang ( ) is a general-purpose, concurrent, functional programming language, and a garbage-collected runtime system. The term Erlang is used interchangeably with Erlang/OTP, or
Open Telecom Platform OTP is a collection of useful middleware, libraries, and tools written in the Erlang programming language. It is an integral part of the open-source distribution of Erlang. The name OTP was originally an acronym for Open Telecom Platform, which w ...
(OTP), which consists of the Erlang runtime system, several ready-to-use components (OTP) mainly written in Erlang, and a set of
design principles A design is a plan or specification for the construction of an object or system or for the implementation of an activity or process or the result of that plan or specification in the form of a prototype, product, or process. The verb ''to design'' ...
for Erlang programs. The Erlang runtime system is designed for systems with these traits: * Distributed * Fault-tolerant *
Soft real-time Real-time computing (RTC) is the computer science term for hardware and software systems subject to a "real-time constraint", for example from event to system response. Real-time programs must guarantee response within specified time constrai ...
* Highly available, non-stop applications * Hot swapping, where code can be changed without stopping a system. The Erlang programming language has
immutable In object-oriented and functional programming, an immutable object (unchangeable object) is an object whose state cannot be modified after it is created.Goetz et al. ''Java Concurrency in Practice''. Addison Wesley Professional, 2006, Section 3.4 ...
data,
pattern matching In computer science, pattern matching is the act of checking a given sequence of tokens for the presence of the constituents of some pattern. In contrast to pattern recognition, the match usually has to be exact: "either it will or will not be ...
, and
functional programming In computer science, functional programming is a programming paradigm where programs are constructed by applying and composing functions. It is a declarative programming paradigm in which function definitions are trees of expressions that ...
. The sequential subset of the Erlang language supports eager evaluation, single assignment, and
dynamic typing In computer programming, a type system is a logical system comprising a set of rules that assigns a property called a type to every "term" (a word, phrase, or other set of symbols). Usually the terms are various constructs of a computer progra ...
. A normal Erlang application is built out of hundreds of small Erlang processes. It was originally
proprietary software Proprietary software is computer software, software that is deemed within the free and open-source software to be non-free because its creator, publisher, or other rightsholder or rightsholder partner exercises a legal monopoly afforded by modern ...
within
Ericsson (lit. "Telephone Stock Company of LM Ericsson"), commonly known as Ericsson, is a Sweden, Swedish multinational networking and telecommunications company headquartered in Stockholm. The company sells infrastructure, software, and services in ...
, developed by Joe Armstrong, Robert Virding, and Mike Williams in 1986, but was released as free and open-source software in 1998. Erlang/OTP is supported and maintained by the Open Telecom Platform (OTP) product unit at
Ericsson (lit. "Telephone Stock Company of LM Ericsson"), commonly known as Ericsson, is a Sweden, Swedish multinational networking and telecommunications company headquartered in Stockholm. The company sells infrastructure, software, and services in ...
.


History

The name ''Erlang'', 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 engineer Agner Krarup Erlang and a
syllabic abbreviation An abbreviation (from Latin ''brevis'', meaning ''short'') is a shortened form of a word or phrase, by any method. It may consist of a group of letters or words taken from the full version of the word or phrase; for example, the word ''abbrevia ...
of "Ericsson Language". Erlang was designed with the aim of improving the development of telephony applications. The initial version of Erlang was implemented in
Prolog Prolog is a logic programming language associated with artificial intelligence and computational linguistics. Prolog has its roots in first-order logic, a formal logic, and unlike many other programming languages, Prolog is intended primarily a ...
and was influenced by the programming language PLEX 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 the BEAM virtual machine (VM) which compiles Erlang to C using a mix of natively compiled code and threaded code to strike a balance between performance and disk space. According to co-inventor Joe Armstrong, the language went from lab product to real applications following the collapse of the next-generation AXE telephone exchange named ''AXE-N'' in 1995. As a result, Erlang was chosen for the next
Asynchronous Transfer Mode Asynchronous Transfer Mode (ATM) is a telecommunications standard defined by American National Standards Institute (ANSI) and ITU-T (formerly CCITT) for digital transmission of multiple types of traffic. ATM was developed to meet the needs o ...
(ATM) exchange ''AXD''. In February 1998, Ericsson Radio Systems banned the in-house use of Erlang for new products, citing a preference for non-proprietary languages. The ban caused Armstrong and others to make plans to leave Ericsson. In March 1998 Ericsson announced the AXD301 switch, containing over a million lines of Erlang and reported to achieve a
high availability High availability (HA) is a characteristic of a system which aims to ensure an agreed level of operational performance, usually uptime, for a higher than normal period. Modernization has resulted in an increased reliance on these systems. F ...
of nine "9"s. In December 1998, the implementation of Erlang was open-sourced and most of the Erlang team resigned to form a new company Bluetail AB. Ericsson eventually relaxed the ban and re-hired Armstrong in 2004. In 2006, native symmetric multiprocessing support was added to the runtime system and VM.


Processes

Erlang applications are built of very lightweight Erlang processes in the Erlang runtime system. Erlang processes can be seen as "living" objects (
object-oriented programming Object-oriented programming (OOP) is a programming paradigm based on the concept of " objects", which can contain data and code. The data is in the form of fields (often known as attributes or ''properties''), and the code is in the form of ...
), with data encapsulation and message passing, but capable of changing behavior during runtime. The Erlang runtime system provides strict process isolation between Erlang processes (this includes data and garbage collection, separated individually by each Erlang process) and transparent communication between processes (see Location transparency) on different Erlang nodes (on different hosts). Joe Armstrong, co-inventor of Erlang, summarized the principles of processes in his
PhD PHD or PhD may refer to: * Doctor of Philosophy (PhD), an academic qualification Entertainment * '' PhD: Phantasy Degree'', a Korean comic series * ''Piled Higher and Deeper'', a web comic * Ph.D. (band), a 1980s British group ** Ph.D. (Ph.D. albu ...
thesis A thesis ( : theses), or dissertation (abbreviated diss.), is a document submitted in support of candidature for an academic degree or professional qualification presenting the author's research and findings.International Standard ISO 7144 ...
: *Everything is a process. *Processes are strongly isolated. *Process creation and destruction is a lightweight operation. *Message passing is the only way for processes to interact. *Processes have unique names. *If you know the name of a process you can send it a message. *Processes share no resources. *Error handling is non-local. *Processes do what they are supposed to do or fail. Joe Armstrong remarked in an interview with Rackspace in 2013: "If
Java Java (; id, Jawa, ; jv, ꦗꦮ; su, ) is one of the Greater Sunda Islands in Indonesia. It is bordered by the Indian Ocean to the south and the Java Sea to the north. With a population of 151.6 million people, Java is the world's mo ...
is ' write once, run anywhere', then Erlang is 'write once, run forever'.”


Usage

In 2014,
Ericsson (lit. "Telephone Stock Company of LM Ericsson"), commonly known as Ericsson, is a Sweden, Swedish multinational networking and telecommunications company headquartered in Stockholm. The company sells infrastructure, software, and services in ...
reported Erlang was being used in its support nodes, and in GPRS, 3G and
LTE LTE may refer to: Science and technology * LTE (telecommunication) (Long-Term Evolution), a telephone and mobile broadband standard ** LTE Advanced, an enhancement *** LTE Advanced Pro * Compaq LTE, a line of laptop computers produced by Compaq * ...
mobile networks worldwide and also by Nortel and
T-Mobile T-Mobile is the brand name used by some of the mobile communications subsidiaries of the German telecommunications company Deutsche Telekom AG in the Czech Republic ( T-Mobile Czech Republic), Poland ( T-Mobile Polska), the United States ( T-Mob ...
. Erlang is used in RabbitMQ. As Tim Bray, director of Web Technologies at Sun Microsystems, expressed in his keynote at O'Reilly Open Source Convention (OSCON) in July 2008: Erlang is the programming language used to code
WhatsApp WhatsApp (also called WhatsApp Messenger) is an internationally available freeware, cross-platform, centralized instant messaging (IM) and voice-over-IP (VoIP) service owned by American company Meta Platforms (formerly Facebook). It allows user ...
. Elixir is a programming language that compiles into BEAM byte code (via Erlang Abstract Format). 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: Vocalink (a MasterCard company), Goldman Sachs, Nintendo, AdRoll, Grindr, BT Mobile,
Samsung The Samsung Group (or simply Samsung) ( ko, 삼성 ) is a South Korean multinational manufacturing conglomerate headquartered in Samsung Town, Seoul, South Korea. It comprises numerous affiliated businesses, most of them united under the ...
, OpenX, and
SITA Sita (; ) also called as Janaki and Vaidehi is a Hindu goddess and the female protagonist of the Hindu epic, '' Ramayana''. She is the consort of Rama, the avatar of the god Vishnu, and is regarded as a form of Vishnu's consort, Lakshmi ...
.


Functional programming examples


Factorial

A factorial algorithm implemented in Erlang: -module(fact). % This is the file 'fact.erl', the module and the filename must match -export( ac/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.


Fibonacci sequence

A tail recursive algorithm that produces the Fibonacci 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( ib/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 is passed precisely the integer 0, then return 0 fib(0) -> 0; %% 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; however, in this case we should explicitly %% prevent a situation that will crash Erlang's runtime engine fib(N) when N < 0 -> err_neg_val; %% If fib/1 is passed an integer less than 3, then return 1 %% The preceding two function signatures handle all cases where N < 1, %% so this function signature handles cases where N = 1 or N = 2 fib(N) when N < 3 -> 1; %% For all other values, call the private function fib_int/3 to perform %% the calculation fib(N) -> fib_int(N, 0, 1). %% --------------------------------------------------------------------- %% Private API %% --------------------------------------------------------------------- %% If fib_int/3 receives a 1 as its first argument, then we're done, so %% return the value in argument B. Since we are not interested in the %% value of the second argument, we denote this using _ to indicate a %% "don't care" value fib_int(1, _, B) -> B; %% For all other argument combinations, recursively call fib_int/3 %% where each call does the following: %% - decrement counter N %% - Take the previous fibonacci value in argument B and pass it as %% argument A %% - Calculate the value of the current fibonacci number and pass it %% as argument B fib_int(N, A, B) -> fib_int(N-1, B, A+B). Here's the same program without the explanatory comments: -module(series). -export( ib/1. fib(0) -> 0; fib(N) when N < 0 -> err_neg_val; fib(N) when N < 3 -> 1; fib(N) -> fib_int(N, 0, 1). fib_int(1, _, B) -> B; fib_int(N, A, B) -> fib_int(N-1, B, A+B).


Quicksort

Quicksort in Erlang, using
list comprehension A list comprehension is a syntactic construct available in some programming languages for creating a list based on existing lists. It follows the form of the mathematical ''set-builder notation'' (''set comprehension'') as distinct from the use of ...
: %% qsort:qsort(List) %% Sort a list of items -module(qsort). % This is the file 'qsort.erl' -export( sort/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 <- Rest, Front < Pivot ++ ivot++ qsort( , Back <- Rest, Back >= Pivot. The above example recursively invokes the function qsort until nothing remains to be sorted. The expression , Front <- Rest, Front < Pivot/code> is a
list comprehension A list comprehension is a syntactic construct available in some programming languages for creating a list based on existing lists. It follows the form of the mathematical ''set-builder notation'' (''set comprehension'') as distinct from the use of ...
, meaning "Construct a list of elements Front such that Front is a member of Rest, and Front is less than Pivot." ++ 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( y_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 <- Rest, Smaller(X,Pivot) Smaller) ++ ivot++ qsort( , Y <- Rest, not(Smaller(Y, Pivot)) Smaller). A Pivot is taken from the first parameter given to qsort() and the rest of Lists is named Rest. Note that the expression , X <- Rest, Smaller(X,Pivot)/syntaxhighlight> is no different in form from , Front <- Rest, Front < Pivot/syntaxhighlight> (in the previous example) except for the use of a comparison function in the last part, saying "Construct a list of elements X such that X is a member of Rest, and Smaller is true", with Smaller being defined earlier as fun(A,B) -> length(A) < length(B) end The anonymous function is named Smaller in the parameter list of the second definition of qsort so that it can be referenced by that name within that function. It is not named in the first definition of qsort, which deals with the base case of an empty list and thus has no need of this function, let alone a name for it.


Data types

Erlang has eight primitive data types: ;Integers: Integers are written as sequences of decimal digits, for example, 12, 12375 and -23427 are integers. Integer arithmetic is exact and only limited by available memory on the machine. (This is called
arbitrary-precision arithmetic In computer science, arbitrary-precision arithmetic, also called bignum arithmetic, multiple-precision arithmetic, or sometimes infinite-precision arithmetic, indicates that calculations are performed on numbers whose digits of precision are l ...
.) ;Atoms: Atoms are used within a program to denote distinguished values. They are written as strings of consecutive alphanumeric characters, the first character being lowercase. Atoms can contain any character if they are enclosed within single quotes and an escape convention exists which allows any character to be used within an atom. Atoms are never garbage collected and should be used with caution, especially if using dynamic atom generation. ;Floats: Floating point numbers use the IEEE 754 64-bit representation. ;References: References are globally unique symbols whose only property is that they can be compared for equality. They are created by evaluating the Erlang primitive make_ref(). ;Binaries: A binary is a sequence of bytes. Binaries provide a space-efficient way of storing binary data. Erlang primitives exist for composing and decomposing binaries and for efficient input/output of binaries. ;Pids: Pid is short for ''process identifier''a Pid is created by the Erlang primitive spawn(...) Pids are references to Erlang processes. ;Ports: Ports are used to communicate with the external world. Ports are created with the built-in function open_port. Messages can be sent to and received from ports, but these messages must obey the so-called "port protocol." ;Funs: Funs are function closures. Funs are created by expressions of the form: fun(...) -> ... end. And three compound data types: ;Tuples: Tuples are containers for a fixed number of Erlang data types. The syntax denotes a tuple whose arguments are D1, D2, ... Dn. The arguments can be primitive data types or compound data types. Any element of a tuple can be accessed in constant time. ;Lists: Lists are containers for a variable number of Erlang data types. The syntax Dt/code> denotes a list whose first element is Dh, and whose remaining elements are the list Dt. 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 the ''head'' of the list. The remainder of a list when its head has been removed is called the ''tail'' of the list. ;Maps: Maps contain a variable number of key-value associations. The syntax is#. Two forms of syntactic sugar are provided: ;Strings: Strings are written as doubly quoted lists of characters. This is syntactic sugar for a list of the integer
Unicode Unicode, formally The Unicode Standard,The formal version reference is is an information technology standard for the consistent encoding, representation, and handling of text expressed in most of the world's writing systems. The standard, ...
code points for the characters in the string. Thus, for example, the string "cat" is shorthand for 9,97,116/code>. ;Records: Records provide a convenient way for associating a tag with each of the elements in a tuple. This allows one to refer to an element of a tuple by name and not by position. A pre-compiler takes the record definition and replaces it with the appropriate tuple reference. Erlang has no method to define classes, although there are external libraries available.


"Let it crash" coding style

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 like exception handling used in many other programming languages. Crashes are reported like other messages, which is the only way processes can communicate with each other, and subprocesses can be spawned cheaply (see
below Below may refer to: *Earth * Ground (disambiguation) * Soil * Floor * Bottom (disambiguation) * Less than *Temperatures below freezing * Hell or underworld People with the surname * Ernst von Below (1863–1955), German World War I general * Fr ...
). The "let it crash" philosophy prefers that a process be completely restarted rather than trying to recover from a serious failure. Though it still requires handling of errors, this philosophy results in less code devoted to defensive programming where error-handling code is highly contextual and specific.


Supervisor trees

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 calling erlang: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 secondly, for taking the appropriate action to correct the error condition.


Concurrency and distribution orientation

Erlang's main strength is support for
concurrency Concurrent means happening at the same time. Concurrency, concurrent, or concurrence may refer to: Law * Concurrence, in jurisprudence, the need to prove both ''actus reus'' and ''mens rea'' * Concurring opinion (also called a "concurrence"), a ...
. It has a small but powerful set of primitives to create processes and communicate among them. Erlang is conceptually similar to the language occam, though it recasts the ideas of communicating sequential processes (CSP) in a functional framework and uses asynchronous message passing. Processes are the primary means to structure an Erlang application. They are neither
operating system An operating system (OS) is system software that manages computer hardware, software resources, and provides common daemon (computing), services for computer programs. Time-sharing operating systems scheduler (computing), schedule tasks for ef ...
processes A process is a series or set of activities that interact to produce a result; it may occur once-only or be recurrent or periodic. Things called a process include: Business and management *Business process, activities that produce a specific se ...
nor
threads Thread may refer to: Objects * Thread (yarn), a kind of thin yarn used for sewing ** Thread (unit of measurement), a cotton yarn measure * Screw thread, a helical ridge on a cylindrical fastener Arts and entertainment * ''Thread'' (film), 2016 ...
, but lightweight 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 300
words A word is a basic element of language that carries an objective or practical meaning, can be used on its own, and is uninterruptible. Despite the fact that language speakers often have an intuitive grasp of what a word is, there is no conse ...
. 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 GB
random-access memory Random-access memory (RAM; ) is a form of computer memory that can be read and changed in any order, typically used to store working data and machine code. A random-access memory device allows data items to be read or written in almost t ...
(RAM; total 800 bytes/process). Erlang has supported symmetric multiprocessing since release R11B of May 2006. While
threads Thread may refer to: Objects * Thread (yarn), a kind of thin yarn used for sewing ** Thread (unit of measurement), a cotton yarn measure * Screw thread, a helical ridge on a cylindrical fastener Arts and entertainment * ''Thread'' (film), 2016 ...
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 using message passing instead of shared variables, which removes the need for explicit locks (a locking scheme is still used internally by the VM). Inter-process communication works via a shared-nothing asynchronous message passing system: every process has a "mailbox", a queue of messages that have been sent by other processes and not yet consumed. A process uses the receive 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, ort, MaxConnections, % Create a remote process and invoke the function % web:start_server(Port, MaxConnections) on machine RemoteNode RemoteProcess = spawn(RemoteNode, web, start_server, ort, MaxConnections, % Send a message to ServerProcess (asynchronously). The message consists of a tuple % with the atom "pause" and the number "10". ServerProcess ! , % Receive messages sent to this process receive a_message -> do_something; -> handle(DataContent); -> io:format("Got hello message: ~s", ext; -> io:format("Got goodbye message: ~s", ext 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.


Implementation

The official reference implementation of Erlang uses BEAM. BEAM is included in the official distribution of Erlang, called Erlang/OTP. BEAM executes
bytecode Bytecode (also called portable code or p-code) is a form of instruction set designed for efficient execution by a software interpreter. Unlike human-readable source code, bytecodes are compact numeric codes, constants, and references (norma ...
which is converted to threaded code at load time. It also includes a native code compiler on most platforms, developed by the High Performance Erlang Project (HiPE) at
Uppsala University Uppsala University ( sv, Uppsala universitet) is a public research university in Uppsala, Sweden. Founded in 1477, it is the oldest university in Sweden and the Nordic countries still in operation. The university rose to significance durin ...
. Since October 2001 the HiPE system is fully integrated in Ericsson's Open Source Erlang/OTP system. It also supports interpreting, directly from source code via abstract syntax tree, via script as of R11B-5 release of Erlang.


Hot code loading and modules

Erlang supports language-level Dynamic Software Updating. To implement this, code is loaded and managed as "module" units; the module is a compilation 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( tart/0, codeswitch/1. start() -> loop(0). loop(Sum) -> receive -> loop(Sum+Count); -> Pid ! , loop(Sum); code_switch -> ?MODULE:codeswitch(Sum) % Force the use of 'codeswitch/1' from the latest 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( tart/0, codeswitch/1. start() -> loop(0). loop(Sum) -> receive -> loop(Sum+Count); reset -> loop(0); -> Pid ! , 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.


Distribution

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 Mnesia is a distributed computing, distributed, real-time computing, soft real-time database management system written in the Erlang (programming language), Erlang programming language. It is distributed as part of the Open Telecom Platform. De ...
, 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, including Nortel and
T-Mobile T-Mobile is the brand name used by some of the mobile communications subsidiaries of the German telecommunications company Deutsche Telekom AG in the Czech Republic ( T-Mobile Czech Republic), Poland ( T-Mobile Polska), the United States ( T-Mob ...
. 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. Erlang has found some use in fielding massively multiplayer online role-playing game (MMORPG) servers.


See also

* Elixir – a functional, concurrent, general-purpose programming language that runs on BEAM * Luerl - Lua on the BEAM, designed and implemented by one of the creators of Erlang. * Lisp Flavored Erlang (LFE) – a Lisp-based programming language that runs on BEAM * Mix (build tool) *
Phoenix (web framework) Phoenix is a web development framework written in the functional programming language Elixir. Phoenix uses a server-side model–view–controller (MVC) pattern. Based on thPluglibrary, and ultimately thCowboy Erlang framework, it was develop ...


References


Further reading

* *
Early history of Erlang
by Bjarne Däcker * * * * * * * *


External links

* {{Authority control Concurrent programming languages Cross-platform free software Declarative programming languages Dynamic programming languages Dynamically typed programming languages Ericsson Formerly proprietary software Functional languages Pattern matching programming languages Programming languages Programming languages created in 1986 Register-based virtual machines