Learn web development with Elixir. We use GenServer Behaviour for a stateful backend. The front-end will use Phoenix Channels to communicate with the backend.

Functional Web Development with  Elixir, OTP and Phoenix by The Pragmatic Programmer_ .png

elixir_islands_test.tar.gz

elixir-app

pheonix-app

elixir-app-guesses

island-interface

phoenix-app-compiled

phoenix-app-iex

phoenix-app-form

phoenix-app-new-module

client-connection

presence

phoenix-app-final

without-presence

Elixir and OTP provide exceptional tools to build rock-solid backend applications that scale. In this course, you’ll build a web application in a radically different way, with a backend that holds application state. You’ll use persistent Phoenix Channel connections instead of HTTP’s request-response, and create the full application in distinct, decoupled layers.

In Part 1, you’ll start by building the business logic as a separate application, without Phoenix. You’ll model the application domain with Elixir functions and simple data structures.

In Part 2, you’ll add in the GenServer Behaviour to make managing in-memory state a breeze. 

In Part 3, you’ll build a web interface with Phoenix where you’ll use Phoenix Channels to establish persistent connections between the stateful server and a stateful front-end client.

Needless to say, you’re going to love this way of building web apps!

Functional Web Development with Elixir, OTP and Phoenix

Modern-day hardware and software make it possible to create stateful web applications?

Modern-day hardware and software make it possible to create stateful web applications?

The Elixir ecosystem has no built-in support for implementing finite state machines?

The Elixir ecosystem has no built-in support for implementing finite state machines?

The catchall ( :error ) clause in a state machine implementation should be placed before all the other clauses.

The catchall ( :error ) clause in a state machine implementation should be placed before all the other clauses.

```elixir
def check(%Rules{state: :initial} = rules, :insert_coin), do: { :error, %Rules{rules | state: :payment_started} }
```

```elixir
def check(%Rules{state: :initial} = rules, :insert_coin), do: { :ok, rules | state: :payment_started }
```

```elixir
def check(%Rules{state: :initial} = rules, :insert_coin), do: { :error, rules | state: :payment_started }
```

```elixir
def check(%Rules{state: :initial} = rules, :insert_coin), do: { :ok, %Rules{rules | state: :payment_started} }
```

We are implementing a vending machine. It has an `:initial` state from which inserting a coin causes a transition to a state `:payment_started`. Which of the following is the best implementation for this state transition?

We are implementing a vending machine. It has an <code>:initial</code> state from which inserting a coin causes a transition to a state <code>:payment_started</code>. Which of the following is the best implementation for this state transition?

```elixir
def check(%Rules{state: :payment_started} = rules, {:dispense, balance} ) do
  case Map.fetch!(rules) do
     :insufficient_balance -> {:ok, rules}
     :sufficient_balance -> :error
  end
end


```elixir
def check(%Rules{state: :payment_started} = rules, {:dispense, balance} ) do
  case Map.fetch!(rules, balance) do
     :insufficient_balance -> :error
     :sufficient_balance -> {:ok, rules}
  end
end
```


```elixir
def check(%Rules{state: :payment_started} = rules, {:dispense} ) do
  case Map.fetch!(rules, balance) do
     :insufficient_balance -> {:ok, rules}
     :sufficient_balance -> :error
  end
end
```

```elixir
def check(%Rules{state: :dispense} = rules, {:payment_started, balance} ) do
  case Map.fetch!(rules, balance) do
     :insufficient_balance -> :error
     :sufficient_balance -> {:ok, rules}
  end
end
```

In a vending machine implementation, we want to check if the balance is sufficient before dispensing a drink. Which of the following is the best implementation?

In a vending machine implementation, we want to check if the balance is sufficient before dispensing a drink. Which of the following is the best implementation?

Let's test our understanding of the concepts covered so far.

Introduction

Mapping Our Route

Model Data and Behavior

Working of State Machines

Add OTP for Concurrency and Fault Tolerance

Process Supervision for Recovery

Generate a New Web Interface with Phoenix

Create Persistent Connections with Phoenix Channels

Appendix

Quiz