Learn Elixir Quickly


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

What if learning were part of your daily routine? With DailyDrip's Elixir topic, you'll get the best training written by experts. Every week day, you'll get a bite-sized piece of Elixir education delivered to your inbox. Learn daily just by checking your email, or work through our exclusive content at your own pace. You'll always be able to go back or skip ahead via our web and mobile applications. We respect your time and you'll learn in just five minutes a day. Try your first week on us, with no risk or credit card required.

NOTE: This topic produces roughly 2 videos per week, but is being migrated to our daily style, see our blog post for more information.

Meet your expert


Joshhead
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.

What our customers are saying


Daily Drip has easily been one of the most helpful resources on my journey to better understand Elixir and the Phoenix web framework.
Taylor Dolezal Software Architect
Taylor dolezal
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 DailyDrip does this and more for Elixir.
James Edward Gray II Developer
James edward gray
Daily Drip is by far the best resource for learning Elm anywhere, and among the very best online learning platforms, period.
Rex van der Spuy Author of 5 books on game development
Rex van der spuy

See what you'll get


Free!
05:47

Introduction + Installing Elixir

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


05:36

Basic Elixir

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


05:48

Pattern Matching

A discussion of pattern matching in Elixir.


05:30

Functions

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


06:58

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


21:53

Unit Testing

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


04:59

List Comprehensions

Generating lists from lists (from lists); A real world example (deck of cards)

NOTE: Syntax changes, see Episode 060 for details


03:22

Records

Note: Elixir Records in this style are deprecated now. You should likely be using maps instead.

Defining Records; Pattern Matching on Records


09:49

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)


10:25

Processes, Part 2

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


09:15

Servers

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


12:55

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.


13:23

Pipe Operator

Used for building pipelines of functions; Similar to Unix pipes


05:04

Enum, Part 1

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


05:24

Enum, Part 2

drop, drop_while; each; empty?; fetch; filter, filter_map; find, find_index, find_value; first; flat_map; join


07:40

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


10:43

OTP Part 3 - GenEvent

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


07:15

Zeldacat, Part 2

Diving further into GenEvent


09:56

OTP Part 4 - Supervisors

Let It Crash

But seriously, do. And then recover.


11:51

OTP Part 5 - Supervisors and Persistent State

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


Free!
08:45

Ecto, Part 1

A brief introduction to using Ecto with Postgres for persistence.


09:40

Ecto, Part 2 - Dwitter

Using Ecto inside a Dynamo web application.


Free!
09:21

Parsing XML

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


07:37

HTTP Clients

A survey covering:

httpc; ibrowse; hackney


05:37

ExActor

Simplified generation of generic servers.


03:39

TCP Servers

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


06:34

Command Line Scripts

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


01:39

Pry

A tool to inspect or debug a running process.


03:34

Elixiak

An ActiveRecord-like wrapper for Riak in Elixir.


17:53

Weber, Part 2 - Performance

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


05:15

ExLager

Fantastic logging for your applications.


03:08

Binaries - Deconstructing and Constructing

Deconstructing and Constructing lists of bits in Elixir.


06:47

Binaries - Deconstructing an IP Packet

Deconstructing an IP Packet.


03:16

Bitwise

Manipulating bits; typically useful for wire protocols.


04:26

File, Part 1

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


04:14

File, Part 2

mkdir; rmdir; mkdir_p; stat; open; stream!; read; stream_to!; regular?; touch; rm; write; rm_rf; write_stat


Free!
04:12

Releases with Relex

Making your Elixir application redistributable using Erlang releases.


01:59

Distribution

Sending messages from one node to another.


03:10

Joe Armstrong's Favorite Erlang Program

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


06:49

Markdown Server, Part 1

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


09:20

Markdown Server, Part 2

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


08:46

Markdown Server, Part 3

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


07:51

Markdown Server, Part 4

Building a poor man's livereload system using inotify and websockets.


04:16

Markdown Server, Part 5

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


07:59

BEAM Toolbox, Part 1

Introducing BEAM Toolbox and starting work on the data layer.


11:00

BEAM Toolbox, Part 2

Further work on the data layer, and introducing defoverridable.


07:41

BEAM Toolbox, Part 3

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


Free!
02:52

Maps, Part 1

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


Free!
02:24

Maps, Part 2

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


03:00

Migrating Records to Maps

Converting a production use of Records to use maps instead.


08:29

BEAM Toolbox, Part 4

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


05:20

BEAM Toolbox, Part 5

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


02:57

Custom Mix Tasks

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


02:39

New Style Comprehensions

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


06:08

Plug

Exploring Elixir's library for building composable web application modules.


Free!
09:44

Quickie Synth

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


03:54

Tracing

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


10:57

Digraph

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


02:07

SSH

Using Erlang's ssh module to provide ssh access to a shell running your Elixir code.


02:00

Plug.Static

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


06:23

Deploying to Heroku

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


03:59

Port

Interacting with external programs as if they were simple processes.


03:59

Observer

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


02:59

Hex

Elixir's new package manager.


08:16

Wx

Building a GUI calculator using Erlang's native wx bindings.


18:47

WxCalc, Part 2

Implementing our calculator's logic and wiring it up to wx events.


02:21

Process Dictionaries

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


08:19

ETS

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


04:30

DETS

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


03:09

Streams

A brief overview of Elixir's "lazy, composable Enumerables"


02:18

Exceptions and Errors

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


05:45

Agents

A simple abstraction around state.


05:11

Tasks

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


05:04

erlubi

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


Free!
03:37

EEx

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


03:59

Protocols

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


05:32

pg2

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


Free!
05:07

PCM Audio

Generating PCM Audio and making some noise


01:50

Apex

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


06:53

put_in and get_in

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


10:57

WordCloud

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


10:04

Porcelain

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


04:01

Protocol Buffers

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


13:20

Websockets Terminal

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


02:35

Test Coverage

Exploring test coverage report generation, using both Erlang's cover application and the Coverex tool.


13:57

Link Extractor

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


09:18

Link Extractor, Part 2

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


06:38

Link Extractor, Part 3

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


13:20

Link Extractor Part 4

Fixing some bugs and setting up a Zapier integration.


06:02

Arduino Motor Driver

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


06:23

BEAM Toolbox, Part 6

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


Free!
16:34

Contributing to Open Source

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


08:45

BEAM Toolbox, Part 7

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


09:47

Beam Toolbox, Part 8

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


12:23

BEAM Toolbox, Part 9

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


05:57

BEAM Toolbox, Part 10

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


04:21

BEAM Toolbox, Part 11

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


04:07

Ruby to Elixir via BERT-RPC

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


12:34

Farkov Chain

Generating killer marketing strategies with Elixir


14:12

Text Parsing

Building a parser for a custom text format.


03:57

Phoenix Release

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


04:53

Release Upgrades

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


06:06

Socket

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


03:00

ExTwitter

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


04:57

ExTwitter, Part 2

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


04:47

Benchfella

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


04:35

Monitoring Network Traffic

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


05:30

Wx Keyboard Events

Handling keyboard input in a wx application.


05:50

Wx Extris Continued

Making pieces fall and drawing the game board.


07:51

Wx Extris Part 3, Refactoring

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


11:25

Wx Extris Part 4 - Testing

Writing some tests and implementing board boundary collision.


05:46

Wx Extris Part 5

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


12:07

Wx Extris Part 6 - Concurrent Rendering

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


00:00

Wx Extris, Part 7

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


06:54

Wx Extris, Part 8

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


05:52

SDL

Using the SDL library for graphics from your Elixir programs.


19:00

SDL Extris

Writing a renderer for the Tetris clone using SDL.


03:47

Typespecs

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


04:50

Dialyzer

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


01:36

Piping Into Elixir

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


01:47

SSH Client Commands

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


03:03

Managing Docker

Programmatically interacting with Docker using Elixir and erldocker.


02:02

egd

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


12:54

Extris Web Client

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


03:44

ExProf

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


04:05

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's important.


06:11

Boltun - Postgres Listen + Notify

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


07:30

Elastic Search with Tirexs

An easy way to interact with ElasticSearch.


01:54

Benchwarmer

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


06:05

Interfacing with Asterisk

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


03:51

Asterisk AGI with Elixir

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


04:21

Monitors and Links

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


02:33

hexdocs

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


07:47

Gopher

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


01:54

Set

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


02:58

escript

Building quick 'binaries' after a fashion using Elixir's tooling.


06:26

Phoenix Generator

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


03:08

Erlang's calendar module

Interacting with Erlang's native date and time types.


03:13

good_times

An elixir library for trivially specifying relative dates and times.


04:51

Mailman

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


03:37

WebAssembly

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


06:22

ejabberd with Elixir

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


08:24

ejabberd Packet Filters

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


10:23

JInterface

Talking to Elixir from Java


06:19

System Information

Exploring a running Erlang system using tools from the shell.


03:31

erlang_js

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


07:46

Phoenix APIs and CORS

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


02:29

inet

Basic TCP/IP interactions built into Erlang's kernel application for you.


04:24

OAuth2 - Code Spelunking

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


02:08

Interacting with Amazon's APIs with erlcloud

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


03:06

Playing with the Code Module, Part 1 - eval_string

Exploring the standard library's Code module's eval_string function for fun and whatnot.


03:18

SOAP with Detergentex

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


07:38

Simple One for One Supervisors

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


01:48

MultiDef

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


12:35

Building a Cron System - Part 1

Building a parser for cron-style job definitions.


09:49

Building a Cron System, Part 2

Determining if a given time is matched by a Schedule.


10:46

Building a Cron System, Part 3

Executing our jobs on their schedule. Bonus intro to defdelegate and ExUnit's @tags.


10:49

Fractals

Exploring L Systems, on our way to generating fractals.


22:25

Accounting 101

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


Free!
13:45

Implementing Logo, Part 1

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


11:46

Implementing Logo, Part 2

Building a renderer for our Logo interpreter.


Free!
07:25

Continuous Integration

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


08:13

Fractals, Part 2

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


06:46

Building a Slack Bot

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


07:21

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.


06:33

Arc File Uploads

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


05:09

Deploying Phoenix Applications to Heroku

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


06:21

ElixirFriends - Saving Tweets with Streams and Filters

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


10:34

Pagination with Ecto and Phoenix using Scrivener

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


11:47

Prettying Up ElixirFriends

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


15:38

Audio Visualizer

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


04:26

Memory Leaks

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


21:19

Rules Engine

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


05:55

Collectable

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


07:54

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!


05:51

Phoenix API

Building out an API endpoint for ElixirFriends in Phoenix


07:53

React with Phoenix

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


06:45

React with Phoenix Channels

Pushing new posts to ElixirFriends into our React application's state using Phoenix Channels.


01:58

Mix Archives

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


03:35

Automatically Connecting Nodes

Using Erlang'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.


08:55

Compiling a Custom AST Into Elixir Functions

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


05:34

ElixirScript

Because writing Elixir is far preferable to writing JavaScript.


03:02

.iex.exs

Customizing your IEx prompt for productivity and aesthetic purposes.


03:49

Testing Phoenix Channels

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


12:07

Interesting IO

Building an ANSI Tetris renderer for the TTY using iolists.


10:17

Interesting IO, Part 2 - Input with tty_sl

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


07:31

Linting with Dogma

Examining an up and coming coding style enforcement tool.


12:34

Interoperability - Ports

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


04:29

Spaceships

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


05:33

Crashing the BEAM

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


10:10

gproc

Using Ulf Wiger's gproc application to register processes and look them up in interesting ways.


03:04

Elixir and Unity3d

Rendering our spaceships simulator in 3D with Unity3D


23:17

Modeling a Virtual Machine

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


07:52

Custom Types in Ecto

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


03:33

Tracing and Debugging with erlyberly

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


07:15

Exception Monitoring with Honeybadger.io

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


04:27

plug_auth

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


08:11

Behaviours

Enforcing your own custom interfaces with Behaviours in Elixir.


09:25

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.


04:32

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.


05:17

XMLRPC

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


09:43

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.


05:10

Integration Testing with Hound

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


06:18

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.


13:45

Parsing and Searching HTML With Floki

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


08:43

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.


07:26

Stripe

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


03:02

Visualixir

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


06:15

Tracking Performance Metrics with Beaker

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


01:47

Code Linting with Credo

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


04:22

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.


05:08

CSV

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


09:45

User Authentication with Ueberauth

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


02:52

Bureaucrat API Documentation

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


01:21

erl_festival

Using the festival speech synthesis tool from Elixir.


09:39

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.


07:43

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.


16:00

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!


04:49

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's multi-alias feature that was introduced in 1.2.


08:04

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.


07:38

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.


09:54

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.


14:48

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.


03:54

The i Helper

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


04:02

Pi Walk With Logo

A random walk through Pi using our Logo interpreter.


05:03

Encryption and Hashing

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


04:05

Hedwig Bot Framework

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


14:07

Hedwig Twitter Bot

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


03:37

Supervising Hedwig Twitter

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


11:39

OpenGL in Elixir

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


06:19

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.


05:13

OpenGL: 3D Bitmaps

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


05:32

OpenGL Extris

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


Free!
02:05

Phoenix and Elm

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


06:51

Constraint Solving

Using for comprehensions to solve some basic constraint modeling problems.


Free!
05:54

Bamboo Email

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


08:54

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.


05:37

Raycaster

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


20:23

Raycaster Part 2: Finding Intersections

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


10:08

Raycaster Part 3: Finishing Up

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


09:48

Phoenix.Presence Chat

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


03:52

Hunt Gather

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


Free!
20:21

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.


10:35

Constraint Solving, Part 2: N-Queens Problem

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


12:24

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

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


Free!
06:37

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


08:52

gen_state_machine

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


08:10

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.


08:00

Ecto 2.0 Exploration

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


09:14

OTP Pipeline

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


06:05

with

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


07:40

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.


Free!
15:38

NIFs

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


Free!
19:31

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.


Free!
12:46

Phoenix Is An Interface, Not Your Application

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


Free!
25:53

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.


03:19

ShortMaps

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


07:52

Currying (and More) with Quark

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


Free!
16:00

Church Encoding in Elixir

Or: The Coolest Thing I Know


15:52

Guardian and Phoenix APIs

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


09:21

Making Sure the Other Party is Wrong

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


17:13

Slurping Links Out of a Free Slack with ExIrc

GenServers and Supervision and IRC bots and queues.


10:48

Phoenix Users with Coherence

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


13:22

Boyd Multerer's phoenix_integration

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


08:06

Phoenix API Pagination with Scrivener

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


14:50

Boyd Multerer's policy_wonk

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


Free!
00:00

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.


16:49

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.


20:42

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.


04:35

Metaprogramming Model Validation Tests

A quick tip for writing data-driven ExUnit tests.


11:46

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.


08:43

Debugging Situations Where You Haven't Fully Let It Crash

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


08:31

Building a Dashboard with Kitto

A dashboard framework descended from Dashing, with flair.


Free!
08:15

GraphQL with Absinthe

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


Free!
11:59

neovim for Elixir

Setting up neovim to have a nice Elixir editing environment


12:36

Building a File Processing Server

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


09:08

Plugging In Fly

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


00:00

Adding an LRU Cache to Fly

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


Free!
14:20

Mechanical Turkdown

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


Free!
00:00

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.