The Erlang Programming Language

© ThoughtWorks 2008

The Erlang Programming Language

Dennis Byrne - [email protected]

http://notdennisbyrne.blogspot.com/



Introduction

• Not a “shiny new object (or function)”• Open sourced by Ericsson• Functional Programming• Concurrency• Reliability• ThoughtWorks ! Erlang

Erlang is a functional programming language, with native constructs for concurrency and reliability.


A Totally “Unbiased” Comparison

In Erlang: List = [1,2,3,4,5]. Doubled = lists:map( fun(I) -> I * 2 end, List).

In Java: List<Integer> list = new LinkedList<Integer>() {{

add(1); add(2); add(3); add(4); add(5); }}; List<Integer> doubled = new ArrayList<Integer>();

for(Integer integer : list) {doubled.add(integer.intValue() * 2);

}


Single Assignment & Unification

I = 4. % assignmentI = 4. % unificationI = I. % unification4 = I. % unificationI = 5. % throws error :(


Pattern Matching

1> MyList = [“A”]. % declaring a list2> [Var] = MyList. % implicit declaration 3> io:format(Var). % prints “A”

1> MyList = [“A”, “B”]. % declaring a list2> [_, Var] = MyList. % _ is ignored3> io:format(Var). % prints B


Functions as First Class Citizens

1> Msg = "I am scoped".2> F = fun()->

io:format(Msg)end.

3> F(). % prints “I am scoped”


Tail Recursion

Tail recursion is to ‘recursion’ as optimistic locking is to ‘locking’.

loop() ->io:format(“in constant space”),

loop().

• Automatic byte code manipulation• Last call optimization


Pop Quiz: Evaluation Strategies

f( a(), b() )

• Order of evaluation• Lazy or strict?• Left, right, both, neither?


State Erlang avoids complex solutions in favor of

simple ways to avoid the problem

• State is immutable w/ single assignment• State is private, passed by value• Changing Perspectives

– Contention vs. Scale– Side Effects vs. Scale


Erlang Process

• An Erlang process combines the best of– An operating system process– An operating system thread– A “green thread”

• Controlled in user space by the ERTS• Costs less than 300 bytes

– Private heap– Private stack

• All processes are created equal• Incremental garbage collection


The Actor Model

• Asynchronous Message passing• Messages passed by value, not reference• One to one relationship

– An Actor– A mailbox– A Process– A Process ID, or pid


Concurrency Primitives: spawn

A built in function used to create a process.

Pid = spawn(Node, Module, Function, Args)


Another “Unbiased” Comparison

In Erlang: Pid = spawn(fun() -> io:format(“hello world”) end).

In Java:Thread thread = new Thread() {

public void run() { System.out.println("Hello World");

} }.start();


Concurrency Primitives: send

!


Concurrency Primitives: send

The send operator passes a message to a process. It is “fire and forget”.

Pid ! Msg


Concurrency Primitives: receive

receivePattern1 [ when Guard1 ] ->

dosomething().Pattern2 [ when Guard2 ] ->

dosomethingelse().end


Reliability

• catch• try• Monitor

– monitor_node(Node, Bool)– Unidirectional

• Link– Pid = spawn_link(Node, Module, Fun, Args)– Bi-directional


The Opposite of Ruby

Erlang Ruby

Orientation Functional Object

Syntax Ugly Beautiful

Concurrent Good Bad

Track Record Back end Front end

Execution Model Compiled Interpreted


Erlang Servers and Frameworks

• Mnesia – distributed database• YAWS – “yet another web server”• ErlyWeb – MVC web framework• EUnit• Jungerl – third party libraries• Perferl ( http://code.google.com/p/perferl )


The Erlang Programming Language

Dennis Byrne - [email protected]



The Erlang Programming Language

Technology

Transcript of The Erlang Programming Language