Erlang



Erlang is a general-purpose concurrent programming language and runtime system. The sequential subset of Erlang is a functional language, with strict evaluation, single assignment, and dynamic typing. It was designed by Ericsson to support distributed, fault-tolerant, soft-real-time, non-stop applications. It supports hot swapping so code can be changed without stopping a system. Erlang was originally a proprietary language within Ericsson, but was released as open source in 1998. The Ericsson implementation is primarily interpreted, but also includes a compiler called HiPE (not supported on all platforms).

Creating and managing processes is trivial in Erlang, whereas threads are considered a complicated and error prone topic in most languages. In Erlang, all concurrency is explicit.

Erlang is named after A. K. Erlang. It is sometimes thought that its name is an abbreviation of ERicsson LANGuage, owing to its heavy use inside Ericsson. According to Bjarne D├Ącker who headed the Computer Science Lab at the time, this duality is intentional.

Code looks like this:

-module(fact).
-export([fac/1]).

fac(0) -> 1;
fac(N) when N > 0 -> N * fac(N-1).

Below is an implementation of a Quicksort algorithm.

%% quicksort:qsort(List)
%% Sort a list of items
-module(quicksort).
-export([qsort/1]).

qsort([]) -> [];
qsort([Pivot|Rest]) ->
qsort([ X || X <- Rest, X < Pivot]) ++ [Pivot] ++ qsort([ Y || Y <- Rest, Y >= Pivot]).

The above example recursively calls the function qsort until there is no more to be sorted. The expression [ X || X <- Rest, X < Pivot] can be read as "Choose all X where X is a member of Rest and X is less than Pivot", resulting in a very easy way of handling Lists. Since you can evaluate any boolean expression between two different datatypes, the evaluation is straightforward: for example, 1 < a will return true.

However, a compare function can be used if the order on which Erlang bases its return value (true or false) needs to be changed. For example, if we would want an ordered list where a < 1 evaluates true.

The following code would sort lists according to length:

-module(listsort).
-export([by_length/1]).

by_length(Lists) ->
F = fun(A,B) when is_list(A), is_list(B) ->
length(A) < length(B)
end,
qsort(Lists, F).

qsort([], _) -> [];
qsort([Pivot|Rest], Smaller) ->
qsort([ X || X <- Rest, Smaller(X, Pivot)], Smaller)
++ [Pivot] ++
qsort([ Y || Y <- Rest, not(Smaller(Y, Pivot))], Smaller).

The main strength of Erlang is support for concurrency. It has a small but powerful set of primitives to create processes and communicate between them. Processes are the primary means to structure an Erlang application. It should also be noted that Erlang processes are neither OS processes nor OS threads, they are lightweight threads somewhat similar to Java's "green threads". As a result, Erlang processes are extremely lightweight (the estimated minimal overhead of an Erlang process is 300 bytes) and a very large number of them can be created without performance degradation (a benchmark with 20 million processes was tried). Since release R11B (May 2006) Erlang implements support for symmetric multiprocessing.

Communication between processes in Erlang is done via a share-nothing asynchronous message-passing system: every Erlang process has a mailbox in which the messages sent by other processes are stored until consumed. Erlang threads then use the receive primitive to retrieve messages. Message retrieval is done through pattern-matching (the message-handling routine tests the first message against each pattern, then the second, and so forth until one of them matches against a pattern). As the message is consumed (removed from the mailbox queue), the thread resumes execution. Any Erlang structure can be used as a message, which include Erlang primitives (integers, floats, characters, atoms), tuples, lists or even functions.

Code examples:

Pid = spawn(Mod, Func, Args) % execute function Func as new process
Pid = spawn(Node, Mod, Func, Args) % execute function Func in remote node Node

Pid ! a_message % send message to the process (asynchronously)

receive % receive message sent to this process
a_message -> do_something;
{data, Data_content} -> do_something_else(); % This is a tuple of a type atom and some data
{hello, Text} -> io:format("Got hello message: ~s", [Text]);
{goodbye, Text} -> io:format("Got goodbye message: ~s", [Text])
end.

There is also built-in support for distributed processes. Processes may be created on remote nodes, and communication with them is transparent (i.e. the communication with remote processes is done exactly as the 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 who can take action. This way of error handling may increase maintainability and reduce complexity of code.

Erlang was released by Ericsson as open-source to ensure its independence from a single vendor and to increase awareness of the language. Distribution of the language together with libraries and real-time distributed database (Mnesia) is known as the Open Telecom Platform, or OTP. Ericsson and a few other companies offer commercial support for Erlang.

Since taking the open-source path in 1998, it became used by several companies world-wide, including Nortel and T-Mobile. However, it hasn't yet become a wide-spread mainstream programming language.

As of 2006, Erlang is under active development with regular releases. It is available for several Unix-like operating systems and Microsoft Windows.Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts.
Virtual Magic is a human knowledge database blog. Text Based On Information From Wikipedia, Under The GNU Free Documentation License. Copyright (c) 2007 Virtual Magic. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts and no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".

Links to this post:

Create a Link

<< Home