Introduction to the language, and installation of Erlang and Elixir

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

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

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

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

Preparing to learn about managing state and testing.

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

Handling enumerables and collections with power and grace.

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

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

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

Building Generic Servers and Supervision Trees

Using Supervisors to handle nuance within your Tasks and Agents.

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

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

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

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

Ensuring your data meets your requirements, flexibly.

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

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

Solving an Ecto exercise and preparing to learn about Phoenix.

Creating a new app and generating some resources.

HTML, CSS, and JavaScript are actual things.

Categories have Threads, and our URLs should reflect that.

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

Replacing Brunch with Webpack in a Phoenix app

Using Ueberauth to authenticate users against OAuth providers.

Handling database transactions in style, with Ecto.Multi.

Being smarter about modifying and inserting associated data.

Making Firestorm look a bit more like it should.

Getting started with a markdown renderer in the Firestorm Forum.

Testing your Phoenix app in the browser, concurrently.

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

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

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

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

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

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

Rendering nice titles for each page in a Phoenix app.

Adding email notifications to our system using Bamboo and SendGrid.

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

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

Rapidly implementing S3 Direct Upload in a rich client.

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

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

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

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

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

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

Adding a system for viewing notifications inside of Firestorm.

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

Making our oEmbed support faster and less prone to failure

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

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

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

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

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

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

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