Functional Web Development with Elixir, OTP, and Phoenix

Rethink the Modern Web App

by: Lance Halvorsen

Published 2018-01-24
Internal code lhelph
Print status In Print
Pages 218
User level Intermediate
Keywords Elixir, Erlang, OTP, Phoenix, transaction, scalable, security, ruby, rails, apps, tech stack, channels, stateful
Related titles

Programming Phoenix
Programming Elixir
Metaprogramming Elixir

ISBN 9781680502435
Other ISBN Channel epub: 9781680505443
Channel PDF: 9781680505450
Kindle: 9781680505429
Safari: 9781680505436
Kindle: 9781680505429
BISACs COM060090 COMPUTERS / Internet / Application Development
COM051440 COMPUTERS / Software Development & Engineering / Tools
COM051440 COMPUTERS / Software Development & Engineering / Tools
https://media.pragprog.com/covers/lhelph.jpg

Highlight

Elixir and Phoenix are generating tremendous excitement as an unbeatable platform for building modern web applications. For decades OTP has helped developers create incredibly robust, scalable applications with unparalleled uptime. Make the most of them as you build a stateful web app with Elixir, OTP, and Phoenix. Model domain entities without an ORM or a database. Manage server state and keep your code clean with OTP Behaviours. Layer on a Phoenix web interface without coupling it to the business logic. Open doors to powerful new techniques that will get you thinking about web development in fundamentally new ways.

Description

Elixir and OTP provide exceptional tools to build rock-solid back-end applications that scale. In this book, you’ll build a web application in a radically different way, with a back end 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, start by building the business logic as a separate application, without Phoenix. Model the application domain with Elixir functions and simple data structures. By keeping state in memory instead of a database, you can reduce latency and simplify your code. In Part 2, add in the GenServer Behaviour to make managing in-memory state a breeze. Create a supervision tree to boost fault tolerance while separating error handling from business logic.

Phoenix is a modern web framework you can layer on top of business logic while keeping the two completely decoupled. In Part 3, you’ll do exactly that as you build a web interface with Phoenix. Bring in the application from Part 2 as a dependency to a new Phoenix project. Then use ultra-scalable Phoenix Channels to establish persistent connections between the stateful server and a stateful front-end client.

You’re going to love this way of building web apps!

Contents and Extracts

  • Define the Functional Core in Elixir
    • Model Data and Behavior
      • The Benefits
      • Let’s Build It
      • Discover the Entities and Model the Domain
      • Transforming Data
      • Putting the Pieces Together
      • Wrapping Up
    • Manage State with a State Machine
      • A Quick Look at State
      • A Bit of History
      • State Machines
      • A Functional State Machine for Islands
      • Working Through the States
      • Wrapping Up
  • Add OTP for Concurrency and Fault Tolerance
    • Wrap It Up in a GenServer
      • A Look at Micro-Services
      • OTP Solutions
      • Getting Started with GenServer <b>excerpt</b>
      • Initializing GenServer State
      • Customizing GenServer Behavior
      • Naming GenServer Processes
      • Wrapping Up
    • Process Supervision for Recovery
      • Fault Tolerance
      • Linking Processes
      • Introducing the Supervisor Behaviour
      • Supervision Strategies
      • The Child Specification
      • A Supervisor for the Game
      • Starting the Supervision Tree
      • Starting and Stopping Child Processes
      • Putting the Pieces Together
      • Recovering State After a Crash
      • Wrapping Up
  • Add a Web Interface with Phoenix
    • Generate a New Web Interface with Phoenix <b>excerpt</b>
      • Frameworks
      • Applications
      • Generate a New Phoenix Application
      • Adding a New Dependency
      • Call the Logic from the Interface
      • Wrapping Up
    • Create Persistent Connections with Phoenix Channels
      • The Beauty of Channels
      • The Pieces That Make a Channel
      • Let’s Build It
      • Establish a Client Connection
      • Converse Over a Channel
      • Connect the Channel to the Game
      • Phoenix Presence
      • Authorization
      • Wrapping Up