The document discusses OTP (Open Telecom Platform) and Elixir. It provides an overview of OTP including that it is mature, battle tested for 16-18 years, and uses actors, object orientation, and design patterns. It then discusses behaviors and callback modules in OTP, the importance of initialization steps and parameter/return value contracts, using supervisors and strategies, and handling failures in Elixir applications. Code examples are provided for GenServers and supervisors.

1. Elixir Elevated!
The Ups and Downs of OTP
Greg Vaughn!
gvaughn@gmail.com!
twitter: @gregvaughn, github/irc: gvaughn

2. Student of Elixir and OTP!
Hobbying with Elixir almost 13 months!
Texan!
Professional Programmer of 20 years!
Across 6 languages!
Employed by LivingSocial

3. Student of Elixir and OTP!
Hobbying with Elixir almost 13 months!
Texan!
Professional Programmer of 20 years!
Across 6 languages!
Employed by LivingSocial
LivingSocial is Hiring!

4. OTP is …

5. OTP is …
Mature / Battle Tested for 16 (18?) years

6. OTP is …
Mature / Battle Tested for 16 (18?) years
Microservices

7. OTP is …
Mature / Battle Tested for 16 (18?) years
Microservices
Object Oriented (NOT class oriented)

8. OTP is …
Mature / Battle Tested for 16 (18?) years
Microservices
Object Oriented (NOT class oriented)
Actor

9. OTP is …
Mature / Battle Tested for 16 (18?) years
Microservices
Object Oriented (NOT class oriented)
Actor
Framework (Hollywood Principle)

10. OTP is …
Mature / Battle Tested for 16 (18?) years
Microservices
Object Oriented (NOT class oriented)
Actor
Framework (Hollywood Principle)
Design Patterns

11. OTP is …
Mature / Battle Tested for 16 (18?) years
Microservices
Object Oriented (NOT class oriented)
Actor
Framework (Hollywood Principle)
Design Patterns
Robust

12. object oriented
OOP to me means only messaging, local
retention and protection and !
hiding of state-process, and extreme
late-binding of all things. — Alan Kay

13. object oriented
OOP to me means only messaging, local
retention and protection and !
hiding of state-process, and extreme
late-binding of all things. — Alan Kay
functional
a style of building the structure and elements of
computer programs that treats computation as
the evaluation of mathematical functions and
avoids state and mutable data. — Wikipedia

14. object oriented
OOP to me means only messaging, local
retention and protection and !
hiding of state-process, and extreme
late-binding of all things. — Alan Kay
functional
a style of building the structure and elements of
computer programs that treats computation as
the evaluation of mathematical functions and
avoids state and mutable data. — Wikipedia
concurrent
The conceptually simultaneous
execution of more than one sequential
program on a computer or network of
computers. — McGraw-Hill Sci & Tech
Dictionary

15. object oriented functional
concurrent
actors

16. Behaviours: Don’t call us, we’ll call you
defmodule MyCallback do
use GenServer
end
iex> {:ok, pid} = GenServer.start(MyCallback, [])

17. Behaviours: Don’t call us, we’ll call you
defmodule MyCallback do
use GenServer
end
iex> {:ok, pid} = GenServer.start(MyCallback, [])
defmodule GenServer do
defmacro __using__(_) do
quote do
@behaviour :gen_server
!
def init(args), do: {:ok, args}
!
def handle_cast(msg, state), do: {:stop, {:bad_cast, msg}, state}
!
def handle_call(msg, _from, state), do: {:stop, {:bad_call, msg}, state}
!
def handle_info(_msg, state), do: {:noreply, state}
!
def terminate(_reason, _state), do: :ok
!
def code_change(_old, state, _extra), do: {:ok, state}
!
defoverridable [init: 1, handle_call: 3, handle_info: 2,
handle_cast: 2, terminate: 2, code_change: 3]
end
end
…
end

18. defmodule MyCallback do
use GenServer
@initial_state %{}
!
def start_link do
GenServer.start_link(__MODULE__, @initial_state)
end
!
def init(arg) do
state = arg
{:ok, state}
end
!
def do_it(pid, param) do
GenServer.call(pid, {:do_it, param})
end
!
def handle_call({:do_it, param}, _from, state) do
payload = get_payload(param, state)
new_state = update_state(param, state)
{:reply, payload, new_state}
end
!
defp get_payload(param, state), do: “I DONE DID IT!”
!
defp update_state(param, state), do: state
end

19. defmodule MyCallback do
use GenServer
@initial_state %{}
!
def start_link do
GenServer.start_link(__MODULE__, @initial_state)
end
!
def init(arg) do
state = arg
{:ok, state}
end
!
def do_it(pid, param) do
GenServer.call(pid, {:do_it, param})
end
!
def handle_call({:do_it, param}, _from, state) do
payload = get_payload(param, state)
new_state = update_state(param, state)
{:reply, payload, new_state}
end
!
defp get_payload(param, state), do: “I DONE DID IT!”
!
defp update_state(param, state), do: state
end

20. defmodule MyCallback do
use GenServer
@initial_state %{}
!
def start_link do
GenServer.start_link(__MODULE__, @initial_state)
end
!
def init(arg) do
state = arg
{:ok, state}
end
!
def do_it(pid, param) do
GenServer.call(pid, {:do_it, param})
end
!
def handle_call({:do_it, param}, _from, state) do
payload = get_payload(param, state)
new_state = update_state(param, state)
{:reply, payload, new_state}
end
!
defp get_payload(param, state), do: “I DONE DID IT!”
!
defp update_state(param, state), do: state
end

21. defmodule MyCallback do
use GenServer
@initial_state %{}
!
def start_link do
GenServer.start_link(__MODULE__, @initial_state)
end
!
def init(arg) do
state = arg
{:ok, state}
end
!
def do_it(pid, param) do
GenServer.call(pid, {:do_it, param})
end
!
def handle_call({:do_it, param}, _from, state) do
payload = get_payload(param, state)
new_state = update_state(param, state)
{:reply, payload, new_state}
end
!
defp get_payload(param, state), do: “I DONE DID IT!”
!
defp update_state(param, state), do: state
end

22. defmodule MyCallback do
use GenServer
@initial_state %{}
!
def start_link do
GenServer.start_link(__MODULE__, @initial_state)
end
!
def init(arg) do
state = arg
{:ok, state}
end
!
def do_it(pid, param) do
GenServer.call(pid, {:do_it, param})
end
!
def handle_call({:do_it, param}, _from, state) do
payload = get_payload(param, state)
new_state = update_state(param, state)
{:reply, payload, new_state}
end
!
defp get_payload(param, state), do: “I DONE DID IT!”
!
defp update_state(param, state), do: state
end
ClientProcess
ServerProcess

23. Elevators 101

24. A rider on any floor presses the up or down button!
An elevator car arrives!
Rider enters and presses a destination floor button
rider
hall!
signal
hall!
signal
car
carrider
floor hail
retrieve
arrival
arrival
go to

25. A rider on any floor presses the up or down button!
An elevator car arrives!
Rider enters and presses a destination floor button
rider
hall!
signal
hall!
signal
car
carrider
floor hail
retrieve
arrival
arrival
go to
Hail
struct

26. Show Me The Code

27. Let It Fail … and Respond
Separation of Concerns!
Think Long and Hard about
Failure Response!
BEAM (not OS) Processes!
Finer Grained Control

28. Prepare to Fail
Car!
Supervisor
Car 1 Car n…
one_for_one

29. Prepare to Fail
Car!
Supervisor
Car 1 Car n…
one_for_one
Hall!
Signal

30. Prepare to Fail
Car!
Supervisor
Car 1 Car n…
one_for_one
Gen!
Event
Hall!
Signal

31. Prepare to Fail
Car!
Supervisor
Car 1 Car n…
one_for_one
Gen!
Event
Hall!
Signal
Bank!
Supervisor
rest_for_one

32. Prepare to Fail
Gen!
Event
HS
Bank A!
Supervisor
CS
Gen!
Event
HS
Bank B!
Supervisor
CS
Elevator!
Supervisor
one_for_one

33. Prepare to Fail
Gen!
Event
HS
Bank A!
Supervisor
CS
Gen!
Event
HS
Bank B!
Supervisor
CS
Elevator!
Supervisor
one_for_one
Gen
Event
Gen
Event

34. Don’t Trip
defmodule MySupervisor do
use Supervisor
!
def init(…) do
workers = worker(MyCallback, [p1, p2, [name: :myc]], [id: :mine])
supervise(workers, strategy: one_for_one)
end
end
!
defmodule MyCallback do
use GenServer
!
def start_link(p1, p2, opts [])
GenServer.start_link(__MODULE__, [p1, p2], opts)
end
!
def init([p1, p2]) do
{:ok, %{p1: p1, p2: p2}}
end
end

35. Don’t Trip
defmodule MySupervisor do
use Supervisor
!
def init(…) do
workers = worker(MyCallback, [p1, p2, [name: :myc]], [id: :mine])
supervise(workers, strategy: one_for_one)
end
end
!
defmodule MyCallback do
use GenServer
!
def start_link(p1, p2, opts [])
GenServer.start_link(__MODULE__, [p1, p2], opts)
end
!
def init([p1, p2]) do
{:ok, %{p1: p1, p2: p2}}
end
end
apply: list of params

36. Don’t Trip
defmodule MySupervisor do
use Supervisor
!
def init(…) do
workers = worker(MyCallback, [p1, p2, [name: :myc]], [id: :mine])
supervise(workers, strategy: one_for_one)
end
end
!
defmodule MyCallback do
use GenServer
!
def start_link(p1, p2, opts [])
GenServer.start_link(__MODULE__, [p1, p2], opts)
end
!
def init([p1, p2]) do
{:ok, %{p1: p1, p2: p2}}
end
end
apply: list of params
single term for init/1

37. Trip-less Convention?
defmodule MySupervisor do
use Supervisor
!
def init(…) do
workers = worker(MyCallback, [{p1, p2}, name: :myc], [id: :mine])
supervise(workers, strategy: one_for_one)
end
end
!
defmodule MyCallback do
use GenServer
!
def start_link(init_params, opts [])
GenServer.start_link(__MODULE__, init_params, opts)
end
!
def init({p1, p2}) do
{:ok, %{p1: p1, p2: p2}}
end
end

38. Show Me The Code

39. Takeaways
Behaviours vs. Callback Modules!
Watch your initialization steps!
Watch parameter and return value contracts!
Supervisors and Strategies!
Config

40. Thank you
Elixir Elevated!
The Ups and Downs of OTP!
!
Greg Vaughn!
!
gvaughn@gmail.com!
twitter: @gregvaughn!
github/irc: gvaughn
http://github.com/gvaughn/elixir_elevated/tree/elixirconf2014