add site
services
publishers
database
health videos
toolbar
stats
live show
health store
more stuff
JOIN/LOGIN
| advertise add site services publishers database health videos
| | about toolbar stats live show health store more stuff JOIN/LOGIN |
Preschool Language Program - Speech-Language Pathology Program -... childrenshospital.org | Sign Language Program prenatalplus.com | Academics - Language Access Program tlcdeaf.org |
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. For concurrency it follows the Actor model. It was designed by Ericsson to support distributed, fault-tolerant, soft-real-time, non-stop applications. The first version was developed by Joe Armstrong in 1986.[1] It supports hot swapping so code can be changed without stopping a system.[2] Erlang was originally a proprietary language within Ericsson, but was released as open source in 1998. While threads are considered a complicated and error-prone topic in most languages, Erlang provides language-level features for creating and managing processes with the aim 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 locks.
[edit] HistoryThe name "Erlang", attributed to Bjarne Däcker, has been understood either as a reference to Danish mathematician and engineer Agner Krarup Erlang, or alternatively, as an abbreviation of "Ericsson Language".[1][3] Erlang was designed with the aim of improving the development of telephony applications. The initial version of Erlang was implemented in Prolog.[1] In 1998, the AXD301 switch was announced, containing over a million lines of Erlang, and reported to achieve a reliability of nine "9"s. Shortly thereafter, Erlang was banned within Ericsson Radio Systems for new products, citing a preference for non-proprietary languages. The implementation was open sourced at the end of the year.[1] The ban at Ericsson was eventually lifted, and Armstrong was re-hired by Ericsson in 2004.[4] In 2006, native symmetric multiprocessing support was added to the runtime system and virtual machine.[1] [edit] Functional languageA factorial 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) -> N * fac(N-1). % Recursively determine, then return the result % (note the period . meaning 'endif' or 'function end') A quicksort algorithm implementation: %% quicksort:quicksort(List) %% Sort a list of items -module(quicksort). % This is the file 'quicksort.erl' -export([quicksort/1]). % A function 'quicksort' with 1 parameter is exported (no type, no name) quicksort([]) -> []; % If the list [] is empty, return an empty list (nothing to sort) quicksort([Pivot|Rest]) -> % Compose recursively a list with 'Front' % from 'Pivot' and 'Back' from 'Rest' quicksort([Front || Front <- Rest, Front < Pivot]) ++ [Pivot] ++ quicksort([Back || Back <- Rest, Back >= Pivot]). The above example recursively invokes the function A compare function can be used, however, if the order on which Erlang bases its return value ( 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 of the type and name) -export([by_length/1]). by_length(Lists) -> % Use 'qsort/2' and provides an anonymous function as parameter (!!!) qsort(Lists, fun(A,B) when is_list(A), is_list(B) -> length(A) < length(B) end). qsort([], _)-> []; % If list is empty, return an empty list (discard the second parameter) qsort([Pivot|Rest], Smaller) -> qsort([X || X <- Rest, Smaller(X,Pivot)], Smaller) % Concatenate 'X' from 'Rest' ++ [Pivot] ++ % Use the anonymous fun (here named 'Smaller') to test the 'Pivot' qsort([Y ||Y <- Rest, not(Smaller(Y, Pivot))], Smaller). % Concatenate 'Y' from 'Rest' [edit] Concurrency and distribution oriented languageErlang's main strength 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. Erlang processes are neither operating system processes nor operating system threads, but lightweight processes somewhat similar to Java's original “green threads”. Like operating system processes (and unlike green threads and operating system threads) they have no shared state between them. The estimated minimal overhead for each is 300 words, so many of them can be created without degrading performance: a benchmark with 20 million processes has been successfully performed[5]. Erlang has supported symmetric multiprocessing since release R11B of May 2006. Process communication is done 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 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 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. 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 is done 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 take action. This way of error handling may increase maintainability and reduce complexity of code. [edit] ImplementationThe Ericsson Erlang implementation primarily runs interpreted virtual machine bytecode, but it also includes a native code compiler on most platforms, developed by the High Performance Erlang Project (HiPE)[6] at Uppsala University. It also supports interpretation, directly from source code via abstract tree, via script as of R11B-5. This is also used for example in Erlang shell. [edit] Hot code loading and modulesCode 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 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 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([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 atom 'code_switch' will the loop execute an external call to codeswitch/1 ( 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 a tricky subject, code needs to be written to make use of Erlang's facilities. [edit] DistributionEricsson released Erlang as open source 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, forms the Open Telecom Platform (OTP) collection of libraries. Ericsson and a few other companies offer commercial support for Erlang. Since it was released as open source in 1998, Erlang has been used by several companies worldwide, including Nortel and T-Mobile.[7] 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.[8][9] Erlang is available for several Unix-like operating systems, including Mac OS X, and for Microsoft Windows. [edit] Projects using ErlangProjects using Erlang include:
[edit] ClonesErlang has inspired several clones of its concurrency facilities for other languages:
[edit] History
[edit] Further reading
[edit] References
[edit] External links
| |||||||||||||||||||||||||||
| ↑ top of page ↑ | about thumbshots |
