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

## Cleaning up the tables
We’re saving the state of each game in the `:game_state` table, but so far, we haven’t removed that state when the game is over. The `:game_state` table continues to grow and use memory unless we delete a game’s key from the `:game_state` table when the supervisor terminates the child process or when the child process times out.

To clean that data up when a game ends normally, we add a call to `:ets.delete/2` in the `GameSupervisor.stop_game/1` function:
```Elixir
def stop_game(name) do
  :ets.delete(:game_state, name)
  Supervisor.terminate_child(__MODULE__, pid_from_name(name))
end
```

# Cleaning up the tables
We’re saving the state of each game in the `:game_state` table, but so far, we haven’t removed that state when the game is over. The `:game_state` table continues to grow and use memory unless we delete a game’s key from the `:game_state` table when the supervisor terminates the child process or when the child process times out.

To clean that data up when a game ends normally, we add a call to `:ets.delete/2` in the `GameSupervisor.stop_game/1` function:
```Elixir
def stop_game(name) do
  :ets.delete(:game_state, name)
  Supervisor.terminate_child(__MODULE__, pid_from_name(name))
end
```

Cleaning Up After a Game

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

Cleaning Up After a Game

Cleaning up the tables