The document discusses concurrency in Elixir using OTP (Open Telecom Platform). OTP provides libraries and design principles for writing concurrent applications in Erlang/Elixir. It includes components like supervisors, applications, agents, tasks and GenServers that help manage concurrency. Supervisors oversee worker processes in a supervision tree, restarting them based on configured restart strategies if they fail. State is managed by agents and GenServers. This allows applications to have many concurrent processes that are fault tolerant and can seamlessly spread across machines.

1. Concurrency in
Elixir with OTP
Presented for
Code & Supply

2. You down with
OTP?

3. You down with
OTP?
Yeah you know me!

4. Open
Telecom
Platform
W hat is OTP?

5. Open
Telecom
Platform
W hat is OTP?
Open source project
Developed by Ericsson, opened in 1998
18 years proven
https://github.com/erlang/otp

6. Open
Telecom
Platform
W hat is OTP?
Fault tolerant
Distributed
Concurrent

7. Open
Telecom
Platform
W hat is OTP?
Design principles for writing concurrent
applications in Erlang
Libraries

9. History
xgen
Integrates Elixir, Mix and OTP
Merged into Elixir
Available in Elixir 0.13.3 and higher
https://github.com/josevalim/xgen

10. Components
Application
Agents
Tasks
Supervisors
GenServers
GenEvents

11. Concurrency

12. Starts Supervisors
Application
# mix.exs
def application do
[mod: { CatFeed, [] }]
end
# lib/cat_feed.ex
defmodule CatFeed do
use Application
def start(_type, _args) do
CatFeed.Supervisor.start_link
end
end

13. Supervises processes
Supervisor
# lib/cat_feed/supervisor.ex
defmodule CatFeed.Supervisor do
use Supervisor
def start_link do
Supervisor.start_link(__MODULE__, :ok)
end
def init(:ok) do
children = [ worker(CatFeed.FeederLady) ]
supervise children, strategy :one_for_one
end
end

14. Supervises processes
Supervisor
# lib/cat_feed/supervisor.ex
defmodule CatFeed.Supervisor do
use Supervisor
def start_link do
Supervisor.start_link(__MODULE__, :ok)
end
def init(:ok) do
children = [ worker(CatFeed.FeederLady) ]
supervise children, strategy :one_for_one
end
end

15. one_for_one
If a child process terminates, only that process is
restarted.
Restart Strategies

16. one_for_one
If a child process terminates, only that process is
restarted.
Restart Strategies

17. one_for_one
If a child process terminates, only that process is
restarted.
Restart Strategies

18. rest_for_one
Restarts all processes started after one that failed
Restart Strategies

19. rest_for_one
Restarts all processes started after one that failed
Restart Strategies

20. rest_for_one
Restarts all processes started after one that failed
Restart Strategies

21. one_for_all
Restarts all processes if any fail
Restart Strategies

22. one_for_all
Restarts all processes if any fail
Restart Strategies

23. one_for_all
Restarts all processes if any fail
Restart Strategies

24. Handles state and does things
GenServer
# lib/cat_feed/feeder_lady.ex
defmodule CatFeed.FeederLady do
use Server
# some stuff here …
def handle_call({:fill, bowl}, _from, state) do
{:reply, CatFeed.BowlAgent.put(bowl, :food, state), state}
# or
HashDict.put(bowl, key, value)
end
end

25. Specialized for storing state
Agent
# lib/cat_feed/bowl_agent.ex
defmodule CatFeed.BowlAgent do
def start_link do # set initial state
Agent.start_link(fn -> HashDict.new end)
end
def get(bucket, key) do # get state
Agent.get(bucket, &HashDict.get(&1, key))
end
def put(bowl, key, value) do # update state
Agent.update(bowl, &HashDict.put(&1, key, value))
end
end

27. Handled in supervisor
BEAM processes
Spread across machines seamlessly
Concurrency

28. # lib/cat_feed/supervisor.ex
defmodule CatFeed.Supervisor do
use Supervisor
def start_link do
Supervisor.start_link(__MODULE__, :ok)
end
def init(:ok) do
children = [ worker(CatFeed.FeederLady) ]
supervise children, strategy :one_for_one
end
end
Concurrency

29. # lib/cat_feed/supervisor.ex
defmodule CatFeed.Supervisor do
use Supervisor
# def start_link do // folded
def init(:ok) do
children = [
worker(CatFeed.FeederLady),
worker(CatFeed.FeederLady),
CatFeed.Supervisor.start_link
]
supervise children, strategy :one_for_one
end
end
Concurrency

30. Recap
OTP
Based on Erlang OTP
Supervision tree
Restart strategies
State managed by select entities

31. Concurrency in
Elixir with OTP
Presented for
Code & Supply
http://codeandsupply.co
@justinxreese