Erlang Introduction: Processes, Concurrency and Actors

Erlang Introduction
Serhiy Oplakanets, Lviv 2012

Friday, February 10, 12

Classiﬁcation
• high-level
• general-purpose
• garbage-collected
• dynamically typed
• functional
• concurrent


$ erl
Erlang R14B04 (erts-5.8.5)
[source] [64-bit] [smp:4:4] [rq:
4] [async-threads:0] [hipe]
[kernel-poll:false]

Eshell V5.8.5 (abort with ^G)
1>


Syntax


Data Types


1> 2 + 2.
4

2> 3 * 5.
15

3> 7 / 6.
1.1666666666666667


1> [].
[]

2> [1, 2, 3].
[1,2,3]

3> [101,104,63].
"eh?"


1> "a string".
"a string"

2>
[97,32,115,116,114,105,110,103].
"a string"


1> $H.
72
2> $e.
101
3> $l.
108
4> $o.
111
5> [$H, $e, $l, $l, $o].
"Hello"


1> true.
true
2> false.
false
3> true == false.
false
4> false == false.
true
5> true /= false.
true


1> atom.
atom

2> anotherAtom.
anotherAtom

3> 'One more atom?'.
'One more atom?'


4> is_atom('One more atom?').
true


1> is_atom(true).
true

2> is_atom(false).
true


1> {1,2,3}.
{1,2,3}

2> {16, "hello"}.
{16,"hello"}

3> {3.14, "Pi", {"foo", bar}}.
{3.14,"Pi",{"foo",bar}}


Invariable Variables


1> Variable = "value".
"value"

2> AnotherVariable = 128.
128


1> R = 5, Pi = 3.14.
3.14

2> Pi.
3.14

3> Pi * R * R.
78.5


1> X = 1.
1

3> X = 2.
** exception error: no match of right
hand side value 2

4> X = 1.
1
?!?!


Pattern Matching


1> X = 1, Y = 1.
1
2> X = Y.
???


1> UnboundVariable.
* 1: variable 'UnboundVariable'
is unbound


1> X = 1.
1
2> X.
1
3> Y.
* 1: variable 'Y' is unbound
4> Y = 2.
2
5> Y.
2


1> User = {"John", "Doe", 35}.
...
2> {Name, Surname, Age} = User.
...
3> Name.
"John"
4> Age.
35


1> User = {"John", "Doe", 35}.
...
2> {Name, Surname} = User.
** exception error: no match of
right hand side value
{"John","Doe",35}


2> User = {"John", "Doe", 35}.
...
3> {Name, "Doe", 35} = User.
...
4> Name.
"John"


1> User = {"John", "Doe", 35}.
...
2> {Name, _, Age} = User.
...
3> Age.
35
4> Name.
"John"


1> _ = 1.
1

2> _.
* 1: variable '_' is unbound

5> _ = 3.
3


1> [Head | Tail] = [1,2,3].
[1,2,3]

2> Head.
1

3> Tail.
[2,3]


1> [1 | [2 | [3]]].
[1,2,3]


Modules and Functions


-module(test).
-export([main/0]).

main() -> "Hello".


1> test:main().
"Hello"


-module(test).
-export([factorial/1]).

factorial(0) -> 1;
factorial(N) -> N * factorial(N - 1).


$ erlc test.erl
$ erl
...
1> test:factorial(3).
6
2> test:factorial(5).
120


-module(logger).
-export([log/1, log/2]).

log(Msg) -> {"info", Msg}.
log(Level, Msg) -> {Level, Msg}.

--------------------8<--------------------

1> logger:log("Some info message.").
{"info","Some info message."}
2> logger:log("error", "Kernel panic!").
{"error","Kernel panic!"}


log(Msg) -> log("info", Msg).
log(Level, Msg) -> {Level, Msg}.


Function Guards


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


test:fib(0).
0
3> test:fib(1).
1
5> test:fib(8).
21
6> test:fib(-23).
** exception error: no function
clause matching test:fib(-23)


% Refactored factorial function:

factorial(0) -> 1;

factorial(N)
when is_integer(N) and (N > 0) ->
N * factorial(N - 1);

factorial(_) ->
{error, "Invalid argument"}.


7> factorial:factorial(3).
6

8> factorial:factorial(0).
1

9> factorial:factorial(-1).
{error,"Invalid argument"}

10> factorial:factorial("a").
{error,"Invalid argument"}


Concurrency

• any function can become a process
• process is a function executing in
parallel
• process shares nothing with other
processes


Processes/Actors

• processes are extremely lightweight and
fast
• ~15 seconds to spawn 100k processes on
my machine (MacBook Pro 8.1, OSX)


spawn(Module, Function, Arguments) -> Pid


Any function can
become a process


8> io:format("Hello~n").
Hello
...
2> spawn(io, format, ["Hello~n"]).
Hello
...


-module(actor).
-export([loop/0]).

loop() ->
receive
die -> io:format("Exiting~n")
end.


2> Pid = spawn(actor, loop, []).
<0.40.0>
3> is_process_alive(Pid).
true
4> Pid ! die.
Exiting
die
false


loop() ->
receive
die ->
io:format("Exiting~n");
Msg ->
io:format("Got: ~p~n", [Msg])
end.


...
true
4> Pid ! "Hello".
Got: "Hello"
...
false


loop() ->
receive
die ->
io:format("Exiting~n");
Msg ->
io:format("Got: ~p~n", [Msg]),
loop()
end.


...
3> Pid ! "Hello".
Got: "Hello"
true
5> Pid ! "Hello again!".
Got: "Hello again!"
true
7> Pid ! die.
Exiting
false


Processes are executed
in parallel and share no
data


-module(counter).
-export([loop/1]).

loop(N) ->
receive
increment -> loop(N + 1);
decrement -> loop(N - 1);
print ->
io:format("Current counter value: ~w~n", [N]),
loop(N)
end.


2> Counter = spawn(counter, loop, [0]).
...
3> Counter ! increment.
...
4> Counter ! increment.
...
5> Counter ! print.
Current counter value: 2
...
6> Counter ! decrement.
...
7> Counter ! print.


2> C1 = spawn(counter, loop, [0]).
<0.40.0>
3> C2 = spawn(counter, loop, [10]).
<0.42.0>

4> C1 ! increment, C1 ! increment, C1 ! print.

5> C2 ! decrement, C2 ! print.


Distributed Erlang


spawn(Node, Module, Function, Args) -> Pid


1> spawn(DistributedNode, test, factorial, [10]).


s erl -sname slave -setcookie '123!@#qwe'
...
(slave@Serhiys-MacBook-Pro)1> node().
'slave@Serhiys-MacBook-Pro'


$ erl -sname master -setcookie '123!@#qwe'
...
(master@Serhiys-MacBook-Pro)1>
net_adm:ping('slave@Serhiys-MacBook-Pro').
pong
(master@Serhiys-MacBook-Pro)3>spawn('slave@Serhiys-
MacBook-Pro', factorial, factorial, [100]).
933262154439441526816992388562667004907159682643816
214685929638952175999932299156089414639761565182862
536979208272237582511852109168640000000000000000000
00000
<6619.52.0>


Fault Tolerance


-module(actor).
-export([loop/0]).
loop() ->
receive
N ->
S = math:sqrt(N),
io:format("sqrt(~p) = ~p~n", [N,S]),
loop()
end.


...
3> Pid ! 4.
sqrt(4) = 2.0
...
5> Pid ! "a".
=ERROR REPORT==== 24-Jan-2012::14:06:02 ===
Error in process <0.40.0>
...
false


Supervisors

• supervisors monitor processes and take
actions on exit signals
• process linking does the trick


start() -> spawn(actor, restarter, []).

restarter() ->
process_flag(trap_exit, true),
Pid = spawn_link(actor, loop, []),
register(myActor, Pid),

receive
{'EXIT', _Pid, _Reason} ->
io:format("Process crashed. Restarting~n"),
restarter()
end.


2> actor:start().
3> myActor ! 4.
sqrt(4) = 2.0
4> myActor ! "foo".
Process crashed. Restarting
=ERROR REPORT====
Error in process <0.41.0> ...
5> is_process_alive(whereis(myActor)).
true
6> myActor ! 9.
sqrt(9) = 3.0


Other great features

• Hot code loading
• OTP Framework
•


Simplicity

• You just learned
• ~70% of Erlang syntax
• most major abstractions: modules,
functions and processes
• most of the core data types


Complexity

• Erlang/OTP is a complex framework
• Learning it takes time and practice


Bad Stuff
• syntax
• Strings
• code organization
• libraries
• underestimated complexity of OTP and
concurrent applications generally
• your colleagues will not understand you :)

Practical Application
• Notable uses:
• Facebook (Chat)
• CouchDB
• RabbitMQ
• Membase
• Riak


How to learn Erlang?


http://learnyousomeerlang.com/


Erlang getting started guide:
http://www.erlang.org/doc/getting_started/intro.html


Programming Erlang: Software for a Concurrent World
http://pragprog.com/book/jaerlang/programming-erlang


$ erl


[$Q, $u, $e, $s, $t, $i, $o, $n, $s, $?].


Thank you


Erlang Introduction: Processes, Concurrency and Actors

Recommended

Recommended

More Related Content

What's hot

What's hot (11)

Viewers also liked

Viewers also liked (20)

Recently uploaded

Recently uploaded (20)

Erlang Introduction: Processes, Concurrency and Actors