Learn the Elixir Programming Language, built atop the highly-scalable Erlang Virtual Machine.


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 to Elixir

Introduction to the language, and installation of Erlang and Elixir


Basic Elixir Syntax and Concepts

Learning the basics of the language, as well as how to run scripts.


Mix and Modules

Using the `mix` tool and defining modules, functions, and structs


Processes and Messaging

Processes are the unit of concurrency. We'll spawn some processes and let them have a conversation.


Elixir Weekly Drip #1 and Exercise: String Upcaser "Microservice"

Further links for reading, and a gratuitous exercise to build a process that responds with the upcased version of any strings it is sent.


Intermediate Elixir Prep

Preparing to learn about managing state and testing.


Processes With State, and Agent

Managing state with processes and messaging, then seeing the Agent module from the Standard Library for a simpler way to do the same thing.


`for` Comprehensions

Handling enumerables and collections with power and grace.


Testing with ExUnit

An in-depth look at ExUnit, Test-Driven Development, and doctests.


Elixir Weekly Drip #2 and Exercise: Reverse Polish Notation Calculator

Links on documentation, `with`, control structures, Enumerables, and an exercise to build a Reverse Polish Notation Calculator.


Preparing to Learn about OTP

A solution to the Reverse Polish Notation Calculator exercise, and preparatory readings for learning about OTP.


GenServer and Supervisor

Building Generic Servers and Supervision Trees


Supervising Tasks and Agents

Using Supervisors to handle nuance within your Tasks and Agents.



Modeling a door with a numeric lock, to explore building Finite State Machines.


Elixir Weekly Drip #3 and Exercise: Supervised RPN Calculator and Tape Printer

Interesting links and an exercise to build an RPN Calculator with GenServer, with a Tape Printer.


Preparing to Learn About Ecto

A solution to last week's exercise and some readings to prepare us to learn about Ecto.


Ecto Basics

Getting started with Ecto by creating a basic schema and querying it.


Ecto Validation with Changesets

Ensuring your data meets your requirements, flexibly.


Ecto Associations and More Queries

Exploring how to model associated data in Ecto and further details on queries.


Elixir Weekly Drip #4 and Exercise: More Queries

Some Ecto-related links and an exercise to write more detailed queries


Preparing to Learn About Phoenix

Solving an Ecto exercise and preparing to learn about Phoenix.


Getting Started with Phoenix

Creating a new app and generating some resources.


Phoenix and the Frontend

HTML, CSS, and JavaScript are actual things.


Nested Resources in Phoenix

Categories have Threads, and our URLs should reflect that.


Elixir Weekly Drip #5 and Exercise: Fix Tests

Fixing the tests after last episode, and some Phoenix-related links.

Webpack2 with Phoenix

Replacing Brunch with Webpack in a Phoenix app

Authentication via OAuth

Using Ueberauth to authenticate users against OAuth providers.

Adding Posts to Threads with Database Transactions

Handling database transactions in style, with Ecto.Multi.

Using Ecto Associations in Phoenix

Being smarter about modifying and inserting associated data.

Phoenix Views, Templates, and Layouts

Making Firestorm look a bit more like it should.

Rendering Markdown in Phoenix with Earmark

Getting started with a markdown renderer in the Firestorm Forum.

Feature Tests with Wallaby

Testing your Phoenix app in the browser, concurrently.

Feature Tests with Wallaby, Part 2

Testing user interaction with wallaby - fill out forms, click links, have fun!

Customizing Earmark

Extending the Earmark markdown renderer to add auto-linking URLs and emoji replacement.

Requiring a Logged In User

Adding a `RequireUser` plug to redirect guests when performing actions that require authentication.

Styling User Details

Turning a mockup of Firestorm's user details view into working code, including responsive design with breakpoints and flexbox.

Paginating a User's Posts

Fleshing out the rest of the user details template, and using `Scrivener` to handle pagination.

Markdown Preview

Building an API endpoint and a JavaScript component for previewing Markdown while composing a post.


Page-Specific Titles

Rendering nice titles for each page in a Phoenix app.

Adding Notification Emails with Bamboo

Adding email notifications to our system using Bamboo and SendGrid.

Handling Inbound Emails from SendGrid

Using SendGrid's Inbound Parse feature to allow users to reply to posts from their email client.

Using Slugs in Ecto

Using `ecto_autoslug_field` to generate slugs for our resources based on their titles.

S3 Direct Upload

Rapidly implementing S3 Direct Upload in a rich client.

Watching Threads via Polymorphic Associations

Exploring Polymorphic associations to add the ability to watch things in our Forum, starting with Threads.

Handling Watched Threads in the Frontend

Adding controller and view support for watching Threads and only emailing Users that are watching a given Thread.

User Authentication with comeonin and ueberauth_identity

Rolling a user authentication system that plays nicely with our existing ueberauth system via the ueberauth_identity strategy, using comeonin for hashing passwords.


Continuous Integration with Semaphore

Setting up continuous integration for an Elixir project using Semaphore CI.


Continuous Deployment to Heroku

Deploying to Heroku, then setting up Semaphore to continuously deploy on each push to master.

Marking Posts Viewed

Adding a polymorphic View type and handling the corresponding UI bits and bobs.

In-App Notifications

Adding a system for viewing notifications inside of Firestorm.

Embedding Rich Data with oEmbed

Using an open standard to embed data from other sites in Firestorm posts.

Making oEmbed Not Terrible

Making our oEmbed support faster and less prone to failure


Adding Channels for our Data Store

Creating JSON representations of our resources and introducing a channel to fetch data from.

Adding Channels for our Data Store, Part 2

Encoding some business logic from the backend into our JSON serializations, and using `defdelegate` to assist in a refactoring.


Monitoring with AppSignal

Add Performance Monitoring to a Phoenix app in five minutes or less.


Deploying a Phoenix App with Gatling

Using HashRocket's `gatling` tool to deploy a Phoenix app to DigitalOcean.

Implementing a Simple Neural Network in Elixir

Using an existing library to play with some simple neural networks.

Code Spelunking in a Neural Network Library

A read-through of Karmen Blake's `neural_network_elixir` library.

How a Neural Network is Trained

Reading the code that trains an Elixir-based neural network.


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.