State Machines in Elixir

Great software should be easy to understand and improve, but usually, developers tend to bring unnecessary complexity to the code base. Building a state machine is one of those things that usually brings a lot of boilerplate and overall complexity with it, but what if we had a better and simple way to build states machines while keeping our sanity, simplicity, and capacity to easily extend it?

In this talk we’ll understand state machines:
- how it’s a well-defined concept that developers all around have been using
- how implementing it without thinking about it can lead to some really nasty code smells
- what solutions we have for it in the Elixir ecosystem

But we won’t stop there, I’ll also share how I have been through it and solved this problem myself by building an opensource library called Machinery, and how it can help you to build nice, clean and expandable state machines while providing you with some great features.

Transcript

1. State Machines State Machines in Elixir in Elixir with Machinery @joaomdmoura
2. State Machines State Machines in Elixir in Elixir with Machinery @joaomdmoura Avoiding Complexity in Software Design Software Design
3. State Machines State Machines in Elixir in Elixir with Machinery @joaomdmoura That time I fell from a Stakeboard Stakeboard
5. This shit is easy
11. things can get things can get complex complex really fast really fast
12. design design matters matters
14. Quality code has low cost for changes
15. state state machines machines
16. Joao Moura Engineering Manager and Speaker @joaomdmoura facebook.com/joaomdmouradev
17. state state what? what?
18. It is an abstract machine that can be in exactly one of a finite number of states at any given time.
20. empty Shopping Cart Shopping Cart filled payed abandoned
21. empty Shopping Cart Shopping Cart filled payed abandoned add item leave checkout
22. Where will this logic live?
24. empty lock items add item in stock? no yes filled
25. State State State State empty lock items add item in stock? no yes filled
26. Guard Guard Callbacks Callbacks empty lock items add item in stock? no yes filled
27. empty lock items add item in stock? no yes filled checkout leave payed? no payed yes abandoned unblock items
28. Where will this logic live?
30. Shopping Carts Shopping Carts Users States Users States Orders Orders Messages Messages
34. 20 20 states states
39. Elixir Elixir
40. Functions must not Functions must not updates values outside of it updates values outside of it
41. Functions must not Functions must not depend on variables other depend on variables other than its parameters than its parameters
42. "Elixir".downcase # elixir
43. String.downcase("Elixir") # elixir
44. Erlang Erlang
45. gen_statem gen_statem "low-level" implementation for "low-level" implementation for state machines as processes state machines as processes
46. defmodule YourProject.UserStateMachine do @behaviour :gen_statem @name :user_state_machine def start_link do :gen_statem.start_link({:local, @name}, __MODULE__, [], []) end def init([]) do {:ok, :created, %{name: "Joe Doe"}} end def callback_mode do :state_functions end def fill_data do :gen_statem.call(@name, :fill_data) end def completed({:call, from}, :fill_data, data) do {:next_state, :completed, data, [{:reply, from, :ok}]} end end
47. defmodule YourProject.UserStateMachine do @behaviour :gen_statem @name :user_state_machine def start_link do :gen_statem.start_link({:local, @name}, __MODULE__, [], []) end def init([]) do {:ok, :created, %{name: "Joe Doe"}} end def callback_mode do :state_functions end def fill_data do :gen_statem.call(@name, :fill_data) end def completed({:call, from}, :fill_data, data) do {:next_state, :completed, data, [{:reply, from, :ok}]} end end
48. defmodule YourProject.UserStateMachine do @behaviour :gen_statem @name :user_state_machine def start_link do :gen_statem.start_link({:local, @name}, __MODULE__, [], []) end def init([]) do {:ok, :created, %{name: "Joe Doe"}} end def callback_mode do :state_functions end def fill_data do :gen_statem.call(@name, :fill_data) end def completed({:call, from}, :fill_data, data) do {:next_state, :completed, data, [{:reply, from, :ok}]} end end
49. defmodule YourProject.UserStateMachine do @behaviour :gen_statem @name :user_state_machine def start_link do :gen_statem.start_link({:local, @name}, __MODULE__, [], []) end def init([]) do {:ok, :created, %{name: "Joe Doe"}} end def callback_mode do :state_functions end def fill_data do :gen_statem.call(@name, :fill_data) end def completed({:call, from}, :fill_data, data) do {:next_state, :completed, data, [{:reply, from, :ok}]} end end
50. defmodule YourProject.UserStateMachine do @behaviour :gen_statem @name :user_state_machine def start_link do :gen_statem.start_link({:local, @name}, __MODULE__, [], []) end def init([]) do {:ok, :created, %{name: "Joe Doe"}} end def callback_mode do :state_functions end def fill_data do :gen_statem.call(@name, :fill_data) end def completed({:call, from}, :fill_data, data) do {:next_state, :completed, data, [{:reply, from, :ok}]} end end
51. defmodule YourProject.UserStateMachine do @behaviour :gen_statem @name :user_state_machine def start_link do :gen_statem.start_link({:local, @name}, __MODULE__, [], []) end def init([]) do {:ok, :created, %{name: "Joe Doe"}} end def callback_mode do :state_functions end def fill_data do :gen_statem.call(@name, :fill_data) end def completed({:call, from}, :fill_data, data) do {:next_state, :completed, data, [{:reply, from, :ok}]} end end
52. defmodule YourProject.UserStateMachine do @behaviour :gen_statem @name :user_state_machine def start_link do :gen_statem.start_link({:local, @name}, __MODULE__, [], []) end def init([]) do {:ok, :created, %{name: "Joe Doe"}} end def callback_mode do :state_functions end def fill_data do :gen_statem.call(@name, :fill_data) end def completed({:call, from}, :fill_data, data) do {:next_state, :completed, data, [{:reply, from, :ok}]} end end
53. fsm fsm Fsm is pure functional finite Fsm is pure functional finite state machine state machine
54. defmodule BasicFsm do use Fsm, initial_state: :stopped defstate stopped do # opens the state scope defevent run do # defines event next_state(:running) # transition to next state end end defstate running do defevent stop do next_state(:stopped) end end end
55. Machinery Machinery
56. Declaring Declaring States States
57. defmodule YourProject.UserStateMachine do use Machinery, states: ["created", "partial", "complete"], transitions: %{ "created" => ["partial", "complete"], "partial" => "completed" } end
58. defmodule YourProject.UserStateMachine do use Machinery, states: ["created", "partial", "complete"], transitions: %{ "created" => ["partial", "complete"], "partial" => "completed" } end
59. defmodule YourProject.UserStateMachine do use Machinery, states: ["created", "partial", "complete"], transitions: %{ "created" => ["partial", "complete"], "partial" => "completed" } end
60. defmodule YourProject.UserStateMachine do use Machinery, states: ["created", "partial", "complete"], transitions: %{ "created" => ["partial", "complete"], "partial" => "completed" } end
61. Machinery.transition_to(your_struct, UserStateMachine, "next_state") # {:ok, updated_struct}
62. Machinery.transition_to(your_struct, UserStateMachine, "next_state") # {:ok, updated_struct}
63. Machinery.transition_to(your_struct, UserStateMachine, "next_state") # {:ok, updated_struct}
64. Guard Guard Functions Functions
65. def guard_transition(struct, "complete") do Map.get(struct, :missing_fields) == false end
66. Before and after Before and after callbacks callbacks
67. def before_transition(struct, "complete") do ... struct end def after_transition(struct, "complete") do ... struct end
68. shopping shopping cart cart
69. defmodule FakeProject.ShoppingCartMachine do use Machinery, states: ["empty", "filled", "payed", "abandoned"], transitions: %{ "empty" => "filled", "filled" => ["payed", "abandoned"] } def guard_function(cart, "filled") do Item.has_stock?(cart.item) end def guard_function(cart, "payed") do Payment.status(cart) == :confirmed end def before_transition(cart, "filled") do Item.lock_form_cart(cart) cart end def after_transition(cart, "abadonned") do Item.unlock_form_cart(cart) cart end end
70. defmodule FakeProject.ShoppingCartMachine do use Machinery, states: ["empty", "filled", "payed", "abandoned"], transitions: %{ "empty" => "filled", "filled" => ["payed", "abandoned"] } def guard_function(cart, "filled") do Item.has_stock?(cart.item) end def guard_function(cart, "payed") do Payment.status(cart) == :confirmed end def before_transition(cart, "filled") do Item.lock_form_cart(cart) cart end def after_transition(cart, "abadonned") do Item.unlock_form_cart(cart) cart end end
71. defmodule FakeProject.ShoppingCartMachine do use Machinery, states: ["empty", "filled", "payed", "abandoned"], transitions: %{ "empty" => "filled", "filled" => ["payed", "abandoned"] } def guard_function(cart, "filled") do Item.has_stock?(cart.item) end def guard_function(cart, "payed") do Payment.status(cart) == :confirmed end def before_transition(cart, "filled") do Item.lock_form_cart(cart) cart end def after_transition(cart, "abadonned") do Item.unlock_form_cart(cart) cart end end
72. defmodule FakeProject.ShoppingCartMachine do use Machinery, states: ["empty", "filled", "payed", "abandoned"], transitions: %{ "empty" => "filled", "filled" => ["payed", "abandoned"] } def guard_function(cart, "filled") do Item.has_stock?(cart.item) end def guard_function(cart, "payed") do Payment.status(cart) == :confirmed end def before_transition(cart, "filled") do Item.lock_form_cart(cart) cart end def after_transition(cart, "abadonned") do Item.unlock_form_cart(cart) cart end end
73. bonus bonus
74. defmodule YourApp.Endpoint do # ... plug Machinery.Plug # ... end config :machinery, interface: true, repo: YourApp.Repo, model: YourApp.User, module: YourApp.UserStateMachine
77. state machines state machines everywhere everywhere
78. Machinery Machinery
79. things can get things can get complex complex really fast really fast
81. @joaomdmoura joaomdmoura.com facebook.com/joaomdmouradev