My talk at TDC 2016 about Elixir Lang and OTP. Done at the functional languages track.

1. Pedro Medeiros
Software Engineer @ Globo.com
/pedrosnk /pesnk
Elixir and OTP

2. Briefing
➔ Introduction to Elixir
➔ Processes (concurrency model)
➔ OTP
➔ GenServer, Supervisor, Application

3. Elixir

4. Elixir
Functional, meta-
programming aware
language built on top of
the Erlang VM

5. Elixir
Functional, meta-
programming aware
language built on top of
the Erlang VM

6. Elixir
Sample
defmodule Fibonacci do
def fib(0), do: 0
def fib(1), do: 1
def fib(n), do
fib(n-1) + fib(n-2)
end
end
IO.puts Fibonacci.fib(10)

7. Disclaimer

8. Disclaimer
Elixir is not about a better syntax
to the Erlang VM.

9. 1. Extensibility
2. Productivity
3. Compatibility
Elixir Design Goals

10. Types and modules
polymorphism
Extensibility

11. Extensibility
Process
Data 1 Data 2
data.value

12. Extensibility
Process
Process
Process
Call.here?

13. Extensibility
Process
Message 1 Message 2
JSON.decode

15. Productivity
1. Mix
2. Hex
3. Docs
4. Test
Great tooling

16. Productivity
Mix

17. Productivity
Hex

18. Productivity
Docs

19. Productivity
Test

20. Productivity
Test
defmodule Fibonacci do
@doc """
Fibonacci
iex> Fibonacci.fib(10)
55
"""
def fib(0), do: 0
def fib(1), do: 1
def fib(n) do
fib(n - 1) + fib(n - 2)
end
end

21. Productivity
Summary
$ mix new foobar
$ cd foobar
$ mix test
$ mix hex.publish
$ mix hex.docs

22. Compatibility
Elixir and Erlang sitting
on a tree

23. Compatibility
Elixir calls Erlang

24. Compatibility
Erlang calls Elixir

25. Process 101
Basic concurrency model.

26. Process
def ExpensiveProcess do
def loop do
receive do
{:operation, {sender, operation}} ->
operation = expensive_method(operation)
send sender, {:ok, operation}
loop()
:stop ->
:error
_ ->
loop()
end
end
end

27. ProcessA P
B
C

28. ProcessA P
B
C

29. ProcessA P
B
C

30. ProcessA P
B
C

31. OTP
Open Telecom Platform

32. 1. Built with the Erlang VM
2. Super Toolset of tools to
build distributed fault-
tolerant applications.
OTP
Open Telecom Platform

33. OTP
What’s the problem?

34. OTP
Switch
Switch

35. OTP
Server
Browser, Mobile, IoTs
Endpoints

36. OTP
Open Telecom Platform
1. GenServer
2. Supervisor
3. Application
Behaviours

37. OTP
GenServer
defmodule MyServer do
use GenServer
def handle_call({:pop, _from, [item | state]}) do
{:reply, item, state}
End
def handle_cast({:push, item}, state) do
{:noreply, [item | state]}
End
def handle_info(:log, state) do
IO.puts("State of server is #{inspect(state)}")
{:noreply, state}
end
end

38. OTP
GenServer
defmodule MyServer do
use GenServer
def handle_call({:pop, _from, [item | state]}) do
{:reply, item, state}
End
def handle_cast({:push, item}, state) do
{:noreply, [item | state]}
End
def handle_info(:log, state) do
IO.puts("State of server is #{inspect(state)}")
{:noreply, state}
end
end
synchronous
asynchronous
message

39. OTP
Supervisor
Supervisor
S1 S2 S3
● Watches its children.
● Manage its children based on a
strategy.
● :one_for_one, :rest_for_all, :
rest_for_one

40. OTP
Supervisor
Supervisor
S1 S3
Strategy :one_for_one
:one_for_one
Supervisor
S1 S3S1

41. OTP
Supervisor
Supervisor
S1 S3
Strategy :rest_for_all
:rest_for_all
Supervisor
S1 S3S1

42. OTP
Supervisor
Supervisor
S1 S3
Strategy :rest_for_one
:rest_for_all
Supervisor
S1 S3S1

43. OTP
Supervisor
defmodule MyServer.Supervisor do
use Supervisor
def start_link do
Supervisor.start_link(__MODULE__, [])
end
def init([]) do
children = [
worker(MyServer, []),
worker(MyServer2, [])
]
supervise(children, strategy: :one_for_one)
end
end

44. OTP
Applicaton
Application is where the top
supervisors are initialized.
● Small code.
● Initialize supervisors to
“live forever”

45. OTP
Applicaton

46. OTP
Applicaton
defmodule Logger.App do
use Application
def start(_type, _args) do
import Supervisor.Spec
# ...
options = [strategy: :rest_for_one, name: Logger.
Supervisor]
children = [worker(GenEvent, [[name: Logger]]),
worker(Logger.Watcher, [Logger, Logger.Config, []],
[id: Logger.Config, function: :watcher]),
supervisor(Logger.Watcher, [Logger.Config, :handlers, []]),
worker(Logger.Watcher,
[:error_logger, Logger.ErrorHandler,
{otp_reports?, sasl_reports?, threshold},
:link],
[id: Logger.ErrorHandler, function: :
watcher])]
case Supervisor.start_link(children, options) do
{:ok, sup} ->
{:ok, sup, config}
{:error, _} = error ->
error
end
end

47. Remember this picture?
Server
Browser, Mobile, IoTs
Endpoints

48. Thanks =D

49. Recursos:
1. http://elixir-lang.org/
2. https://hex.pm
3. Programming Elixir Book
4. The little Elixir and OTP Guidebook
5. slideshare.net/pemedeiros