This is a short introduction to one of the newest and noisiest additions to the functional family. Chances are you have heard about Elixir before: created six years ago by José Valim, it has emerged rapidly in the Erlang ecosystem, attracting lots of attention. But what's so special about it? What's all the fuzz about? This talk will offer you a few selected sips for you to get a taste... but beware! You may want to drink all the bottle: if so, you may end up following the white rabbit down the hole and wake up in the Erlang wonderland.

1. ELIXIR
the not-so-hidden path to Erlang
A Coruña, February 1st, 2018
Laura M. Castro
Universidade da Coruña 1

2. 2

3. 3

4. Born in 1986, released ’98
Concurrency-oriented
◦ Lightweight, isolated
processes,
message-passing
communication
Multiplatform VM
Transparent distribution
OTP behaviours
Hot code swap
3

5. Born in 1986, released ’98
Concurrency-oriented
◦ Lightweight, isolated
processes,
message-passing
communication
Multiplatform VM
Transparent distribution
OTP behaviours
Hot code swap
3

6. Born in 2011
Runs on the Erlang VM
Can invoke Erlang code
Born in 1986, released ’98
Concurrency-oriented
◦ Lightweight, isolated
processes,
message-passing
communication
Multiplatform VM
Transparent distribution
OTP behaviours
Hot code swap
3

7. Dynamic typing
Single assignment
Eager evaluation
4

8. Dynamic typing
Variable rebinding
Lazy collections
Strings are not lists
Pipeline operator
Namespaces
Polymorphism via
protocols
Dynamic typing
Single assignment
Eager evaluation
4

9. Dynamic typing
Variable rebinding
Lazy collections
Strings are not lists
Pipeline operator
Namespaces
Polymorphism via
protocols
Dynamic typing
Single assignment
Eager evaluation
4

10. 5

11. HELLO, WORLD!
1 defmodule World do
2
3 def hello(who) do
4 IO.puts "Hello, #{inspect who}!"
5 end
6
7 end
1 -module(world).
2
3 -export([hello/1]).
4
5 hello(Who) ->
6 io:format("Hello, ~p!~n", [Who]).
6

12. HELLO, WORLD!
1 defmodule World do
2
3 def hello(who) do
4 IO.puts "Hello, #{inspect who}!"
5 end
6
7 end
1 -module(world).
2
3 -export([hello/1]).
4
5 hello(Who) ->
6 io:format("Hello, ~p!~n", [Who]).
6

13. HELLO, WORLD!
1 defmodule World do
2
3 def hello(who) do
4 IO.puts "Hello, #{inspect who}!"
5 end
6
7 end
1 -module(world).
2
3 -export([hello/1]).
4
5 hello(Who) ->
6 io:format("Hello, ~p!~n", [Who]).
6

14. SIMPLE MODULE
1 defmodule Boolean do
2 @moduledoc """
3 Simple pattern matching
4 """
5
6 @doc """
7 Operator ’not’.
8
9 ## Parameters
10
11 - value: boolean to be negated
12
13 """
14 @spec b_not(boolean) :: boolean
15 def b_not(true), do: false
16 def b_not(false), do: true
17
18 @doc """
19 Operator ’and’.
20
21 ## Parameters
22
23 - value1, value2: booleans to operate
24
25 """
26 @spec b_and(boolean , boolean) ::
boolean
27 def b_and(true, true), do: true
28 def b_and(_, _), do: false
1 %%% @doc Simple pattern matching
2 %%% @end
3 -module(boolean).
4
5 -export([b_not/1, b_and/2]).
6
7 %% @doc Operator ’not’.
8 %% @end
9 -spec b_not(Value :: boolean()) ->
boolean().
10 b_not(true) -> false;
11 b_not(false) -> true.
12
13 %% @doc Operator ’and’.
14 %% @end
15 -spec b_and(Value1 :: boolean(),
16 Value2 :: boolean()) ->
boolean().
17 b_and(true, true) ->
18 true;
19 b_and(Value1, Value2) ->
20 false.
7

15. SIMPLE MODULE
7

16. SIMPLE MODULE
7

17. SIMPLE MODULE
7

18. UNIT TESTS
1 ExUnit.start
2
3 defmodule BooleanTest do
4 @moduledoc """
5 Simple pattern matching (tests)
6 """
7
8 use ExUnit.Case
9 doctest Boolean
10
11 test "Boolean negation" do
12 assert Boolean.b_not(false)
13 refute Boolean.b_not(true)
14 end
15
16 test "Boolean AND" do
17 assert Boolean.b_and(true, true)
18 refute Boolean.b_and(true, false)
19 refute Boolean.b_and(false, true)
20 refute Boolean.b_and(false, false)
21 end
22
23 end
1 %%% @doc Simple pattern matching (tests)
2 %%% @end
3 -module(boolean_tests).
4
5 -include_lib("eunit/include/eunit.hrl").
6
7 b_not_test() ->
8 ?assert(boolean:b_not(false)),
9 ?assertNot(boolean:b_not(true)).
10
11 b_and_test() ->
12 ?assert(boolean:b_and(true,true)),
13 ?assertNot(boolean:b_and(true,false)),
14 ?assertNot(boolean:b_and(false,true)),
15 ?assertNot(boolean:b_and(false,false)).
8

19. UNIT TESTS
8

20. SIMPLE MODULE (II)
1 defmodule Create do
2 @moduledoc """
3 Creating lists
4 """
5
6 def create(n) when n>0 do
7 acc_forward(1, n, [])
8 end
9
10 def reverse_create(n) when n>0 do
11 acc_backwards(n, 1, [])
12 end
13
14 def acc_forward(a, a, l), do: [a|l]
15 def acc_forward(a, b, l), do:
acc_forward(a, b-1, [b|l])
16
17 def acc_backwards(a, a, l), do: [a|l]
18 def acc_backwards(a, b, l), do:
acc_backwards(a, b+1, [b|l])
19
20 end
1 %%% @doc Creating lists
2 %%% @end
3 -module(create).
4
5 -export([create/1, reverse_create/1]).
6
7 create(N) when N>0 ->
8 acc_forward(1, N, []).
9
10 reverse_create(N) when N>0 ->
11 acc_backwards(N, 1, []).
12
13 acc_forward(A, A, L) -> [A | L];
14 acc_forward(A, B, L) ->
15 acc_forward(A, B-1, [B | L]).
16
17 acc_backwards(A, A, L) -> [A | L];
18 acc_backwards(A, B, L) ->
19 acc_backwards(A, B+1, [B | L]).
9

21. PROPERTY-BASED TESTS
1 defmodule CreateProps do
2 @moduledoc """
3 Creating lists (test properties)
4 """
5
6 use ExUnit.Case
7 use PropCheck
8 doctest Create
9
10 property "List creation" do
11 forall i <- positive_integer() do
12 Create.create(i+1) == Enum.to_list
(1..i+1)
13 end
14 end
15
16 property "Reverse list creation" do
17 forall i <- positive_integer() do
18 Create.reverse_create(i+1) == Enum.
reverse(Enum.to_list(1..i+1))
19 end
20 end
21
22 end
1 %%% @doc Creating lists (test properties)
2 %%% @end
3 -module(create_props).
4
5 -include_lib("proper/include/proper.hrl")
.
6 -compile(export_all).
7
8 prop_create() ->
9 ?FORALL(I, positive_integer(),
10 create:create(I) == lists:seq(1, I)).
11
12 prop_reverse_create() ->
13 ?FORALL(I, positive_integer(),
14 create:reverse_create(I) == lists:
reverse(lists:seq(1, I))).
10

22. PROPERTY-BASED TESTS
1 defmodule CreateProps do
2 @moduledoc """
3 Creating lists (test properties)
4 """
5
6 use ExUnit.Case
7 use PropCheck
8 doctest Create
9
10 property "List creation" do
11 forall i <- positive_integer() do
12 Create.create(i+1) == Enum.to_list
(1..i+1)
13 end
14 end
15
16 property "Reverse list creation" do
17 forall i <- positive_integer() do
18 Create.reverse_create(i+1) == Enum.
reverse(Enum.to_list(1..i+1))
19 end
20 end
21
22 end
1 %%% @doc Creating lists (test properties)
2 %%% @end
3 -module(create_props).
4
5 -include_lib("proper/include/proper.hrl")
.
6 -compile(export_all).
7
8 prop_create() ->
9 ?FORALL(I, positive_integer(),
10 create:create(I) == lists:seq(1, I)).
11
12 prop_reverse_create() ->
13 ?FORALL(I, positive_integer(),
14 create:reverse_create(I) == lists:
reverse(lists:seq(1, I))).
10

23. PROPERTY-BASED TESTS
10

24. PROPERTY-BASED TESTS
10

25. SIMPLE PROCESS
11

26. SIMPLE PROCESS
1 defmodule DbProcess do
2 @moduledoc """
3 Database handling using a process
4 """
5
6 def new(), do: spawn(DbProcess , :loop,
[[]])
7
8 def write(key, element , dbref) do
9 send dbref, {:write, key, element}
10 dbref
11 end
12
13 def delete(key, dbref) do
14 send dbref, {:delete, key}
15 dbref
16 end
17
18 def read(key, dbref) do
19 send dbref, {:read, key, self()}
20 receive do
21 {_dbref, :found, element} -> {:ok,
element}
22 {_dbref, :notfound} -> {:
error, :instance}
23 end
24 end
1 %%% @doc Database handling using a
process
2 %%% @end
3 -module(db_process).
4
5 -export([new/0, write/3, delete/2, read
/2, match/2, destroy/1]).
6
7 new() ->
8 spawn(?MODULE, loop, [[]]).
9
10 write(Key, Element , DbRef) ->
11 DbRef ! {write, Key, Element},
12 DbRef.
13
14 delete(Key, DbRef) ->
15 DbRef ! {delete, Key},
16 DbRef.
17
18 read(Key, DbRef) ->
19 DbRef ! {read, Key, self()},
20 receive
21 {DbRef, found, Element} -> {ok,
Element};
22 {DbRef, notfound} -> {error,
instance}
23 end.
11

27. SIMPLE PROCESS
25 def match(element , dbref) do
26 send dbref, {:match, element , self()}
27 receive do
28 {_dbref, keys} -> keys
29 end
30 end
31
32 def destroy(dbref) do
33 send dbref, :stop
34 :ok
35 end
24 match(Element , DbRef) ->
25 DbRef ! {match, Element , self()},
26 receive
27 {DbRef, Keys} -> Keys
28 end.
29
30 destroy(DbRef) ->
31 DbRef ! stop,
32 ok.
11

28. SIMPLE PROCESS
36 def loop(db) do
37 receive do
38 {:write, key, element} -> loop([{
key, element} | db])
39 {:delete, key} -> loop(
acc_delete(key, db, []))
40 {:read, key, who} ->
41 case List.keyfind(db, key, 0) do
42 nil -> send who, {
self(), :notfound}
43 {_key, element} -> send who, {
self(), :found, element}
44 end
45 loop(db)
46 {:match, element , who} ->
47 keys = acc_match(element , db, [])
48 send who, {self(), keys}
49 loop(db)
50 :stop ->
51 :ok
52 end
53 end
33 loop(Db) ->
34 receive
35 {write, Key, Element} ->
36 loop([{Key, Element} | Db]);
37 {delete, Key} ->
38 loop(lists:keydelete(Key, 1, Db));
39 {read, Key, Who} ->
40 case lists:keyfind(Key, 1, Db) of
41 false ->
42 Who ! {self(), notfound};
43 {Key, Element} ->
44 Who ! {self(), found, Element}
45 end,
46 loop(Db);
47 {match, Element , Who} ->
48 Keys = acc_match(Element , Db, []),
49 Who ! {self(), Keys},
50 loop(Db);
51 stop ->
52 ok
53 end.
11

29. SIMPLE OTP PROCESS
1 defmodule DbGenServer do
2 @moduledoc """
3 Database handling using OTP
4 """
5
6 use GenServer
7
8 def new() do
9 GenServer.start_link(__MODULE__ , [],
name: DbGenServer)
10 end
11
12 def write(key, element) do
13 GenServer.cast(DbGenServer , {:write,
key, element})
14 end
15
16 def delete(key) do
17 GenServer.cast(DbGenServer , {:delete,
key})
18 end
19
20 def read(key) do
21 GenServer.call(DbGenServer , {:read,
key})
22 end
1 %% @doc Database handling using OTP
2 %% @end
3 -module(db_gen_server).
4 -behaviour(gen_server).
5
6 -export([new/0, write/2, delete/1, read
/1, match/1, destroy/0]).
7 -export([init/1, handle_call/3,
handle_cast/2, handle_info/2,
terminate/2, code_change/3]).
8
9 -define(SERVER, ?MODULE).
10
11 new() ->
12 gen_server:start_link({local, ?SERVER},
?MODULE, [], []).
13
14 write(Key, Element) ->
15 gen_server:cast(?SERVER, {write, Key,
Element}).
16
17 delete(Key) ->
18 gen_server:cast(?SERVER, {delete, Key})
.
19
20 read(Key) ->
21 gen_server:call(?SERVER, {read, Key}).
12

30. SIMPLE OTP PROCESS
23 def match(element) do
24 GenServer.call(DbGenServer , {:match,
element})
25 end
26
27 def destroy() do
28 GenServer.stop(DbGenServer)
29 end
30
31 ## GenServer Callbacks
32
33 def init([]) do
34 {:ok, []}
35 end
36
37 def handle_call({:read, key}, _from,
state) do
38 reply = case List.keyfind(state, key,
0) do
39 nil -> {:error, :instance}
40 {_key, element} -> {:ok, element}
41 end
42 {:reply, reply, state}
43 end
44 def handle_call({:match, element},
_from, state) do
45 keys = acc_match(element , state, [])
46 {:reply, keys, state}
47 end
22 match(Element) ->
23 gen_server:call(?SERVER, {match,
Element}).
24
25 destroy() ->
26 gen_server:stop(?SERVER).
27
28 % gen_server callbacks
29
30 init([]) ->
31 {ok, []}.
32
33 handle_call({read, Key}, _From, State) ->
34 Reply = case lists:keyfind(Key, 1,
State) of
35 false ->
36 {error, instance};
37 {Key, Element} ->
38 {ok, Element}
39 end,
40 {reply, Reply, State};
41 handle_call({match, Element}, _From,
State) ->
42 Keys = acc_match(Element , State, []),
43 {reply, Keys, State}.
12

31. SIMPLE OTP PROCESS
48 def handle_cast({:write, key, element},
state) do
49 {:noreply , [{key, element} | state]}
50 end
51 def handle_cast({:delete, key}, state)
do
52 {:noreply , acc_delete(key, state, [])
}
53 end
54
55 def handle_info(_msg, state) do
56 {:noreply , state}
57 end
58
59 def terminate(:normal, _state) do
60 :ok
61 end
62
63 end
44 handle_cast({write, Key, Element}, State)
->
45 {noreply , [{Key, Element} | State]};
46 handle_cast({delete, Key}, State) ->
47 {noreply , lists:keydelete(Key, 1, State
)}.
48
49 handle_info(_Info, State) ->
50 {noreply , State}.
51
52 terminate(normal, _State) ->
53 ok.
12

32. SIMPLE DISTRIBUTION
13

33. SIMPLE INTEGRATION
14

34. 15

35. ELIXIR, THE NOT-SO-HIDDEN PATH TO ERLANG
Concurrency & distribution
(+scalability, robustness...) made easy!
16

36. ELIXIR, THE NOT-SO-HIDDEN PATH TO ERLANG
Concurrency & distribution
(+scalability, robustness...) made easy!
Enjoy the power of the actor model
16

37. ELIXIR, THE NOT-SO-HIDDEN PATH TO ERLANG
Concurrency & distribution
(+scalability, robustness...) made easy!
Enjoy the power of the actor model
Take advantage of OTP & other tools
◦ Behaviours
◦ Static analysis, stateful property-based
testing, etc.
16

38. 17

39. Thanks!
@lauramcastro
lcastro@udc.es
18