The ElixirSips catalog consists of nearly 300 episodes of Elixir content. If you're looking for our updated reboot for getting started with Elixir and Phoenix, check out the Elixir topic.


Each lesson focuses on a single aspect of building the project, like modeling the data, building a GraphQL server in Elixir, or building a mobile client for it in Flutter.


Introduction + Installing Elixir

A quick introduction to the screencast, followed by an Erlang / Elixir installation walkthrough.

Basic Elixir

A quick overview of some of the basic types in Elixir: Atoms, Numbers, Lists, Tuples, Regexes, and Booleans...

Pattern Matching

A discussion of pattern matching in Elixir.


Defining Anonymous Functions; Calling Anonymous Functions; Functions as First Class Types

Mix and Modules

Using mix to begin a new project; Defining a module; Compiling and using a module; `defmodule` return value; Documenting a module; Generating HTML Docs

Unit Testing

ExUnit; Building an example module via TDD; Exercism.io; DocTests

Dynamo, Part 1

Note: Deprecated Episode. Introduction to Dynamo; Creating your first app; Views; Routers

Dynamo, Part 2

Note: Dynamo itself is deprecated. Persistence; Ecto; Amnesia

Dynamo, Part 3

Note: Dynamo itself is deprecated. Integrating Dynamo and Amnesia

List Comprehensions

Generating lists from lists (from lists); A real world example (deck of cards) NOTE: Syntax changes, see Episode 060 for details


Note: Elixir Records in this style are deprecated now. You should likely be using maps instead. Defining Records; Pattern Matching on Records

Processes and messaging

What are processes? Playing with processes; Encapsulating state in a process Note: The `a <- b` syntax has been replaced with `send(a, b)`

Processes, Part 2

Modeling a Bank Account with a Process: Deposit; Withdraw; Balance Inquiry; Command-Query Responsibility Segregation; Event Sourcing


What is OTP?; Implementing GenServer Behaviour; Where to go from here

Finite State Machines

What a Finite State Machine (FSM) is; An example FSM that we'll be implementing; How to implement an FSM in Elixir using OTP's GenFSM.

Pipe Operator

Used for building pipelines of functions; Similar to Unix pipes

Enum, Part 1

all?; any?; at; chunks; chunks_by; concat; count

Enum, Part 2

drop, drop\_while; each; empty?; fetch; filter, filter\_map; find, find\_index, find\_value; first; flat\_map; join

Enum, Part 3

map, map\_join, map\_reduce; max, max\_by, min, min\_by; member?, partition, reduce; reject, reverse, shuffle; slice, sort, split; split\_while, take, take\_every; take_while, to\_list, uniq; with\_index, zip

OTP Part 3 - GenEvent

Building an Entity-Component system in order to begin the zeldacat roguelike game.

Zeldacat, Part 2

Diving further into GenEvent

OTP Part 4 - Supervisors

"Let It Crash" But seriously, do. And then recover.

OTP Part 5 - Supervisors and Persistent State

Storing state in a separate process in order to tolerate a crash without losing track of data.


Ecto, Part 1

A brief introduction to using Ecto with Postgres for persistence.

Ecto, Part 2 - Dwitter

Using Ecto inside a Dynamo web application.

Dict, Part 1

delete; drop; empty; equal?; fetch; get; has_key?; keys; merge

Dict, Part 2

pop; put; put\_new; size; split; take; to\_list; update; update!; values


Parsing XML

Exploring the `xmerl` module that is built into Erlang, and interoperating with it.

HTTP Clients

A survey covering: httpc; ibrowse; hackney


Simplified generation of generic servers.

TCP Servers

Building network servers in Elixir using Erlang's `:gen_tcp` module.

Command Line Scripts

Basic Introduction to writing Elixir scripts that can be invoked and passed arguments from the command line.


A tool to inspect or debug a running process.


An ActiveRecord-like wrapper for Riak in Elixir.


An MVC Web framework for Elixir, with: Flexible routing; Websocket support; Sessions; Grunt integration; Html Helpers

Weber, Part 2 - Performance

Building a simple cache for our API calls; Performance comparison with node.js and ruby


Fantastic logging for your applications.

Binaries - Deconstructing and Constructing

Deconstructing and Constructing lists of bits in Elixir.

Binaries - Deconstructing an IP Packet

Deconstructing an IP Packet.


Manipulating bits; typically useful for wire protocols.

File, Part 1

cd; cp_r; chgrp; cwd; chmod; dir?; chown; exists? close; ls; copy

File, Part 2

mkdir; rmdir; mkdir\_p; stat; open; stream!; read; stream\_to!; regular?; touch; rm; write; rm\_rf; write\_stat


Releases with Relex

Making your Elixir application redistributable using Erlang releases.


Sending messages from one node to another.

Joe Armstrong's Favorite Erlang Program

Sending messages to remote machines, and Joe Armstrong&apos;s favorite program, the universal server.

Markdown Server, Part 1

Building a HTTP Server to render Markdown files, using the Phoenix web framework.

Markdown Server, Part 2

Writing an integration test suite and dealing with macros for the first time.

Markdown Server, Part 3

Using Eml for markup, and bringing in Compass and Zurb Foundation for styles.

Markdown Server, Part 4

Building a poor man&apos;s livereload system using inotify and websockets.

Markdown Server, Part 5

Accepting environment variables for configuration and filtering out files we don&apos;t want. Plus, a call to action to build BEAM Toolbox.

BEAM Toolbox, Part 1

Introducing BEAM Toolbox and starting work on the data layer.

BEAM Toolbox, Part 2

Further work on the data layer, and introducing defoverridable.

BEAM Toolbox, Part 3

Adding an integration testing layer that drives a browser using Hound, extracting a Controller helper, and adding Project pages.


Maps, Part 1

An introduction to maps, a new feature in Erlang R17 and Elixir 0.13


Maps, Part 2

Introducing structs and demonstrating how they can take the place of public Records.

Migrating Records to Maps

Converting a production use of Records to use maps instead.

BEAM Toolbox, Part 4

Moving our ad-hoc tuple-based data layer to one powered by maps/structs.

BEAM Toolbox, Part 5

Building a module that caches our GitHub data for a given project.

Custom Mix Tasks

Looking at building a basic mix task, and how you can go about testing it.

New Style Comprehensions

An old dog got taught a new trick. But the new trick is kind of like 20 tricks in one.


Exploring Elixir&apos;s library for building composable web application modules.


Quickie Synth

Using processes, gs, and shelling out to `sox` to build an Elixir-based synthesizer module.


A quick tour of the `dbg` module from Erlang, and its tracing features.


A look at using the `digraph`module from the Erlang standard library to implement pathfinding on a map.


Using Erlang&apos;s `ssh` module to provide ssh access to a shell running your Elixir code.


Serving static files without an opaque and complicated-looking cowboy handler.

Deploying to Heroku

Using HashNuke&apos;s Elixir buildpack for Heroku to deploy BEAM Toolbox. Also, a brief intro to ExConf.


Interacting with external programs as if they were simple processes.


A graphical tool for inspection of a running Erlang/Elixir system and its processes.


Elixir&apos;s new package manager.


Building a GUI calculator using Erlang&apos;s native wx bindings.

WxCalc, Part 2

Implementing our calculator&apos;s logic and wiring it up to wx events.

Process Dictionaries

Process-local state that you likely should never use :)


Erlang term storage - a queryable database for your processes to store terms in.


A disk-based version of ETS with a few restrictions.


A brief overview of Elixir&apos;s &quot;lazy, composable Enumerables&quot;

Exceptions and Errors

Manually raising exceptions, handling them, defining your own, and using them idiomatically.


A simple abstraction around state.


An abstraction for computing a value in the background and receiving the value later.


A client for the Ubigraph visualization server, and an easy way to view a BEAM application&apos;s supervision tree in 3D.



Elixir&apos;s built-in templating language, useful for embedding Elixir code inside of a string.


A fantastic method for polymorphism in Elixir. Pairs well with structs. Slight oaky flavor.


A replacement for the `pg` module that has some better semantics for distribution.


PCM Audio

Generating PCM Audio and making some noise


Awesome Print for Elixir. An easy way to get insight into unfamiliar data structures.

`put_in` and `get_in`

(and friends) Easy access to deeply nested data structures.


Using Elixir to do a word frequency count on a corpus of text and generate input for a WordCloud generator.


External Process interaction like the Port module but both simpler and more powerful.

Protocol Buffers

Easy cross-language serialization and deserialization of data structures using Google&apos;s Protocol Buffers and exprotobuf.

Websockets Terminal

Taking advantage of Phoenix&apos;s native websockets support to build an in-browser bash terminal proxy.

Test Coverage

Exploring test coverage report generation, using both Erlang&apos;s `cover` application and the Coverex tool.

Link Extractor

Using poolboy to build a service for extracting data from a set of links and collecting them into memory for viewing later.

Link Extractor, Part 2

Using Phoenix to build an HTTP API for posting links into the system, and a page to view posted links.

Link Extractor, Part 3

Deploying our application to a VPS from scratch and pushing in our first message.

Link Extractor Part 4

Fixing some bugs and setting up a Zapier integration.

Arduino Motor Driver

An unusually formatted episode discussing an ad hoc serial protocol for controlling an Arduino Motor Controller.

BEAM Toolbox, Part 6

Resurrecting the Toolbox with an Ecto-based data layer from scratch, and synchronizing data with the Hex API.


Contributing to Open Source

In which we contribute to the elixir codebase and open a pull request.

BEAM Toolbox, Part 7

Managing relationships in Ecto, and integrating Ecto into a Phoenix application.

Beam Toolbox, Part 8

Making the BEAM Toolbox a bit more useful, including adding in Disqus support.

BEAM Toolbox, Part 9

Building a CLI utility for categorizing our projects as a Mix task.

BEAM Toolbox, Part 10

Building a projects listing page, and reviewing some changes to the toolbox.

BEAM Toolbox, Part 11

Switching to the expression style in Ecto, and using Phoenix&apos;s new routing helpers because we must.

Ruby to Elixir via BERT-RPC

Trivial interop between Ruby and Elixir processes using BERT-RPC.

Farkov Chain

Generating killer marketing strategies with Elixir

Text Parsing

Building a parser for a custom text format.

Phoenix Release

Using `exrm` to build a release of the BEAM Toolbox webapp, for deployment.

Release Upgrades

Upgrading a running app to a new version without losing state.


A pleasant abstraction around `gen_tcp`, `gen_udp`, `gen_sctp`, and `ssl`.


A library for interacting with the Twitter API, using standard requests or the streaming responses.

ExTwitter, Part 2

Streaming a Twitter search to the browser, because Phoenix Channels are meant to be paired with Elixir Streams, I promise.


A pleasant-to-use benchmarking tool that includes graph output.

Monitoring Network Traffic

Using libpcap from Elixir to see the stream of data passing across your computer&apos;s network interface.

Wx Keyboard Events

Handling keyboard input in a wx application.

Wx Extris Continued

Making pieces fall and drawing the game board.

Wx Extris Part 3, Refactoring

Turning a gigantic module into something a little more sensible and well-factored.

Wx Extris Part 4 - Testing

Writing some tests and implementing board boundary collision.

Wx Extris Part 5

Defining the bottom game board boundary and providing the next shape when needed.

Wx Extris Part 6 - Concurrent Rendering

Introducing multiple processes into the game, and running the render loop separately from the game logic.

Wx Extris, Part 7

Introducing collision detection and cleaning up the renderer / game board data structure.

Wx Extris, Part 8

Test-driven implementation of clearing full lines off of the board.


Using the SDL library for graphics from your Elixir programs.

SDL Extris

Writing a renderer for the Tetris clone using SDL.


Layering type information over your functions to aid users and static analysis tools, and to catch errors.


Letting the computer (rather than logs or users) tell you when you&apos;ve written crap code.

Piping Into Elixir

Handling typical unix-script style stdin and stdout pipes trivially from your Elixir scripts.

SSH Client Commands

Becoming an SSH client and sending commands to an SSH server with Elixir.

Managing Docker

Programmatically interacting with Docker using Elixir and erldocker.


A module in the Erlang Standard Library meant for doing basic graphics.

Extris Web Client

Using Phoenix&apos;s websockets to build a JavaScript canvas-based renderer and interaction module for Extris games running in processes on the server.


An Elixir profiler, useful for finding where your program is spending its time.

Randomness in the Erlang VM

An exploration of where our randomness in Tetris went so horribly wrong, along with an exposition of how to think about which process your code is running in, and why that&apos;s important.

Boltun - Postgres Listen + Notify

An Elixir package providing fantastically simple support for Postgres&apos;s built-in pubsub notifications.

Elastic Search with Tirexs

An easy way to interact with ElasticSearch.


Another benchmarking tool, with a little bit less setup required.

Interfacing with Asterisk

Using the `erlagi` application from Elixir to control the logic of an extension in a PBX system via Asterisk&apos;s AGI protocol.

Asterisk AGI with Elixir

Building out an erlagi handler module in Elixir that interacts with a remote HTTP API.

Monitors and Links

Two of the core building blocks that the Erlang VM provides. I&apos;d neglected discussing them until now. Oops.


Elixir&apos;s package manager, hex.pm, also provides a documentation server for elixir packages. We&apos;ll see how to push documentation up.


Using `goma`, which is essentially WebMachine for The Internet Gopher Protocol, to build an elixir-power gopher server.


Elixir ships with a Set behaviour, and a default HashSet implementation.


Building quick &apos;binaries&apos; after a fashion using Elixir&apos;s tooling.

Phoenix Generator

A project that adds code generation to Phoenix for building models, controllers, templates, and channels.

Erlang's `calendar` module

Interacting with Erlang&apos;s native date and time types.


An elixir library for trivially specifying relative dates and times.


Easily send emails, parse emails, and verify email related features in your tests using this One Neat Trick.


Generate markup from blocks of elixir code, in the style of _why the lucky stiff&apos;s markaby.

ejabberd with Elixir

Getting started interacting with a battle-hardened XMPP chat server by writing Elixir modules for it.

ejabberd Packet Filters

Modifying messages inside of our ejabberd server, specifically - making everyone yell at each other.


Talking to Elixir from Java

System Information

Exploring a running Erlang system using tools from the shell.


Evaluating javascript on a SpiderMonkey interpreter and getting back Erlang terms.

Phoenix APIs and CORS

Building a basic API with Phoenix, and allowing remote domains to access it from the browser.


Basic TCP/IP interactions built into Erlang&apos;s kernel application for you.

OAuth2 - Code Spelunking

A dig through Sonny Scroggins&apos; example of integrating a Phoenix application with GitHub via his OAuth2 package.

Interacting with Amazon's APIs with erlcloud

A comically brief overview of erlcloud and evidence that it does, in fact, work for me.

Playing with the Code Module, Part 1 - `eval_string`

Exploring the standard library&apos;s Code module&apos;s `eval_string` function for fun and whatnot.

SOAP with Detergentex

Using the `detergentex` library, which wraps the erlang `detergent` library, to interact with SOAP services in Elixir.

Simple One for One Supervisors

Getting a dynamically spawned process into a supervision tree to avoid orphaned processes, among other things.


A less-verbose way to define multiple function clauses, courtesy of Dave Thomas.

Building a Cron System - Part 1

Building a parser for cron-style job definitions.

Building a Cron System, Part 2

Determining if a given time is matched by a Schedule.

Building a Cron System, Part 3

Executing our jobs on their schedule. Bonus intro to defdelegate and ExUnit&apos;s `@tag`s.


Exploring L Systems, on our way to generating fractals.

Accounting 101

Modeling a double-entry ledger. Terribly. And then discussing what went wrong.


Implementing Logo, Part 1

Implementing the Logo graphical programming language in Elixir with wxWidgets. In this episode we just implement the underlying GenServer.

Implementing Logo, Part 2

Building a renderer for our Logo interpreter.


Continuous Integration

Using Semaphore CI to automatically test a Phoenix application each time we push new code.

Fractals, Part 2

Combining our L Systems and our Logo Interpreter to explore drunk sierpinski triangles.

Building a Slack Bot

Using Elixir to build a bot that can respond to messages in our Slack groups.

Erlang 18 and time

Learning how to replace calls to `:erlang.now` with the new API for various use cases. Plus an introduction to the kerl erlang release manager.

Arc File Uploads

Using the `arc` library to enable simple file uploads and image manipulation and versioning in your Phoenix applications.

Deploying Phoenix Applications to Heroku

Using SemaphoreCI to automatically deploy your Phoenix application after the tests run successfully.

ElixirFriends - Saving Tweets with Streams and Filters

Building a Phoenix Application that stores select tweets for display, applying filters, using Twitter&apos;s streaming search.

Pagination with Ecto and Phoenix using Scrivener

Using Scrivener to paginate Ecto queries and display pagination controls on our web pages.

Prettying Up ElixirFriends

Adding SemanticUI to ElixirFriends and making it look a little bit better. Also, we beef up the paginator to know what&apos;s active.

Audio Visualizer

Using ports and wx to build a visualizer for an audio stream.

Memory Leaks

Using :observer to find memory leaks in your system, because the BEAM&apos;s basically on OS.

Rules Engine

Building a Rules Engine and benchmarking a couple of different processing options.


Implementing the Collectable protocol to clean up a common pattern in our code.

Native Compilation with HiPE

Taking further advantage of the power given to us by the almighty BEAM to get faster code for free. Hype hype hype!

Phoenix API

Building out an API endpoint for ElixirFriends in Phoenix

React with Phoenix

Building a React application that interfaces with our Phoenix API for ElixirFriends.

React with Phoenix Channels

Pushing new posts to ElixirFriends into our React application&apos;s state using Phoenix Channels.

Mix Archives

Using Mix to build an Erlang Archive Format file and install it as a local archive.

Automatically Connecting Nodes

Using Erlang&apos;s sys.config file to tell our application to wire a couple of nodes together automatically, and seeing that Phoenix Channels support distribution out of the box.

Compiling a Custom AST Into Elixir Functions

Taking advantage of Elixir&apos;s amazing metaprogramming support to build our own AST and compile it into running functions.


Because writing Elixir is far preferable to writing JavaScript.


Customizing your IEx prompt for productivity and aesthetic purposes.

Testing Phoenix Channels

Looking at the facilities Phoenix provides to assist in writing tests for your channels.

Interesting IO

Building an ANSI Tetris renderer for the TTY using iolists.

Interesting IO, Part 2 - Input with `tty_sl`

Using the underlying port driver that the Erlang &quot;REPL&quot; uses to handle terminal-based input one character at a time.

Linting with Dogma

Examining an up and coming coding style enforcement tool.

Interoperability - Ports

Writing a C program that has an Elixir interface by way of Erlang&apos;s Ports system.


A rapid jaunt through a little spaceship simulator I wrote that has a wx renderer.

Crashing the BEAM

Causing a few of the BEAM&apos;s failure modes so we can see them in a controlled environment...and because breaking things is fun.


Using Ulf Wiger&apos;s `gproc` application to register processes and look them up in interesting ways.


Elixir and Unity3d

Rendering our spaceships simulator in 3D with Unity3D

Modeling a Virtual Machine

Building a register-based virtual machine with 4 registers and 2 instructions. And a bytecode format. And an assembly language.

Custom Types in Ecto

Storing custom types in Ecto models. Specifically, storing a particularly-shaped 2-tuple, and barfing on anything else.

Tracing and Debugging with erlyberly

Tracing function calls in a running Erlang node, which should be massively helpful for debugging.

Exception Monitoring with Honeybadger.io

Monitoring exceptions in your production applications, whether they&apos;re OTP applications, Phoenix applications, or something ad-hoc.


An unbelievably simple plug for adding authentication and role-based authorization to your Plug-based web application.


Enforcing your own custom interfaces with Behaviours in Elixir.

The Opposite of Mocks

A strategy that I employed to get around a module that was particularly opposed to being tested, due to a dependency on being started with a client socket as its argument.

Getting a Nested Module From a String

A few unsafe ways to turn user input into a module, a wrongheaded safe way to do it, and then the correct way to do it.


Integrating with systems that use XMLRPC as their remote execution interface.

Compile-Time Interface Policy Enforcement using `@on_definition`

Making our compiler enforce business-level decisions about how functions in a particular module should be written.

Integration Testing with Hound

Using Hound to drive a browser and test JavaScript behaviour of your Phoenix application.

Visualizing Another Node With `ex_top`

A quick demonstration of the `ex_top` tool for visualizing a remote Erlang node, as well as a bit of code spelunking and a look at the use of the `rpc` module to do cool stuff.

Parsing and Searching HTML With Floki

A really nice library for parsing HTML and finding elements in it using CSS selectors.

Streaming Structured Data From Webpages With Stream.resource

Combining Floki and Stream.resource to turn a static HTML site into a paginating stream of structured data.


Using Rob Conery's `stripity_stripe` library to easily work with Stripe's API.


A tool to visualize your application and trace messages between processes in the browser.

Tracking Performance Metrics with Beaker

A lightweight tool that gives you an instant performance monitoring dashboard for Gauges, Counters, and TimeSeries.

Code Linting with Credo

A code linting tool focused on giving gentle suggestions and providing explanations for the issues it uncovers.

Internationalizing a Phoenix Application with Gettext

An overview of Phoenix's new Gettext support for allowing easy string translation in your app for various locales.


A look at an unbelievably well-built CSV encoding and decoding library that deals exclusively in Streams.

User Authentication with Ueberauth

A library for flexible user authentication, whether from an OAuth provider, a local database, or something else.

Bureaucrat API Documentation

A tool to generate end-user API Documentation from your existing API Controller tests.


Using the festival speech synthesis tool from Elixir.

TDDing an E-Commerce Site With Phoenix, Part 1 - Setup

Kicking off a new project to test-drive a Phoenix app, using Hound for an acceptance test layer.

TDDing an E-Commerce Site With Phoenix, Part 2 - Images

Using Arc to store product images on S3, make thumbnails, and render them in the templates.

TDDing an E-Commerce Site With Phoenix, Part 3 - Cart

Test-Driving a basic cart implementation, which requires adding a LineItem model. Bonus: Josh fixes bugs on the fly and gets really irritated!

TDDing an E-Commerce Site with Phoenix, Part 4 - Multiple Carts

Introducing an actual Cart model. Involves multiple browser sessions with Hound, autogenerating UUID fields in Ecto models, and Elixir&apos;s multi-alias feature that was introduced in 1.2.

TDDing an E-Commerce Site With Phoenix, Part 5 - Updating Carts

Adding support for removing and updating LineItem quantities. As a bonus, introducing vim-test, which makes ExUnit testing in vim far more pleasant.

TDDing an E-Commerce Site With Phoenix, Part 6 - Completing an Order

Introducing an Order model, and a Register module that encapsulates the logic around turning a Cart into an Order. Also, a brief introduction to Ecto transactions.

TDDing an E-Commerce Site With Phoenix, Part 7 - Stripe

Adding the ability for the Register to charge a credit card for the Order via the Stripe API.

TDDing an E-Commerce Site With Phoenix, Part 8 - Stripe Checkout

Using Stripe's `Checkout` library to provide a nice user experience and avoid handling sensitive credit card details server-side.

The `i` Helper

A new feature in Elixir 1.2 to provide information about any piece of data.

Pi Walk With Logo

A random walk through Pi using our Logo interpreter.

Encryption and Hashing

An explanation of one way hashes, HMACs, password hashing, and a discussion about encryption proper.

Hedwig Bot Framework

Building chatbots with Elixir. With XMPP, Slack, and HipChat adapters already available.

Hedwig Twitter Bot

Modifying our existing Hedwig bot to interact with Twitter via ExTwitter.

Supervising Hedwig Twitter

Using `Task.Supervisor` to supervise our chatbot's ExTwitter streams, restarting them in the event of failure.

OpenGL in Elixir

Beginning an exploration of OpenGL programming in Elixir, using wx. We'll be porting the NeHe OpenGL tutorials.

OpenGL Part 2 - Color and Depth

Introducing color to our scenes, and making use of the Z coordinates so that we aren't just drawing fancy 2D scenes.

OpenGL: 3D Bitmaps

Introducing trivially repeatable shapes with GL Display Lists, and rendering a bitmap as cubes in a scene.

OpenGL Extris

Hooking our OpenGL Bitmap renderer into the Extris game, to render our Tetris clone in 3D.


Phoenix and Elm

Using `elm-brunch` to wire your Elm application into Phoenix's default build pipeline.

Constraint Solving

Using for comprehensions to solve some basic constraint modeling problems.


Bamboo Email

A library from Thoughtbot that makes it easy to send emails that is testable, composable, and adapter-based.

Moebius - Functional Database Queries

A library from Rob Conery for querying PostgreSQL databases that is composable, supports JSONB document databases, and in general makes constructing queries extremely pleasant.


Casting rays and simulating how light falls when cut off by various walls. (This is just the setup though!)

Raycaster Part 2: Finding Intersections

Calculating where 2 lines intersect, and using that to determine where walls occlude rays of light

Raycaster Part 3: Finishing Up

Wrapping up our raycaster project, resulting in a really fun simulation of light occlusion.

Phoenix.Presence Chat

Implementing chat and a user list on top of Phoenix.Presence, a new feature coming in Phoenix 1.2

Hunt Gather

An Elixir pattern for trivially parallelizing work that has no ordering constraints.


Webpack, Phoenix, and Elm

A walkthrough of starting a new webpack-based project in Phoenix, getting most of the existing out-of-the-box Brunch feature support, and introducing Elm compilation and scss as well.

Constraint Solving, Part 2: N-Queens Problem

Solving the "N-Queens Problem" driven by tests and types.

Constraint Solving, Part 3: N-Queens Problem, Part 2

Finishing up our solution to the N-Queens Problem, driven by tests and types.


Elixir 1.3 Mix Tasks

Checking out the new mix tasks provided in Elixir 1.3: `xref`, `app.tree`, `deps.tree`, `test --stale`, and `escript.install`


Exploring Erlang 19's new `gen_statem` behaviour by way of an idiomatic Elixir wrapper, by modeling a door lock with it.

Ecto 2.0

Ecto 2.0 was released. We'll look at it from the ground up, pointing out a few things that have changed with this release.

Ecto 2.0 Exploration

Digging into the corners a bit in the latest features in Ecto 2.0

OTP Pipeline

Building an umbrella application with 2 OTP apps in it, to produce a decoupled RSS handling pipeline.


Exploring Elixir's `with` Special Form, to ease error handling.

Commanding the Client with Phoenix Channels

Adding a control channel for your frontend clients to facilitate sending RPC-style commands into them from the backend.

Phoenix Chat Persistence

Persisting message in chat and providing the chat history to clients when they connect.



Building a Native Implemented Function and corresponding Elixir module, writing the Makefile, and integrating it into mix.


GenStage By Way of Pairing

In which Theron Boerner and I paired on prototyping a Continuous Integration server workflow using GenStage to produce jobs for specific machines and consume them appropriately.


Phoenix Is An Interface, Not Your Application

All of this has happened before. All of this will happen again.


Phoenix Is An Interface, Not Your Application, Part 2

Completing our Channels-based collaboration, seeing another "I didn't think this through" mistake, and seeing some benefits that OTP app separation help us accrue.


A small library that provides a sigil to get the equivalent of ES6 Object Destructuring and Shorthand Property Names in Elixir.

Currying (and More) with Quark

A library that adds some great features like Currying, Partial Function Application, and Composition to Elixir.


Church Encoding in Elixir

Or: The Coolest Thing I Know

Guardian and Phoenix APIs

Because you shouldn't let just **anyone** screw up your database. That's your users's job!

Making Sure the Other Party is Wrong

Because the only thing better than knowing you're right is knowing someone else is a failure.

Slurping Links Out of a Free Slack with ExIrc

GenServers and Supervision and IRC bots and queues.

Phoenix Users with Coherence

A relatively full-featured User Management System, with a broad feature set, that's pretty painless to set up.

Boyd Multerer's `phoenix_integration`

A supremely pleasant library for performing browserless integration tests against your Phoenix application.


Phoenix API Pagination with Scrivener

Using Scrivener.Headers to add pagination link information to the headers in our API responses, per an RFC Draft.

Boyd Multerer's `policy_wonk`

A library for painlessly enforcing authorization policies in your Phoenix applications.


Direct Uploads with S3 in a Phoenix API

Providing a restricted S3 policy to a user requesting to upload a file, and using jQuery File Upload to send it to S3.

Slurping Links Out of a Free Slack with ExIrc, Part 2

Pushing messages with links into the queue, building a quick WordPress API client with Tesla, and building a worker to pull items from the queue and push them into the API.

Slurping Links Out of a Free Slack with ExIrc, Part 3 - GenStage to the Rescue

Using GenStage to completely replace our queue-based system and provide us additional avenues for enhancement.

Metaprogramming Model Validation Tests

A quick tip for writing data-driven ExUnit tests.

Using Distillery to Create a Release of our ExIrc Slack Bot

Painlessly rolling a release tarball of our Elixir application, and producing a systemd unit to run it on system boot.

Debugging Situations Where You Haven't Fully "Let It Crash"

Identifying why our application stops working in certain crashing situations, and fixing it.

Building a Dashboard with Kitto

A dashboard framework descended from Dashing, with flair.


GraphQL with Absinthe

An introduction to GraphQL, using the Absinthe package to create a GraphQL server.


neovim for Elixir

Setting up neovim to have a nice Elixir editing environment

Building a File Processing Server

Starting a new OTP application to provide on-the-fly, configurable file transformations.

Plugging In Fly

Building a Plug to route requests to our job processing application.

Adding an LRU Cache to Fly

Using a Least-Recently-Used Cache to store our work and avoid repeating ourselves and avoid repeating ourselves.


Mechanical Turkdown

Building an entirely reasonable service for synchronous Markdown to HTML conversion, via Mechanical Turk


Firestorm Pairing Session #1 - Josh Adams and Michal Muskala on HexView

Work on an Elm API client for a project to view Elixir source packages.


Firestorm Pairing Session 2 - Josh Adams and Claudio Ortolina Building a Subreddit Word Counter with Flow

I pair with Claudio Ortolina to build my first Flow application.


Firestorm Pairing Session 3 - Josh Adams and Claudio Ortolina Building a Subreddit Word Counter with Flow, Part 2

Josh and Claudio Pair Further on RedditFlow


Firestorm Pairing Session 4 - Josh Adams and Adam Dill Pairing on the Firestorm UI

Pairing a bit to get the Firestorm UI started on good footing.


Firestorm Pairing Session 5 - Josh Adams and Andrew Vy Working with Ecto Polymorphism

Working through polymorphism in Ecto for Views and Follows (and eventually tags)


The code in the applications was produced by:

./josh adams

Josh Adams

I've been building web-based software for businesses for over 18 years. In the last four years I realized that functional programming was in fact amazing, and have been pretty eager since then to help people build software better.

Featured Lessons

Our content library is pretty great, here are a few lessons we think you might like.

What our Superusers are Saying!

Some other people were willing to publicly state that they like us!

Taylor Dolezal

Software Architect

Smooth Terminal has easily been one of the most helpful resources on my journey to better understand Elixir and the Phoenix web framework.

James Edward II


With any language there are so many details to learn. What functions are built-in? How should I structure my code? What tools are available for improving my workflow? It’s rare to find one source that can answer so many of these questions, but Smooth Terminal does this and more.

Rex Van Der Spuy

Game developer

Smooth Terminal is by far the best resource for learning Elm anywhere, and among the very best online learning platforms, period.