Gain insights into building scalable backend applications with Elixir, OTP, and Phoenix. Learn about persistent connections via Phoenix Channels, and explore distinct, decoupled application layers.

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

## The game engine
Now that we have a new Application to act as the web interface, we need to bring the game engine in as a dependency. The interface needs to have access to all the game logic we wrote so far in the course. In particular, it must be able to see all the public functions in the `IslandsEngine.Game` module.

This works just like any other dependency in Elixir and is about as easy as it can possibly be. Only two steps are involved.

We need to compile `IslandsEngine` with the rest of the project and start it when we start the `IslandsInterface` Application.

## Changes to `mix.exs`

To make `:islands_engine` a compile-time dependency, we’ve added it to the `deps/0` function in `/islands_interface/mix.exs`:
```Elixir
defp deps do [
  {:phoenix, "~> 1.3.0"},
  {:phoenix_pubsub, "~> 1.0"},
  {:phoenix_html, "~> 2.10"}, 
  {:phoenix_live_reload, "~> 1.0", only: :dev},
  {:gettext, "~> 0.11"},
  {:cowboy, "~> 1.0"},
  {:islands_engine, path: "../islands_engine"}
]
end
```

Notice that we use a path dependency for `:islands_engine`. This allows us to provide the pathname to a project on the local filesystem. The Elixir package manager, **Hex**, takes care of the rest. That’s it. We can give this a try in the console by running `iex -S mix phx.server` at the root of the `islands_interface` project.

# The game engine
Now that we have a new Application to act as the web interface, we need to bring the game engine in as a dependency. The interface needs to have access to all the game logic we wrote so far in the course. In particular, it must be able to see all the public functions in the `IslandsEngine.Game` module.

This works just like any other dependency in Elixir and is about as easy as it can possibly be. Only two steps are involved.

We need to compile `IslandsEngine` with the rest of the project and start it when we start the `IslandsInterface` Application.

# Changes to `mix.exs`

To make `:islands_engine` a compile-time dependency, we’ve added it to the `deps/0` function in `/islands_interface/mix.exs`:
```Elixir
defp deps do [
  {:phoenix, "~> 1.3.0"},
  {:phoenix_pubsub, "~> 1.0"},
  {:phoenix_html, "~> 2.10"}, 
  {:phoenix_live_reload, "~> 1.0", only: :dev},
  {:gettext, "~> 0.11"},
  {:cowboy, "~> 1.0"},
  {:islands_engine, path: "../islands_engine"}
]
end
```

Notice that we use a path dependency for `:islands_engine`. This allows us to provide the pathname to a project on the local filesystem. The Elixir package manager, **Hex**, takes care of the rest. That’s it. We can give this a try in the console by running `iex -S mix phx.server` at the root of the `islands_interface` project.

Learn how to add a new dependency in the game engine.

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

Visualizing Live Streaming Data with Elixir, Kafka, and Chart.js

Appendix

Add a New Dependency

The game engine

Changes to `mix.exs`

Visualizing Live Streaming Data with Elixir, Kafka, and Chart.js

Add a New Dependency

The game engine

Changes to mix.exs

Changes to `mix.exs`