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

# What we have learned so far 

We’ve done a lot of great work in this chapter. We’ve built a state machine from scratch and encapsulated all the rules of Islands with a data structure and a handful of clauses for a single function.

Along the way, we learned a lot about finite state machines in general. We learned to map events to states to make decisions about behavior. We also learned to manage state and state transitions.

The implementation we came up with is completely decoupled from any other module we’ve written so far. It can decide whether actions follow the rules independently and without any knowledge of the application logic for the rest of the game.

# Get ready for the next step 

Now we’re ready to put all the work we’ve done so far together in a single entity, with a single interface. As we move into the next part of the course, we define a `GenServer` for the game. In it, we’ll get the application logic working together with the rules.

By the end of the next few lessons, Islands is going to take shape. It’s going to feel a lot more like a complete game. Let’s get to it!

Get a brief introduction to what we've covered so far.

Wrapping Up 

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

Wrapping Up

What we have learned so far