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

Where do we specify a dependency for an application generated using `mix new`?

Where do we specify a dependency for an application generated using <code>mix new</code>?

Such dependencies are not specified in `deps/0`

How are compile-time dependencies specified in the `deps/0` function?

How are compile-time dependencies specified in the <code>deps/0</code> function?

The BEAM would start `:logger` and then the application

The application would start, but not function correctly

An application has a run-time dependency of `:logger`. If `:logger` isn’t running, and we try to start the application, what would happen?

An application has a run-time dependency of <code>:logger</code>. If <code>:logger</code> isn’t running, and we try to start the application, what would happen?

```elixir
<%= form_tag("/test") do [tag(:input, type: "text", name: "First name"), 
tag(:input, type: "text", name: "Last name"),
tag(:input, type: "submit", value: "Connect")] end%>
```

```elixir
<%= form_tag("/connect") do [tag(:input, type: "text", name: "First name"), 
tag(:input, type: "text", name: "Last name"),
tag(:input, type: "submit", value: "Connect")] end%>
```

```elixir
<%= form_tag("/connect") do [tag(:input, type: "submit", name: "First name"), 
tag(:input, type: "text", name: "Last name"),
tag(:input, type: "submit", value: "Connect")] end%>
```

How do we create a form on the `/connect` route in Phoenix that has _first name_ and _last name_ text fields and a _submit_ button?

How do we create a form on the <code>/connect</code> route in Phoenix that has first name and last name text fields and a submit button?

It causes the `get` requests to `/signup` route to be handled by the `shopsite` module’s `signup` function

It causes the `post` requests to `/signup` route to be handled by the `shopsite` module’s `signup` function

It causes the `get` requests to `/signup` route to be handled by the `shopsite.MyController` module’s `signup` function

It causes the `post` requests to `/signup` route to be handled by the `shopsite.MyController` module’s `signup` function

The following definition is given in `router.ex`. What does it do?
```elixir
scope "/", shopsite do
   pipe_through :browser
   get "/", MyController, :index
   post "/signup", MyController, :signup
end
```

The following definition is given in <code>router.ex</code>. What does it do?
<pre><code class="language-elixir">scope &quot;/&quot;, shopsite do
 pipe_through :browser
 get &quot;/&quot;, MyController, :index
 post &quot;/signup&quot;, MyController, :signup
end
</code></pre>

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