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

## Check for overlaps
Islands have a little bit more to do during a game. 

An island has a role to play in three actions we’ve defined in the game: 
* Positioning islands
* Guessing coordinates 
* Checking for a forested island

Since we’ve chosen `MapSets` to store coordinates and hit coordinates, we have some powerful functions to help us out.

One thing we want to check when positioning islands is that they don’t overlap. We could rely solely on the front end to do this for us. However, it’s easy to check for and good to have backup validation on the back-end.

We’re representing islands as sets of coordinates. One way to determine if islands overlap is to look for any coordinates they have in common. If there are any shared coordinates between two islands, those islands overlap.

There’s a great function to test for this: `MapSet.disjoint?/2`. **Disjointed sets** share no members. If the coordinates of the two islands are disjointed, they don’t overlap.
```Elixir
def overlaps?(existing_island, new_island), do:
   not MapSet.disjoint?(existing_island.coordinates, new_island.coordinates)
```

After adding this to `island.ex`, the file should look like the following (additions are highlighted):

# Check for overlaps
Islands have a little bit more to do during a game. 

An island has a role to play in three actions we’ve defined in the game: 
* Positioning islands
* Guessing coordinates 
* Checking for a forested island

Since we’ve chosen `MapSets` to store coordinates and hit coordinates, we have some powerful functions to help us out.

One thing we want to check when positioning islands is that they don’t overlap. We could rely solely on the front end to do this for us. However, it’s easy to check for and good to have backup validation on the back-end.

We’re representing islands as sets of coordinates. One way to determine if islands overlap is to look for any coordinates they have in common. If there are any shared coordinates between two islands, those islands overlap.

There’s a great function to test for this: `MapSet.disjoint?/2`. **Disjointed sets** share no members. If the coordinates of the two islands are disjointed, they don’t overlap.
```Elixir
def overlaps?(existing_island, new_island), do:
   not MapSet.disjoint?(existing_island.coordinates, new_island.coordinates)
```

After adding this to `island.ex`, the file should look like the following (additions are highlighted):

Islands in Action

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

Islands in Action

Check for overlaps