Erlang

Amir SalimiMoi VanJon Paik

Contents• Introduction• History• Design and Purpose• Distribution• Projects• Clones• Features• Sample Code• Compilation• Tuples and Atoms• Lists• Concurrency• Processes• Message passing• Telephony

Introduction

• The sequential subset is a Functional Language.

• A concurrent programming language and runtime system (follows the actor model).

• Multi-Paradigm (provides a framework in which programmers can work in a variety of styles, freely intermixing constructs from different paradigms).

Design and Purpose

• Initial Version was coded in Prolog (logic programming).

• Designed to Improve the development of telephony applications.

• The Ericsson Erlang implementation primarily runs interpreted virtual machine code, but it also includes a native code compiler.

History

• Joe Armstrong designed the 1st version in 1986.

• Bjarne Däcker.• Agner Krarup Erlang.• "Ericsson Language."

Distribution

• Ericsson released Erlang as open source – Independence from a single vendor.– Increase awareness about the language.

• Erlang, together with libraries and the real-time distributed database Mnesia, forms the Open Telecom Platform (OTP) collection of libraries.

• Nortel• T-Mobile

Erlang Projects• Yahoo! Delicious• ejabberd - an XMPP instant messaging server • Wings 3D - a 3D modeller • the Yaws web server • Twitterfall - a service to view trends and patterns from

Twitter• Nitrogen - an event-driven web framework with

support for Web 2.0 features • The Facebook Chat system• Apache CouchDB - a distributed document-oriented

database

Erlang Inspired Concurrency Facilities

• C#: Retlang• Python: Candygram • JavaScript: Er.js • Lisp: Termite Scheme, erlang-in-lisp, CL-MUPROC,

Distel • PHP: PHP/Erlang • Ruby: Erlectricity • Scala • Reia

Features

• Hot Swapping.• Pattern matching allows for extremely

compact and clear programs.• Interfaces to other programming languages,

such as C, C++ and Java, are provided.

Features

• Erlang comes with design patterns or templates for client-server design, state machines, event distribution, and thread supervision.

• Erlang provides a framework that supports distribution of programs across a pool of servers, with automatic recovery and redistribution whenever a server fails.

Features

• It also includes powerful components for a network systems including an HTTP server, a Simple Network Management Protocol (SNMP) agent, a Common Object Request Broker Architecture (CORBA) interface, an OAM subsystem, and a fully distributed database engine.

Features

• Erlang's bytecode is identical on all platforms, and a network of Erlang nodes may consist of any mix of NT, UNIX, or other supported platforms.

• Erlang programs are able to handle much more load than any other languages out there, which is perfect for telephone company switches.

Sample Code-module(sample).            %module name

-export([double/1]).        %exported function

 

double(X) → 2 * X.          %function code

• The 1st line is the module name, which is the same

as the file name (ex. modulename.erl).• The 2nd line is exporting the function of the module.• The 3rd line is the function code itself. • X is a variable.

Compilation

• Type in “c(module_name).“ in the shell.• To compile top code “c(sample).”• Should get “{ok,sample}”, if not then there's

error in your code.• To run program type in

“module_name:function_name(arguments).”• To run top program “sample:double(10).” This

will return 20.

Factorial-module(fact).               %module name-export([fac/1, mult/2]).     %2 exported functions fac(1) ->   1;                %return 1 if fac(1)fac(N) ->   N * fac(N – 1).   %recursive calls mult(X, Y) ->   X * Y.        %return X * Y

• Has 2 functions in it: fac and mult • fac(1) acts like an if statement in C and Java• ; means there is more to that function• mult/2 takes in 2 arguments, therefore X & Y.

Fibonacci-module(fib).-export([fib/1]). fib(0) -> 0;fib(1) -> 1;fib(N) -> fib(N-1) + fib(N-2).

• Return the fibonacci number• fib:fib(5) returns 5• fib:fib(6) returns 8• fib:fib(10) returns 55

Tuples and Atoms-module(tup).-export([convert_length/1]). convert_length({centimeter, X}) ->   {inch, X / 2.54};convert_length({inch, Y}) ->    {centimeter, Y * 2.54}.

• Atoms are centimeter and inch

– Simply just names– Does not contains value

• Tuples are {centimeter, X} and {inch, Y}– Always enclosed in { }– Consider as one variable

Why Tuples?-module(con).-export([convert/2]). convert(M, inch) ->    M / 2.54;convert(N, centimeter) ->    N * 2.54. • Running command con:convert(3, inch). will return 1.181102...

– Is 3 in inches or centimeters?– confusing

• Running command tup:convert_length({inch, 5}). will return {centimeter,12.7}– 5 inches convert into 12.7 centimeters

• It is a way to group variables, so it's easier to understand.

Lists

• Lists in Erlang are surrounded by "[" and "]".• Example:

• [ 1, 2, 3, 4, 5 ] or [ { 1, blue }, { 2, red }, { 3, yellow } ]

• The | is used to separate the list.• Example: [ First | TheRest ] = [ 1, 2, 3, 4 ]

– First = 1– TheRest = [ 2, 3, 4 ]

List Code-module(list).

-export([list_length/1]).

 

list_length([]) ->    0;   

list_length([First | Rest]) -> 1 + list_length(Rest).

• list:list_length([1,2,3,4]). will return 4 • List is comparable to array and link list in other

programming language.

Concurrency in Erlang

• Erlang’s main strength is its support for concurrency.

• All concurrency is explicit in Erlang.• Processes communicate using message

passing instead of shared variables.

Posix/Windows Processes

• Posix and Windows thread implementations are designed to support statically typed languages that have no garbage collection information, so they cannot move or resize stacks (they don’t know where the pointers are and can’t fix them.)

• The programmer has to say how big the stacks will be, and have to overestimate with a large safety factor or else the program will not run.

Erlang Processes

• Erlang processes are neither operating system processes nor operating system threads

• Erlang processes do keep around enough garbage collection information to fix the necessary pointers whenever a stack has to be moved or resized

• The programmer never has to make a guess about how big to make a stack

• Stacks can start very small in size

Process Switching

• Posix and Windows thread implementations need the help of the OS for several operations, such as context switches.

• Context switches are very bad for caches; a context switch can mess up a cache to the point where it takes thousands of instructions to recover

• Erlang processes are green threads – no kernel memory is needed for an Erlang process, and all process switching is done by the application.

Erlang vs. Java

• Java is an imperative programming language; computation is done by accessing mutable shared objects

• Erlang requires no locking for routine calculations, ie, no mutex or any semaphores

Processes

Pid2 = spawn(Mod, Func, Args)

Processes

Pid2 = spawn(Mod, Func, Args)

Pid2 is process identifier of the new process - this is known only to process Pid1.

Message Passing

• Processes are isolated, no process can access another process's data in any way, so there is no need for locking (semaphores, mutexes) for routine calculations. (Saves time)

• The only permissible way to exchange information is message passing.

• This simplifies writing thread “safe” code.

Message Passing

self() - returns the Process Identity (Pid) of the process executing this function.From and Msg become bound when the message is received. Messages can carry data.

Message Passing

Messages can carry data and be selectively unpacked. The variables A and D become bound when receiving the message.

If A is bound before receiving a message then only data from this process is accepted.

Selective Message Reception

The message foo is received, then the message bar – irrespective of the order in which they were sent.

Selection of Any Message

The first message to arrive at the process C will be processed – the variable Msg in the process C will be bound to one of the atoms foo or bar depending on which arrives first.

Telephony

ringing_a(A, B) -> receive

{A, on_hook} -> A ! {stop_tone, ring}, B ! terminate, idle(A);

{B, answered} -> A ! {stop_tone, ring}, switch ! {connect, A, B}, conversation_a(A, B)

end.

Client Server Model

Timeouts

If the message foo is received from A within the time Time perform Actions1 otherwise perform Actions2.

Uses of Timeoutssleep(T)- process suspends for T ms.

sleep(T) -> receive after

T -> true

end.

suspend() - process suspends indefinitely.

suspend() -> receive after

infinity -> true

end.

Conclusion

• Erlang is a concurrent functional language designed to improve the development of telephony applications.

• It runs fast and the code is compact and easy to read.

• It is becoming more popular due to the arising need for concurrent programming.

Erlang

Amir SalimiMoi VanJon Paik