Jump to content

Erlang (programming language): Difference between revisions

From Wikipedia, the free encyclopedia
Browse history interactively
← Previous editNext edit →
Content deleted Content added
VisualWikitext
Renku (talk | contribs)
77 edits
+ link to Estonian wiki
Untalker (talk | contribs)
104 edits
history
Line 223: Line 223:
*[[Scala (programming language)|Scala]]
*[[Scala (programming language)|Scala]]
*[[Scheme (programming language)|Scheme]]: [http://code.google.com/p/termite/ Termite Scheme]
*[[Scheme (programming language)|Scheme]]: [http://code.google.com/p/termite/ Termite Scheme]

==History==
According to Jörg Mittag <ref>[http://stackoverflow.com/questions/2409494/some-solid-oop-criticism Some solid OOP criticism?]Stackoverflow. Retrieved April 3, 2010.</ref>:

:Carl Hewitt, who invented the Actor Model, based it on Smalltalk-71. Alan Kay, who invented Smalltalk-71 based it on Planner, which in turn was also invented by Carl Hewitt. The designers of Erlang didn't actually know about the Actor Model (Joe Armstrong only learned about it many years later, when he was writing his thesis about the design of Erlang), they based the design of Erlang on Prolog, which in turn is based on - surprise - Carl Hewitt's Planner.
:The designers of Erlang also based their design on the requirements of the telco industry: resiliency, dependability, no single point of failure, evolvability. Incidentally, those are also the attributes of an evolutionary successful organism, and guess what: Alan Kay actually has a degree in microbiology and based the design of Smalltalk on the way cells communicate with each other and form complex organisms from very simple structures.


== References ==
== References ==

Revision as of 16:22, 3 April 2010

Erlang
Paradigmmulti-paradigm: concurrent, functional
Designed byEricsson
DeveloperEricsson
First appeared1986
Stable release
R13B04 / February 24, 2010 (2010-02-24)
Typing disciplinedynamic, strong
LicenseModified MPL
Websitewww.erlang.org
Major implementations
Erlang
Influenced by
Prolog
Influenced
Clojure, Scala

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 thus 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.

History

The 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 Ericsson 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][clarification needed]

In 2006, native symmetric multiprocessing support was added to the runtime system and virtual machine.[1]

Functional language

A 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 quicksort until nothing remains to be sorted. The expression [Front || Front <- Rest, Front < Pivot] is a list comprehension, meaning “Construct a list of elements Front such that Front is a member of Rest, and Front is less than Pivot”.

A compare function can be used, however, 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 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'

Here again, a Pivot is taken from the first parameter given to qsort() and the rest of Lists is named Rest. 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 elements X such that X is a member of Rest, and Smaller is true", with Smaller being defined earlier as

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

Note also that 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.

Concurrency and distribution orientation

Erlang's main strength is support for concurrency. It has a small but powerful set of primitives to create processes and communicate among 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, thus 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 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, [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.

Implementation

The 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 the Erlang shell.

Hot code loading and modules

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([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 (?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 required in the newer version. In our example we keep the state 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 a tricky subject; code needs to be written to make use of Erlang's facilities.

Distribution

In 1998, Ericsson 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 the open source release, Erlang has been used by several firms 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 many Unix-like operating systems, including Mac OS X, and for Microsoft Windows.

Projects using Erlang

Projects using Erlang include:

Clones

Erlang has inspired several clones of its concurrency facilities for other languages:

History

According to Jörg Mittag [17]:

Carl Hewitt, who invented the Actor Model, based it on Smalltalk-71. Alan Kay, who invented Smalltalk-71 based it on Planner, which in turn was also invented by Carl Hewitt. The designers of Erlang didn't actually know about the Actor Model (Joe Armstrong only learned about it many years later, when he was writing his thesis about the design of Erlang), they based the design of Erlang on Prolog, which in turn is based on - surprise - Carl Hewitt's Planner.
The designers of Erlang also based their design on the requirements of the telco industry: resiliency, dependability, no single point of failure, evolvability. Incidentally, those are also the attributes of an evolutionary successful organism, and guess what: Alan Kay actually has a degree in microbiology and based the design of Smalltalk on the way cells communicate with each other and form complex organisms from very simple structures.

References

  1. ^ a b c d e Joe Armstrong, "History of Erlang", in HOPL III: Proceedings of the third ACM SIGPLAN conference on History of programming languages, 2007, ISBN 978-1-59593-766-X
  2. ^ Joe Armstrong, Bjarne Däcker, Thomas Lindgren, Håkan Millroth. "Open-source Erlang - White Paper". Retrieved 2008-01-23.{{cite web}}: CS1 maint: multiple names: authors list (link)
  3. ^ Erlang, the mathematician?
  4. ^ Joe Armstrong, question about Erlang's future, erlang-questions mailing list (July 6, 2006).
  5. ^ Ulf Wiger (2005-11-14). "Stress-testing erlang". comp.lang.functional.misc. Retrieved 2006-08-25.
  6. ^ "High Performance Erlang". Retrieved 2008-03-23.
  7. ^ "Who uses Erlang for product development?". Frequently asked questions about Erlang. Retrieved 2007-07-16. The largest user of Erlang is (surprise!) Ericsson. Ericsson use it to write software used in telecommunications systems. Many dozens 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 national air traffic control organisation), and T-Mobile.
  8. ^ "Programming Erlang". Retrieved 2008-12-13. 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.
  9. ^ "Erlang, the next Java". Retrieved 2008-10-08. 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.
  10. ^ http://www.facebook.com/note.php?note_id=16787213919&id=9445547199&index=2
  11. ^ http://developers.facebook.com/news.php?blog=1&story=110
  12. ^ http://twitter.com/jalada/status/1206606823
  13. ^ http://twitter.com/jalada/statuses/1234217518
  14. ^ http://blog.socklabs.com/2008/09/erlang_is_delicious_cufp_slide
  15. ^ What You Need To Know About Amazon SimpleDB
  16. ^ http://github.com/blog/112-supercharged-git-daemon
  17. ^ Some solid OOP criticism?Stackoverflow. Retrieved April 3, 2010.

Further reading

Wikibooks has a book on the topic of: Erlang Programming
Retrieved from "https://en.wikipedia.org/w/index.php?title=Erlang_(programming_language)&oldid=353747306"