Introduction to Erlang
Erlang is a functional, concurrency-oriented,
distributive, fault-tolerant programming
language.
1
Philosophy of Erlang
Erlang was designed for writing concurrent programs
that "run forever". - Joe Armstrong
Let it fail. Have another process deal with it.
Fault tolerance requires at least *two* computers.
2
Erlang Mindset
Lots of little tasks
Tons of processes
Each process does a task very well
Ant Colony
Ants are processes sending messages to each other
3
Why Erlang?
4
Erlang makes hard things
easier.
5
Concurrency
6
7
Spawning Processes
8
F = fun() ->
io:format(hi)
end,
spawn(F).
>> hi<0.34.0>
9
spawn(io, format, [hi]).
10
Message Passing
11
12
Pid ! Message
Pid ! {do_task, run_home}
Pid ! 2
13
receive ... end
receive
Pattern1 [when Guard1] ->
Expressions1;
Pattern2 [when Guard2] ->
Expressions2
end.
14
Messages are contained in a processs
inbox.
receive
_ ->
ok
end.
15
Fault Tolerance
16
17
18
which is why erlang was
designed to be....
19
Distributive
20
21
Pid ! Message
where Pid exists on another node.
22
Erlang Nodes
Can only talk if the erlang cookie is the same
Can exist on the same machine or different machines
Does have overhead, isnt free
Can have C nodes (+ other node types that speak
erlang)
Communicate via Global Name Registry, Specific Pids,
or by Node name
23
The Basics
24
Erlang is Functional
25
Periods, Commas,
Semicolons Oh My!
People think Erlangs syntax is ugly. Its actually
very logical.
26
Periods ( . ) end everything except when
Semicolons ( ; ) end clauses
and Commas ( , ) separate expressions.
27
calculate_area({square, Size}) ->
Size * Size;
calculate_area({circle, Radius}) ->
Pi = 3.14,
Pi * Radius * Radius;
calculate_area(_Unknown) ->
ok.
28
case Expression of
{do_task, run_home} ->
Home = 123,
spawn(run, home, [Home]);
_ ->
ok
end.
29
Data Types
30
Integer - however big you can imagine
Floats
Atoms - similar to a ruby symbol, they are used to
represent non-numerical constants (true, false, ok,
error)
Tuple - Fixed length collection of items ({one, two,
three} or {one, two} etc)
Lists - Stores a variable number of things ([1, 2, {one,
two}, $a])
31
Missing Links...
32
Strings - A string is just a list of integers in erlang.
Booleans - Use atoms (true, false)
Hash - Property List ( [tuple()] ) shown later
33
Pattern Matching
Once you pattern match, variable assigning feels dirty.
34
1 = 1 ( ok )
1 = 2 ( error thrown bad_match )
Value = {2, 4},
{Width, Height} = {2, 4} ( ok )
[Head|Tail] = [1,2,3,4] ( ok )
35
Variable Binding
or restricting infinite possibilities.
36
An unbound variable can be anything it
needs to be (infinite possibilities)
A.
37
Pattern matching an unbound variable is
like restricting what it can be.
A = 1.
A = 2. (error bad_match)
38
Tuples
Single entity that holds a collection of items.
39
{1, 2, 3}.
{one, two}.
{user_id, 2, user_name, asceth}.
40
Lists
Variable sized container of items.
41
List = [1, 2, 3],
NewList = List ++ [4, 5, 6].
>> [1, 2, 3, 4, 5, 6]
[Head|Tail] = NewList.
>> Head -> 1
>> Tail -> [2, 3, 4, 5, 6]
42
[tuple()]
Property Lists or semi-hashes.
43
PList = [{key, value}, {key1, value1}].
case lists:keysearch(key, 1, PList) of
false ->
error;
{value, {Key, Value}} ->
Value
end.
44
keydelete - deletes tuple with specified key in list of
tuples and returns new list
keymap - returns list of tuples where Nth element is
replaced be specified fun
keymember - tests for existence of key
keymerge - combines two tuples with tuple1 taking
priority
ukeymerge, ukeysort - like keymerge but removes
duplicates in tuple2
45
Functions
Pattern matching, Function Arities & more
46
Functions with the same name can exist
Functions with the same name and different arity can
exist
Erlang tells you if a function cannot be called due to
order of definement
Function order is very important
47
contains(Key, []) ->
false;
contains(Key, List) ->
lists:any(fun(X) -> Key == X end, List).
contains(1, [1, 2, 3]).
true
contains({home, 123}, [{apartment, 333}, {house, 000}]).
false
48
Anonymous
49
contains(Key, []) ->
false;
contains(Key, List) ->
lists:any(fun(X) -> Key == X end, List).
F = fun(X, Y) ->
X1 = X * 2,
Y1 = Y * X,
X1 + Y1
end,
F(2, 2).
>> 12
50
Looping
Tail recursion makes looping good again.
51
print([]) ->
ok;
print([H|T]) ->
io:format(~p~n, [H]),
print(T).
52
Conditionals
Ifs are okay, cases are cooler.
53
if
A == 5 ->
do_something();
true ->
do_something_else()
end.
54
case A of
0 ->
first();
2 ->
second();
_ ->
something()
end.
55
Resources
http://www.erlang.org
Technorati
56
57
Questions?
58
