September 8th, 2016 @ Full Stack Talks

3. OTP
• Erlang
• Tools
• Libraries
• Design Principles
• Other Stuff

4. Processes

5. iex(1)>

6. iex(1)> spawn(fn -> IO.puts “Hello Full Stack” end)

7. iex(1)> spawn(fn -> IO.puts “Hello Full Stack” end)
Hello Full Stack
#PID<0.64.0>
iex(2)>

8. iex(2)> pid = spawn(fn -> IO.puts “Hello Full Stack” end)
Hello Full Stack
#PID<0.65.0>
iex(3)> Process.alive?(pid)
false
iex(4)>

9. Error Handling

10. Supervisors

12. “The Zen of Erlang”

17. Messages

18. FantasyTeam

19. State

20. defmodule FantasyTeam.Basic do
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end
end

21. defmodule FantasyTeam.Basic do
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
...

22. defmodule FantasyTeam.Basic do
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
...

23. defmodule FantasyTeam.Basic do
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
...

24. defmodule FantasyTeam.Basic do
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
...

25. defmodule FantasyTeam.Basic do
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
...

26. def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, state)
loop(new_state)

27. def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, state)
loop(new_state)

28. def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, state)
loop(new_state)

29. def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, state)
loop(new_state)

30. def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, state)
loop(new_state)

31. def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, state)
loop(state)

32. def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, state)
loop(state)

33. def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, state)
loop(state)

34. iex(1)>

35. iex(1)> pid = FantasyTeam.Basic.start_link
#PID<0.65.0>
iex(2)>

36. iex(1)> pid = FantasyTeam.Basic.start_link
#PID<0.65.0>
iex(2)> send(pid, {:add, “Russell Wilson”})
{:add, “Russell Wilson”}
iex(3)>

37. iex(1)> pid = FantasyTeam.Basic.start_link
#PID<0.65.0>
iex(2)> send(pid, {:add, “Russell Wilson”})
{:add, “Russell Wilson”}
iex(3)> send(pid, {:add, “Doug Baldwin”})
{:add, “Doug Baldwin”}
iex(4)>

38. iex(1)> pid = FantasyTeam.Basic.start_link
#PID<0.65.0>
iex(2)> send(pid, {:add, “Russell Wilson”})
{:add, “Russell Wilson”}
iex(3)> send(pid, {:add, “Doug Baldwin”})
{:add, “Doug Baldwin”}
iex(4)> send(pid, {:remove, “Doug Baldwin”})
{:remove, “Doug Baldwin”}
iex(5)>

39. iex(1)> pid = FantasyTeam.Basic.start_link
#PID<0.65.0>
iex(2)> send(pid, {:add, “Russell Wilson”})
{:add, “Russell Wilson”}
iex(3)> send(pid, {:add, “Doug Baldwin”})
{:add, “Doug Baldwin”}
iex(4)> send(pid, {:remove, “Doug Baldwin”})
{:remove, “Doug Baldwin”}
iex(5)> send(pid, {:team, self})
{:team, #PID<0.123.0>}
iex(6)>

40. iex(1)> pid = FantasyTeam.Basic.start_link
#PID<0.65.0>
iex(2)> send(pid, {:add, “Russell Wilson”})
{:add, “Russell Wilson”}
iex(3)> send(pid, {:add, “Doug Baldwin”})
{:add, “Doug Baldwin”}
iex(4)> send(pid, {:remove, “Doug Baldwin”})
{:remove, “Doug Baldwin”}
iex(5)> send(pid, {:team, self})
{:team, #PID<0.123.0>}
iex(6)> flush
{:ok, %{“Russell Wilson” => %{position: “QB”, team: “SEA”}}

41. defmodule FantasyTeam.Basic do
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end
end

42. GenServer

43. defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
end
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
def init(:ok) do
{:ok, %{}}
end
def handle_cast({:add, name}, state) do
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
{:noreply, new_state}
end
def handle_cast({:remove, name}, state) do
new_state = Map.delete(state, name)
{:noreply, new_state}
end
def handle_call(:team, _from, state) do
{:reply, state, state}
end
end
defmodule FantasyTeam.Basic do
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end
end

44. defmodule FantasyTeam.MyGenServer do
use GenServer
defmodule FantasyTeam.Basic do
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end
end

45. def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
# Callbacks
def init(:ok) do
{:ok, %{}}
end
def handle_cast({:add, name}, state) do
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
{:noreply, new_state}
end
def handle_cast({:remove, name}, state) do
new_state = Map.delete(state, name)
{:noreply, new_state}
end
def handle_call(:team, _from, state) do
{:reply, state, state}
end
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end

46. def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
# Callbacks
def init(:ok) do
{:ok, %{}}
end
def handle_cast({:add, name}, state) do
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
{:noreply, new_state}
end
def handle_cast({:remove, name}, state) do
new_state = Map.delete(state, name)
{:noreply, new_state}
end
def handle_call(:team, _from, state) do
{:reply, state, state}
end
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end

47. def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
# Callbacks
def init(:ok) do
{:ok, %{}}
end
def handle_cast({:add, name}, state) do
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
{:noreply, new_state}
end
def handle_cast({:remove, name}, state) do
new_state = Map.delete(state, name)
{:noreply, new_state}
end
def handle_call(:team, _from, state) do
{:reply, state, state}
end
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end

48. def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
# Callbacks
def init(:ok) do
{:ok, %{}}
end
def handle_cast({:add, name}, state) do
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
{:noreply, new_state}
end
def handle_cast({:remove, name}, state) do
new_state = Map.delete(state, name)
{:noreply, new_state}
end
def handle_call(:team, _from, state) do
{:reply, state, state}
end
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end

49. def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
# Callbacks
def init(:ok) do
{:ok, %{}}
end
def handle_cast({:add, name}, state) do
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
{:noreply, new_state}
end
def handle_cast({:remove, name}, state) do
new_state = Map.delete(state, name)
{:noreply, new_state}
end
def handle_call(:team, _from, state) do
{:reply, state, state}
end
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end

50. def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
# Callbacks
def init(:ok) do
{:ok, %{}}
end
def handle_cast({:add, name}, state) do
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
{:noreply, new_state}
end
def handle_cast({:remove, name}, state) do
new_state = Map.delete(state, name)
{:noreply, new_state}
end
def handle_call(:team, _from, state) do
{:reply, state, state}
end
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end

51. def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
# Callbacks
def init(:ok) do
{:ok, %{}}
end
def handle_cast({:add, name}, state) do
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
{:noreply, new_state}
end
def handle_cast({:remove, name}, state) do
new_state = Map.delete(state, name)
{:noreply, new_state}
end
def handle_call(:team, _from, state) do
{:reply, state, state}
end
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end

52. def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
# Callbacks
def init(:ok) do
{:ok, %{}}
end
def handle_cast({:add, name}, state) do
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
{:noreply, new_state}
end
def handle_cast({:remove, name}, state) do
new_state = Map.delete(state, name)
{:noreply, new_state}
end
def handle_call(:team, _from, state) do
{:reply, state, state}
end
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end

53. def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
# Callbacks
def init(:ok) do
{:ok, %{}}
end
def handle_cast({:add, name}, state) do
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
{:noreply, new_state}
end
def handle_cast({:remove, name}, state) do
new_state = Map.delete(state, name)
{:noreply, new_state}
end
def handle_call(:team, _from, state) do
{:reply, state, state}
end
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end

54. def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
# Callbacks
def init(:ok) do
{:ok, %{}}
end
def handle_cast({:add, name}, state) do
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
{:noreply, new_state}
end
def handle_cast({:remove, name}, state) do
new_state = Map.delete(state, name)
{:noreply, new_state}
end
def handle_call(:team, _from, state) do
{:reply, state, state}
end
def start_link do
spawn_link(__MODULE__, :loop, [%{}])
end
def loop(state) do
receive do
{:add, name} ->
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
loop(new_state)
{:remove, name} ->
new_state = Map.delete(state, name)
loop(new_state)
{:team, pid} ->
send(pid, {:ok, state})
loop(state)
end
end

55. defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

56. defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

57. defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

58. defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

59. defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

60. defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

61. defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

62. defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

63. defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

64. defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

65. defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

66. defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
def init(:ok) do
{:ok, %{}}
end
def handle_cast({:add, name}, state) do
player = FantasyTeam.Player.find(name)
new_state = Map.put(state, name, player)
{:noreply, new_state}
end
def handle_cast({:remove, name}, state) do
new_state = Map.delete(state, name)
{:noreply, new_state}
end
def handle_call(:team, _from, state) do
{:reply, state, state}
end
end

67. defmodule FantasyTeam.SingleServer do
use GenServer
@name __MODULE__
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, name: @name)
end
def add(name) do
GenServer.cast(@name, {:add, name})
def
def remove(name) do
GenServer.cast(@name, {:remove, name})
end
def team do
GenServer.call(@name, :team)
end
# Callbacks
...
defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

68. defmodule FantasyTeam.SingleServer do
use GenServer
@name __MODULE__
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, name: @name)
end
def add(name) do
GenServer.cast(@name, {:add, name})
def
def remove(name) do
GenServer.cast(@name, {:remove, name})
end
def team do
GenServer.call(@name, :team)
end
# Callbacks
...
defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

69. defmodule FantasyTeam.SingleServer do
use GenServer
@name __MODULE__
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, name: @name)
end
def add(name) do
GenServer.cast(@name, {:add, name})
def
def remove(name) do
GenServer.cast(@name, {:remove, name})
end
def team do
GenServer.call(@name, :team)
end
# Callbacks
...
defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

70. defmodule FantasyTeam.SingleServer do
use GenServer
@name __MODULE__
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, name: @name)
end
def add(name) do
GenServer.cast(@name, {:add, name})
def
def remove(name) do
GenServer.cast(@name, {:remove, name})
end
def team do
GenServer.call(@name, :team)
end
# Callbacks
...
defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

71. defmodule FantasyTeam.SingleServer do
use GenServer
@name __MODULE__
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, name: @name)
end
def add(name) do
GenServer.cast(@name, {:add, name})
def
def remove(name) do
GenServer.cast(@name, {:remove, name})
end
def team do
GenServer.call(@name, :team)
end
# Callbacks
...
defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

72. defmodule FantasyTeam.SingleServer do
use GenServer
@name __MODULE__
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, name: @name)
end
def add(name) do
GenServer.cast(@name, {:add, name})
def
def remove(name) do
GenServer.cast(@name, {:remove, name})
end
def team do
GenServer.call(@name, :team)
end
# Callbacks
...
defmodule FantasyTeam.MyGenServer do
use GenServer
# API
def start_link do
GenServer.start_link(__MODULE__, :ok, [])
end
def add(pid, name) do
GenServer.cast(pid, {:add, name})
def
def remove(pid, name) do
GenServer.cast(pid, {:remove, name})
end
def team(pid) do
GenServer.call(pid, :team)
end
# Callbacks
...

73. iex(1)>

74. iex(1)> FantasyTeam.SingleServer.start_link
{:ok, #PID<0.65.0>}
iex(2)>

75. iex(1)> FantasyTeam.SingleServer.start_link
{:ok, #PID<0.65.0>}
iex(2)> FantasyTeam.SingleServer.add(“Russell Wilson”)
:ok
iex(3)>

76. iex(1)> FantasyTeam.SingleServer.start_link
{:ok, #PID<0.65.0>}
iex(2)> FantasyTeam.SingleServer.add(“Russell Wilson”)
:ok
iex(3)> FantasyTeam.SingleServer.add(“Doug Baldwin”)
:ok
iex(4)>

77. iex(1)> FantasyTeam.SingleServer.start_link
{:ok, #PID<0.65.0>}
iex(2)> FantasyTeam.SingleServer.add(“Russell Wilson”)
:ok
iex(3)> FantasyTeam.SingleServer.add(“Doug Baldwin”)
:ok
iex(4)> FantasyTeam.SingleServer.remove(“Doug Baldwin”)
:ok
iex(5)>

78. iex(1)> FantasyTeam.SingleServer.start_link
{:ok, #PID<0.65.0>}
iex(2)> FantasyTeam.SingleServer.add(“Russell Wilson”)
:ok
iex(3)> FantasyTeam.SingleServer.add(“Doug Baldwin”)
:ok
iex(4)> FantasyTeam.SingleServer.remove(“Doug Baldwin”)
:ok
iex(5)> FantasyTeam.SingleServer.team
%{“Russell Wilson” => %{position: “QB”, team: “SEA”}}
iex(6)>

79. Recap

80. Agents & Tasks

81. defmodule FantasyTeam.MyAgent do
def start_link do
Agent.start_link(fn -> %{} end)
end
def add(pid, name) do
player = FantasyTeam.Player.find(name)
Agent.get_and_update(pid, fn(x) -> {player, Map.put(x, name, player)} end)
:ok
end
def remove(pid, name) do
Agent.update(pid, fn(x) -> Map.delete(x, name) end)
end
def team(pid) do
Agent.get(pid, fn(x) -> x end)
end
end

82. bit.ly/fullstackotp
OTP / ELIXIR RESOURCES
@jessejanderson
FOLLOW ME