Introduction Erlang Conclusion - theory.stanford.edump/mp/Teaching_files/2014-Erl.pdf · Introduction Erlang Conclusion Syntax and examples Concurrency in Erlang Let it crash Distribution

IntroductionErlang

Conclusion

CPL - Erlang

Marco Patrignani

KU Leuven

24 October 2014

Marco Patrignani CPL - Erlang 1/36

IntroductionErlang

Conclusion

Outline

1 IntroductionWhat, who, why, using Erlang?

2 ErlangSyntax and examplesConcurrency in ErlangLet it crashDistribution in Erlang

3 Conclusion

IntroductionErlang

ConclusionWhat, who, why, using Erlang?

Outline

3 Conclusion

IntroductionErlang

What is Erlang?

programming language +runtime system +OTP (libraries for DBs, FFIs ...)

Programming language:

functional (like )dynamically typed

(unlike )concurrentfault-tolerant

Runtime system:

garbage collector

(like )

IntroductionErlang

What is Erlang?

Runtime system:

garbage collector

(like )

IntroductionErlang

What is Erlang?

functional (like )

dynamically typed

Runtime system:

garbage collector

(like )

IntroductionErlang

What is Erlang?

(unlike )

concurrentfault-tolerant

Runtime system:

garbage collector

(like )

IntroductionErlang

What is Erlang?

(unlike )concurrent

fault-tolerant

Runtime system:

garbage collector

(like )

IntroductionErlang

What is Erlang?

Runtime system:

garbage collector

(like )

IntroductionErlang

What is Erlang?

Runtime system:

garbage collector

(like )

IntroductionErlang

What is Erlang?

Runtime system:

garbage collector

(like )

IntroductionErlang

Why using Erlang?

inherently concurrent programs:achieved via processes (no threads)

benefit from parallelisation (also thanks to SSA)

distributed programs on different machinesfault-tolerant systems:several mechanisms to recover faults without a system crashnon-stop applications:ability to load code at runtime

IntroductionErlang

Why using Erlang?

inherently concurrent programs:achieved via processes (no threads)benefit from parallelisation (also thanks to SSA)

IntroductionErlang

Why using Erlang?

distributed programs on different machines

fault-tolerant systems:several mechanisms to recover faults without a system crashnon-stop applications:ability to load code at runtime

IntroductionErlang

Why using Erlang?

distributed programs on different machinesfault-tolerant systems:several mechanisms to recover faults without a system crash

non-stop applications:ability to load code at runtime

IntroductionErlang

Why using Erlang?

IntroductionErlang

Why NOT using Erlang?

Poor support for frontends/GUIs

Not as supported as other languages (unlike )Not known / understood as other languages

(unlike or C) (like )

IntroductionErlang

Not as supported as other languages (unlike )

Not known / understood as other languages

IntroductionErlang

Not as supported as other languages (unlike )Not known / understood as other languages

IntroductionErlang

Who uses Erlang?

IntroductionErlang

Who uses Erlang?

IntroductionErlang

Conclusion

Syntax and examplesConcurrency in ErlangLet it crashDistribution in Erlang

Outline

3 Conclusion

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

Local_Var = 2 * Num,Avg = average([Num, Local_Var]),Sqr_Avg = math:sqrt(Avg),io:format("Result ~p. ~n",[Sqr_Avg]),

average( L ) ->

lists:foldr(fun(El, Acc)-> El + Acc end , 0, L).

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

average( L ) ->

module definition

IntroductionErlang

Conclusion

Functional code

-module(app) .

-export([func/1]).

func( Num )->

average( L ) ->

EVERYTHING ends with a dot “.”

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

Local_Var = 2 * Num ,

Avg = average([Num , Local_Var]) ,

Sqr_Avg = math:sqrt(Avg) ,

io:format("Result ~p. ~n",[Sqr_Avg]),

average( L ) ->

commas “,” separate things

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

average( L ) ->

list of exported functions

IntroductionErlang

Conclusion

Functional code

-module(app).

-export( [ func/1 ] ).

func( Num )->

average( L ) ->

list of exported functionslists are between square brackets “[ ] ”

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func /1 ]).

func( Num )->

average( L ) ->

list of exported functionsarity of the function

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

average( L ) ->

function definition

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

average( L ) ->

function definition

LOCAL function definition

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

average( L ) ->

variable, single assignment, like

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

average( L ) ->

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

average( L ) ->

atommind the difference!!

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

Local_Var = 2 * Num,Avg = average ([Num, Local_Var]),

Sqr_Avg = math:sqrt(Avg),io:format("Result ~p. ~n",[Sqr_Avg]),

average( L ) ->

local function call

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

Sqr_Avg = math:sqrt (Avg),

average( L ) ->

local function callfunction call across modules

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

Sqr_Avg = math : sqrt (Avg),

average( L ) ->

local function callfunction call across modules

Module name – colon “:” – function name

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

average( L ) ->

supports higher-order functions

(like , , )

IntroductionErlang

Conclusion

Functional code

-module(app).

-export([func/1]).

func( Num )->

average( L ) ->

lists:foldr( fun(El, Acc)-> El + Acc end , 0, L).

anonymous function (like , )

IntroductionErlang

Conclusion

Erlang datatypes (selection of)

Integers: 1, 15 and -4217

Strings: "You", "are", "sleeping"Atoms: distinguished valuesPids: process identifierFuns: function closures created by expressions:fun(...) ->... end.

Tuples: contain a fixed number data types:{E1, E2, ..., En}

Lists: [ Head | Tail ]. [] denotes an empty list.

IntroductionErlang

Conclusion

Integers: 1, 15 and -4217Strings: "You", "are", "sleeping"

Atoms: distinguished valuesPids: process identifierFuns: function closures created by expressions:fun(...) ->... end.

IntroductionErlang

Conclusion

Integers: 1, 15 and -4217Strings: "You", "are", "sleeping"Atoms: distinguished values

Pids: process identifierFuns: function closures created by expressions:fun(...) ->... end.

IntroductionErlang

Conclusion

Integers: 1, 15 and -4217Strings: "You", "are", "sleeping"Atoms: distinguished valuesPids: process identifier

Funs: function closures created by expressions:fun(...) ->... end.

IntroductionErlang

Conclusion

Integers: 1, 15 and -4217Strings: "You", "are", "sleeping"Atoms: distinguished valuesPids: process identifierFuns: function closures created by expressions:fun(...) ->... end.

IntroductionErlang

Conclusion

IntroductionErlang

Conclusion

IntroductionErlang

Conclusion

Dynamic typing

NO static typing (unlike )

This is a valid erlang program (will fail at runtime)

add( X, Y ) ->

add( 5, "marco" ).

IntroductionErlang

Conclusion

Dynamic typing

NO static typing (unlike )This is a valid erlang program (will fail at runtime)

add( X, Y ) ->

add( 5, "marco" ).

IntroductionErlang

Conclusion

Compiling and running Erlang code

Download and install the runtime:http://www.erlang.org/download.html

erl starts the consoleerlc filename.erl compiles

run commands within the consolec(filename). compiles from the console

IntroductionErlang

Conclusion

erl starts the console

erlc filename.erl compiles

IntroductionErlang

Conclusion

IntroductionErlang

Conclusion

run commands within the console

c(filename). compiles from the console

IntroductionErlang

Conclusion

IntroductionErlang

Conclusion

Useful links

Erlang API: http://www.erlang.org/doc/man_index.htmlPart I of Concurrent programming in Erlang, by J. Armstrong,R. Virding, C. Wikström and M. Williams: http://www.erlang.org/download/erlang-book-part1.pdf

//www.erlang.org/static/getting_started_quickly.html

http://www.erlang.org/doc/getting_started/users_

guide.html

http://learnyousomeerlang.com/

IntroductionErlang

Conclusion

Coding time

Coding timelength/1,dynamic type error with length/1, atom_to_list BIF,filter/2,anonymous functions, guards in functions,tailFilter/2

IntroductionErlang

Conclusion

Outline

3 Conclusion

IntroductionErlang

Conclusion

The Actor model

everything is an actor

messages are the means of communication (asynchronous)actors have mailboxes where messages are queuedactors send and receive messages (only 2 primitives)

IntroductionErlang

Conclusion

The Actor model

everything is an actormessages are the means of communication (asynchronous)

actors have mailboxes where messages are queuedactors send and receive messages (only 2 primitives)

IntroductionErlang

Conclusion

The Actor model

everything is an actormessages are the means of communication (asynchronous)actors have mailboxes where messages are queued

actors send and receive messages (only 2 primitives)

IntroductionErlang

Conclusion

The Actor model

everything is an actormessages are the means of communication (asynchronous)actors have mailboxes where messages are queuedactors send and receive messages (only 2 primitives)

IntroductionErlang

Conclusion

Actors vs Threads

Actors

(generally) context switched bythe runtimemessage passing (asynchronous)no race conditons: no lockingcan deadlockbenefit from SSA

Threads

(generally) context switched bythe OSshared memory (sync/async)race conditions: needs lockingcan deadlockrely on mutable state

IntroductionErlang

Conclusion

Actors vs Threads

Actors

(generally) context switched bythe runtimemessage passing (asynchronous)no race conditons: no lockingcan deadlockbenefit from SSA

Threads

(generally) context switched bythe OSshared memory (sync/async)race conditions: needs lockingcan deadlockrely on mutable state

IntroductionErlang

Conclusion

Erlang’s concurrency model, informally

Actor model:actors are lightweight processes, not OS processes, not threads

309 words of memory when spawned (very small!)fixed point context switches (optimal concurrency)processes have mailboxessend and receive are part of syntax.

has actors as a library

Akka implements actors for the JVM ( , ...)actor framework or Retlang for .Net

IntroductionErlang

Conclusion

Actor model:actors are lightweight processes, not OS processes, not threads309 words of memory when spawned (very small!)

fixed point context switches (optimal concurrency)processes have mailboxessend and receive are part of syntax.

IntroductionErlang

Conclusion

Actor model:actors are lightweight processes, not OS processes, not threads309 words of memory when spawned (very small!)fixed point context switches (optimal concurrency)

processes have mailboxessend and receive are part of syntax.

IntroductionErlang

Conclusion

Actor model:actors are lightweight processes, not OS processes, not threads309 words of memory when spawned (very small!)fixed point context switches (optimal concurrency)processes have mailboxes

send and receive are part of syntax.has actors as a library

IntroductionErlang

Conclusion

Actor model:actors are lightweight processes, not OS processes, not threads309 words of memory when spawned (very small!)fixed point context switches (optimal concurrency)processes have mailboxessend and receive are part of syntax.

IntroductionErlang

Conclusion

Receiving messages in Erlang

receive

mess ->

ok;{tuple, Number} ->

io:format("Received ~p",[Number])

10000 ->

IntroductionErlang

Conclusion

receive

mess ->

{tuple, Number} ->

10000 ->

pattern matching (like , )

IntroductionErlang

Conclusion

receive

mess ->

{tuple, Number} ->

10000 ->

pattern matching (like , )separate by “;”

IntroductionErlang

Conclusion

receive

mess ->

10000 ->

pattern matching (like , )

last clause ends with NOTHING

IntroductionErlang

Conclusion

receive

mess ->

10000 ->

timeout clause

IntroductionErlang

Conclusion

The receive loop

a receive loop is a recursive receive inside a functionthe recursive call must be tail-recursive

server( NumMess )->

receive

mess ->

server( NumMess + 1 );

{tuple, Number} ->

server( Number ) + 1

10000 ->

IntroductionErlang

Conclusion

The receive loop

server( NumMess )->

receive

mess ->

{tuple, Number} ->

10000 ->

IntroductionErlang

Conclusion

The receive loop

server( NumMess )->

receive

mess ->

server( NumMess + 1 ) ;

{tuple, Number} ->

10000 ->

this one is ok

IntroductionErlang

Conclusion

The receive loop

server( NumMess )->

receive

mess ->

{tuple, Number} ->

10000 ->

this one is NOT

IntroductionErlang

Conclusion

The receive loop

server( NumMess )->

receive

mess ->

{tuple, Number} ->

10000 ->

State of the function (unlike , C)

IntroductionErlang

Conclusion

Sending messages in Erlang

messages are sent to PIDs or NAMEs:PID !{mess, Var, 1}

PIDs are process identifiersprocesses are created with the BIF spawn/1-4, which returnsa PIDthe BIF self/0 returns the PID of the current processPIDs can be registered to local names with register/2

(good for servers and for failing-respawning processes)local names are fetch with registered/0

IntroductionErlang

Conclusion

PIDs are process identifiers

processes are created with the BIF spawn/1-4, which returnsa PIDthe BIF self/0 returns the PID of the current processPIDs can be registered to local names with register/2

IntroductionErlang

Conclusion

PIDs are process identifiersprocesses are created with the BIF spawn/1-4, which returnsa PID

the BIF self/0 returns the PID of the current processPIDs can be registered to local names with register/2

IntroductionErlang

Conclusion

PIDs are process identifiersprocesses are created with the BIF spawn/1-4, which returnsa PIDthe BIF self/0 returns the PID of the current process

PIDs can be registered to local names with register/2

IntroductionErlang

Conclusion

(good for servers and for failing-respawning processes)

local names are fetch with registered/0

IntroductionErlang

Conclusion

IntroductionErlang

Conclusion

Coding time

Coding timereceive messages, send messages, timeoutspawn/3, register/2, unregister/1

receive loop

IntroductionErlang

Conclusion

Outline

3 Conclusion

IntroductionErlang

Conclusion

The “Let it crash” philosophy

expect failuredeal with it

Failures:in the same function: exceptions, errors and exits.

Handled with try / catch, like in andin another processHandled as messages by monitor/2 and link/1

IntroductionErlang

Conclusion

Handled with try / catch, like in and

in another processHandled as messages by monitor/2 and link/1

IntroductionErlang

Conclusion

Handled with try / catch, like in andin another processHandled as messages by monitor/2 and link/1

IntroductionErlang

Conclusion

Exceptions – throwing

Three types:

throw(Exception).

erlang:error(Reason).

exit(Reason).

IntroductionErlang

Conclusion

Three types:

throw(Exception).

exit(Reason).

IntroductionErlang

Conclusion

Three types:

throw(Exception).

exit(Reason).

IntroductionErlang

Conclusion

Exceptions – catching

throws(F) ->

try F() of_ -> ok

Throw -> {throw, caught, Throw};

error:Error -> {error, caught, Error};

exit:Exit -> {exit, caught, Exit}

IntroductionErlang

Conclusion

Monitoring

Unidirectionalreceive a message when a process dies:{ ’DOWN’, MonitorReference, process, Pid, Reason}

Pid = spawn( function ),

Ref = monitor(process, Pid).

... % or

{ Pid , Ref } = spawn_monitor( function ).

... %remove with

demonitor( Ref ).

IntroductionErlang

Conclusion

Monitoring

Unidirectionalreceive a message when a process dies:{ ’DOWN’, MonitorReference, process, Pid, Reason}

Pid = spawn( function ),

Ref = monitor(process, Pid).

... % or

{ Pid , Ref } = spawn_monitor( function ).

... %remove with

demonitor( Ref ).

IntroductionErlang

Conclusion

Linking

Bidirectionalreceive message when either process dies:{ ’EXIT’, Pid, Reason}only active after process_flag(trap_exit, true)

Pid = spawn( function ).

link( Pid ).

... % or

Pid = spawn_link( function ).

... %remove with

unlink( Pid ).

IntroductionErlang

Conclusion

Linking

Bidirectionalreceive message when either process dies:{ ’EXIT’, Pid, Reason}only active after process_flag(trap_exit, true)

Pid = spawn( function ).

link( Pid ).

... % or

Pid = spawn_link( function ).

... %remove with

unlink( Pid ).

IntroductionErlang

Conclusion

Coding time

Coding timetry/catchspawn_link/3, link/1, monitor/2

IntroductionErlang

Conclusion

Outline

3 Conclusion

IntroductionErlang

Conclusion

What is distribution?

processes on different Erlang nodes

different Erlang nodes on different machines

some applications are inherently distributede.g. Cloud management, load balancing middleware ...

IntroductionErlang

Conclusion

processes on different Erlang nodesdifferent Erlang nodes on different machines

IntroductionErlang

Conclusion

processes on different Erlang nodesdifferent Erlang nodes on different machines

IntroductionErlang

Conclusion

Erlang Nodes

an Erlang node is an executing Erlang system

a node is given a name erl -name asd

the BIF node/0 returns the full namethe BIFs spawn/1-4, monitor/2, link/1, register/2 allwork also with node names

IntroductionErlang

Conclusion

Erlang Nodes

an Erlang node is an executing Erlang systema node is given a name erl -name asd

IntroductionErlang

Conclusion

Erlang Nodes

the BIF node/0 returns the full name

the BIFs spawn/1-4, monitor/2, link/1, register/2 allwork also with node names

IntroductionErlang

Conclusion

Erlang Nodes

IntroductionErlang

Conclusion

connect with net_kernel:connect_node( NodeName )

net_kernel coordinates distributed Erlang systemsuse cookies to prevent communicationsuse -hidden to prevent communications

IntroductionErlang

Conclusion

net_kernel coordinates distributed Erlang systems

use cookies to prevent communicationsuse -hidden to prevent communications

IntroductionErlang

Conclusion

net_kernel coordinates distributed Erlang systemsuse cookies to prevent communications

use -hidden to prevent communications

IntroductionErlang

Conclusion

net_kernel coordinates distributed Erlang systemsuse cookies to prevent communicationsuse -hidden to prevent communications

IntroductionErlang

Conclusion

Coding time

Coding timedistributed communication

IntroductionErlang

Conclusion

Erlang is:concurrent (also parallel and distributed)functionalfail-resistant

good for backend softwaregood for long-lived applications

IntroductionErlang

Conclusion

good for backend software

good for long-lived applications

IntroductionErlang

Conclusion

good for backend softwaregood for long-lived applications

IntroductionErlang

Conclusion

Homework and lab exercises

Find the homework exercise in Toledo.Lab sessions:

November 4, from 1:30 PM to 4:00 PM, Location:200A.SOL_ZNovember 14, from 10:30 AM to 1:00 PM, Location:200A.SOL_Z

DOyour homework before the lab sessions

Introduction Erlang Conclusion - theory.stanford.edump/mp/Teaching_files/2014-Erl.pdf · Introduction Erlang Conclusion Syntax and examples Concurrency in Erlang Let it crash Distribution

Documents

Cloud Scaling Erlang Erlang - Informatix Sol · PDF...

Erlang kansai01

Social Erlang

Erlang workshopdrammen

Why erlang

Evaluating the Erlang C and Erlang A Models for Call...

Erlang SGSN

Erlang session2

IV. rész Tartalom Erlang alapok Bevezetés Erlang alapok...

Cloud Erlang

Tabela Erlang

erlang 101

Practical Erlang Programming Basic Erlang. © 2001 -2009...

Erlang (GeekTalks)

Erlang scheduler

Introucing Erlang