• interactive session: iex -S mix phx.server
• not interactive session: mix phx.server

• IRC
• Discord
• Elixir Forum
• Stack Overflow
• Twitter
• Web Application Security Best Practices for BEAM languages

Ecto

Plug

ExUnit

Gettext

Swoosh

Phoenix HTML

Phoenix PubSub

It holds all compilation artifacts.

This directory contains the front end code e.g. JavaScript and CSS.

This directory contains all the configuration data of the application.

This directory contains all dependencies installed by mix.

lib contains the application source code.

This directory holds data that is necessary in production but are not source code — e.g. priv/static can contain images, priv/static/assets contains generated from files in assets.

This directory contains tests and usually mirrors lib.

This directory contains:

• application.ex defines an Elixir application, in particular, how to start it. Starting the application means starting a number of processes in order. These are defined and started in start/2.
• mailer.ex defines a module to send emails.
• repo.ex defines a module to interact with a DB

It gives an implementation to this actor computation.

1. Add a new route that points to a controller — e.g. /hello points to HelloController.
2. Add the new controller and make its view — e.g. HelloHTML

1. It is a function : Plug.Conn Options → Plug.Conn
It is a module m such that:
• m.init : Options → Options
• m.call : Plug.Conn Options → Plug.Conn

In the context where plug is defined:

• endpoint
• router
• controller

It tells that the next plug will not be called.

• A route is: Verb x Path x Action
• mix phx.routes

• A resource is a type of data that a client can interact with using a given set of HTTP requests.
• For a resource user, the set of requests is: GET /users HelloWeb.UserController :index GET /users/:id/edit HelloWeb.UserController :edit GET /users/new HelloWeb.UserController :new GET /users/:id HelloWeb.UserController :show POST /users HelloWeb.UserController :create PATCH /users/:id HelloWeb.UserController :update PUT /users/:id HelloWeb.UserController :update DELETE /users/:id HelloWeb.UserController :delete

• Using resource users under a given scope in the router.
• Generated routes may be selected using the option only: [:index, :show]
• Or except: [:delete]
• Resources may be nested.

By using :verified_routes.

This code will check routes against the router's routes at compile time.

By using scopes. For instance:

Which gives:

• A pipeline is a plug built by composing plugs — i.e. p = p1 |> p2 …
• To build a pipeline, one may use: pipeline :browser do plug :accepts, ["html"] … plug :put_secure_browser_headers end
• The pipeline may be used within a scope: scope "/reviews", HelloWeb do pipe_through [:browser, :auth] resources "/", ReviewController end

• An anonymous user can read the list of reviews.
• An anonymous user can read a review.
• An authentified user can create a review.

By using the forward macro.

1. A controller gives meaning to a request — i.e. an HTTP request may be viewed as a message received from the client and the controller is the computation that follows.
2. A controller function is called an action.
3. To build a Controller for a given application hello, it is enough to define a module: defmodule HelloWeb.PageController do use HelloWeb, :controller … end
4. To use a controller, it is enough to connect a route to one of its actions.

• index - renders a list of all items of the given resource type
• show - renders an individual item by ID
• new - renders a form for creating a new item
• create - receives parameters for one new item and saves it in a data store
• edit - retrieves an individual item by ID and displays it in a form for editing
• update - receives parameters for one edited item and saves the item to a data store
• delete - receives an ID for an item to be deleted and deletes it from a data store

• text(conn, …)
• json(conn, …)
• conn |> assign(:messenger, messenger) |> render(:show)

Using render implies that a show templates exists and an associated view module.

• Any format will do as more may be added.
• JSON views are already ready to be used.
• Check the MIME library for specifics.

• By using send_resp/3.
• And put_resp_content_type/2
• and put_status/2

For instance, if a user sends data to build a resource, he should then be re-directed to an other page. Using the redirect/2 function.

Flash messages are short transient messages presented to the user. A flash message may be used to inform him about the status of an action.

1. A recurring pattern is to assign values to variables into templates in order to build HTML fragments.
2. Composing these framents build an HTML page.
3. To build a function component, it is enough to define a function Assigns → HEEx using use Phoenix.Component.

1. HTML needs to be generated from assigns.
2. HTML is static, so a DSL that augments HTML with programming constructs is built: HEEx.
3. To build an HEEx template, it is enough to use <%= … %>, <% … %>, @… and save the result as an otherwise HTML document/fragment in a .heex file.
4. To use it, it may be included as part of a view using embed_templates/1 so that it is turned into a function component.
5. HTML extensions may be used, for instance:

   Hello <%= @username %>

   Hello <%= @username %>

1. The root layout hardly changes.
2. There is a concept of LiveView which do not change root layouts but app layouts.