ElixirSips

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.

Get Started Now!

Meet your expert


7f98e514a44b8ff8109e81882dbcf1c5?s=184&d=mm

Josh Adams

@knewter

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


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

Working through polymorphism in Ecto for Views and Follows (and ev...
30:08
Free!


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.
37:16
Free!


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
56:33
Free!


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.
09:29
Free!


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

Work on an Elm API client for a project to view Elixir source pack...
06:30
Free!


Mechanical Turkdown

Building an entirely reasonable service for synchronous Markdown t...
14:20
Free!


Adding an LRU Cache to Fly

Using a Least-Recently-Used Cache to store our work and avoid repe...
10:34


Plugging In Fly

Building a Plug to route requests to our job processing application.
09:08


Building a File Processing Server

Starting a new OTP application to provide on-the-fly, configurable...
12:36


neovim for Elixir

Setting up neovim to have a nice Elixir editing environment
11:59
Free!


GraphQL with Absinthe

An introduction to GraphQL, using the Absinthe package to create a...
08:15
Free!


Building a Dashboard with Kitto

A dashboard framework descended from Dashing, with flair.
08:31


Debugging Situations Where You Haven't Fully Let It Crash

Identifying why our application stops working in certain crashing ...
08:43


Using Distillery to Create a Release of our ExIrc Slack Bot

Painlessly rolling a release tarball of our Elixir application, an...
11:46


Metaprogramming Model Validation Tests

A quick tip for writing data-driven ExUnit tests.
04:35


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 pr...
20:42


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

Pushing messages with links into the queue, building a quick WordP...
16:49


Direct Uploads with S3 in a Phoenix API

Providing a restricted S3 policy to a user requesting to upload a ...
00:00
Free!


Boyd Multerer's policy_wonk

A library for painlessly enforcing authorization policies in your ...
14:50


Phoenix API Pagination with Scrivener

Using Scrivener.Headers to add pagination link information to the ...
08:06
Free!


Boyd Multerer's phoenix_integration

A supremely pleasant library for performing browserless integratio...
13:22


Phoenix Users with Coherence

A relatively full-featured User Management System, with a broad fe...
10:48


Slurping Links Out of a Free Slack with ExIrc

GenServers and Supervision and IRC bots and queues.
17:13


Making Sure the Other Party is Wrong

Because the only thing better than knowing you're right is knowing...
09:21


Guardian and Phoenix APIs

Because you shouldn't let just **anyone** screw up your database. ...
15:52


Church Encoding in Elixir

Or: The Coolest Thing I Know
16:00
Free!


Currying (and More) with Quark

A library that adds some great features like Currying, Partial Fun...
07:52


ShortMaps

A small library that provides a sigil to get the equivalent of ES6...
03:19


Phoenix Is An Interface, Not Your Application, Part 2

Completing our Channels-based collaboration, seeing another "I did...
25:53
Free!


Phoenix Is An Interface, Not Your Application

All of this has happened before. All of this will happen again.
12:46
Free!


GenStage By Way of Pairing

In which Theron Boerner and I paired on prototyping a Continuous I...
19:31
Free!


NIFs

Building a Native Implemented Function and corresponding Elixir mo...
15:38
Free!


Phoenix Chat Persistence

Persisting message in chat and providing the chat history to clien...


Commanding the Client with Phoenix Channels

Adding a control channel for your frontend clients to facilitate s...
07:40


with

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


OTP Pipeline

Building an umbrella application with 2 OTP apps in it, to produce...
09:14


Ecto 2.0 Exploration

Digging into the corners a bit in the latest features in Ecto 2.0
08:00


Ecto 2.0

Ecto 2.0 was released. We'll look at it from the ground up, point...
08:10


gen_state_machine

Exploring Erlang 19's new `gen_statem` behaviour by way of an idio...
08:52


Elixir 1.3 Mix Tasks

Checking out the new mix tasks provided in Elixir 1.3: `xref`, `ap...
06:37
Free!


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

Finishing up our solution to the N-Queens Problem, driven by tests...
12:24


Constraint Solving, Part 2: N-Queens Problem

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


Webpack, Phoenix, and Elm

A walkthrough of starting a new webpack-based project in Phoenix, ...
20:21
Free!


Hunt Gather

An Elixir pattern for trivially parallelizing work that has no ord...
03:52


Phoenix.Presence Chat

Implementing chat and a user list on top of Phoenix.Presence, a ne...
09:48


Raycaster Part 3: Finishing Up

Wrapping up our raycaster project, resulting in a really fun simul...
10:08


Raycaster Part 2: Finding Intersections

Calculating where 2 lines intersect, and using that to determine w...
20:23


Raycaster

Casting rays and simulating how light falls when cut off by variou...
05:37


Moebius - Functional Database Queries

A library from Rob Conery for querying PostgreSQL databases that i...
08:54


Bamboo Email

A library from Thoughtbot that makes it easy to send emails that i...
05:54
Free!


Constraint Solving

Using for comprehensions to solve some basic constraint modeling p...
06:51


Phoenix and Elm

Using `elm-brunch` to wire your Elm application into Phoenix's def...
02:05
Free!


OpenGL Extris

Hooking our OpenGL Bitmap renderer into the Extris game, to render...
05:32


OpenGL: 3D Bitmaps

Introducing trivially repeatable shapes with GL Display Lists, and...
05:13


OpenGL Part 2 - Color and Depth

Introducing color to our scenes, and making use of the Z coordinat...
06:19


OpenGL in Elixir

Beginning an exploration of OpenGL programming in Elixir, using wx...
11:39


Supervising Hedwig Twitter

Using `Task.Supervisor` to supervise our chatbot's ExTwitter strea...
03:37


Hedwig Twitter Bot

Modifying our existing Hedwig bot to interact with Twitter via ExT...
14:07


Hedwig Bot Framework

Building chatbots with Elixir. With XMPP, Slack, and HipChat adap...
04:05


Encryption and Hashing

An explanation of one way hashes, HMACs, password hashing, and a d...
05:03


Pi Walk With Logo

A random walk through Pi using our Logo interpreter.
04:02


The i Helper

A new feature in Elixir 1.2 to provide information about any piece...
03:54


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

Using Stripe's `Checkout` library to provide a nice user experienc...
14:48


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

Adding the ability for the Register to charge a credit card for th...
09:54


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

Introducing an Order model, and a Register module that encapsulate...
07:38


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

Adding support for removing and updating LineItem quantities. As ...
08:04


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

Introducing an actual Cart model. Involves multiple browser sessi...
04:49


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

Test-Driving a basic cart implementation, which requires adding a ...
16:00


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

Using Arc to store product images on S3, make thumbnails, and rend...
07:43


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

Kicking off a new project to test-drive a Phoenix app, using Hound...
09:39


erl_festival

Using the festival speech synthesis tool from Elixir.
01:21


Bureaucrat API Documentation

A tool to generate end-user API Documentation from your existing A...
02:52


User Authentication with Ueberauth

A library for flexible user authentication, whether from an OAuth ...
09:45


CSV

A look at an unbelievably well-built CSV encoding and decoding lib...
05:08


Internationalizing a Phoenix Application with Gettext

An overview of Phoenix's new Gettext support for allowing easy str...
04:22


Code Linting with Credo

A code linting tool focused on giving gentle suggestions and provi...
01:47


Tracking Performance Metrics with Beaker

A lightweight tool that gives you an instant performance monitorin...
06:15


Visualixir

A tool to visualize your application and trace messages between pr...
03:02


Stripe

Using Rob Conery's `stripity_stripe` library to easily work with S...
07:26


Streaming Structured Data From Webpages With Stream.resource

Combining Floki and Stream.resource to turn a static HTML site int...
08:43


Parsing and Searching HTML With Floki

A really nice library for parsing HTML and finding elements in it ...
13:45


Visualizing Another Node With ex_top

A quick demonstration of the `ex_top` tool for visualizing a remot...
06:18


Integration Testing with Hound

Using Hound to drive a browser and test JavaScript behaviour of yo...
05:10


Compile-Time Interface Policy Enforcement using @on_definition

Making our compiler enforce business-level decisions about how fun...
09:43


XMLRPC

Integrating with systems that use XMLRPC as their remote execution...
05:17


Getting a Nested Module From a String

A few unsafe ways to turn user input into a module, a wrongheaded ...
04:32


The Opposite of Mocks

A strategy that I employed to get around a module that was particu...
09:25


Behaviours

Enforcing your own custom interfaces with Behaviours in Elixir.
08:11


plug_auth

An unbelievably simple plug for adding authentication and role-bas...
04:27


Exception Monitoring with Honeybadger.io

Monitoring exceptions in your production applications, whether the...
07:15


Tracing and Debugging with erlyberly

Tracing function calls in a running Erlang node, which should be m...
03:33


Custom Types in Ecto

Storing custom types in Ecto models. Specifically, storing a part...
07:52


Modeling a Virtual Machine

Building a register-based virtual machine with 4 registers and 2 i...
23:17


Elixir and Unity3d

Rendering our spaceships simulator in 3D with Unity3D
03:04
Free!


gproc

Using Ulf Wiger's `gproc` application to register processes a...
10:10


Crashing the BEAM

Causing a few of the BEAM's failure modes so we can see them ...
05:33


Spaceships

A rapid jaunt through a little spaceship simulator I wrote that ha...
04:29


Interoperability - Ports

Writing a C program that has an Elixir interface by way of Erlang&...
12:34


Linting with Dogma

Examining an up and coming coding style enforcement tool.
07:31


Interesting IO, Part 2 - Input with tty_sl

Using the underlying port driver that the Erlang "REPL" ...
10:17


Interesting IO

Building an ANSI Tetris renderer for the TTY using iolists.
12:07


Testing Phoenix Channels

Looking at the facilities Phoenix provides to assist in writing te...
03:49


.iex.exs

Customizing your IEx prompt for productivity and aesthetic purposes.
03:02


ElixirScript

Because writing Elixir is far preferable to writing JavaScript.
05:34


Compiling a Custom AST Into Elixir Functions

Taking advantage of Elixir's amazing metaprogramming support ...
08:55


Automatically Connecting Nodes

Using Erlang's sys.config file to tell our application to wir...
03:35


Mix Archives

Using Mix to build an Erlang Archive Format file and install it as...
01:58


React with Phoenix Channels

Pushing new posts to ElixirFriends into our React application&apos...
06:45


React with Phoenix

Building a React application that interfaces with our Phoenix API ...
07:53


Phoenix API

Building out an API endpoint for ElixirFriends in Phoenix
05:51


Native Compilation with HiPE

Taking further advantage of the power given to us by the almighty ...
07:54


Collectable

Implementing the Collectable protocol to clean up a common pattern...
05:55


Rules Engine

Building a Rules Engine and benchmarking a couple of different pro...
21:19


Memory Leaks

Using :observer to find memory leaks in your system, because the B...
04:26


Audio Visualizer

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


Prettying Up ElixirFriends

Adding SemanticUI to ElixirFriends and making it look a little bit...
11:47


Pagination with Ecto and Phoenix using Scrivener

Using Scrivener to paginate Ecto queries and display pagination co...
10:34


ElixirFriends - Saving Tweets with Streams and Filters

Building a Phoenix Application that stores select tweets for displ...
06:21


Deploying Phoenix Applications to Heroku

Using SemaphoreCI to automatically deploy your Phoenix application...
05:09


Arc File Uploads

Using the `arc` library to enable simple file uploads and image ma...
06:33


Erlang 18 and time

Learning how to replace calls to `:erlang.now` with the new API fo...
07:21


Building a Slack Bot

Using Elixir to build a bot that can respond to messages in our Sl...
06:46


Fractals, Part 2

Combining our L Systems and our Logo Interpreter to explore drunk ...
08:13


Continuous Integration

Using Semaphore CI to automatically test a Phoenix application eac...
07:25
Free!


Implementing Logo, Part 2

Building a renderer for our Logo interpreter.
11:46


Implementing Logo, Part 1

Implementing the Logo graphical programming language in Elixir wit...
13:45
Free!


Accounting 101

Modeling a double-entry ledger. Terribly. And then discussing what...
22:25


Fractals

Exploring L Systems, on our way to generating fractals.
10:49


Building a Cron System, Part 3

Executing our jobs on their schedule. Bonus intro to defdelegate ...
10:46


Building a Cron System, Part 2

Determining if a given time is matched by a Schedule.
09:49


Building a Cron System - Part 1

Building a parser for cron-style job definitions.
12:35


MultiDef

A less-verbose way to define multiple function clauses, courtesy o...
01:48


Simple One for One Supervisors

Getting a dynamically spawned process into a supervision tree to a...
07:38


SOAP with Detergentex

Using the `detergentex` library, which wraps the erlang `detergent...
03:18


Playing with the Code Module, Part 1 - eval_string

Exploring the standard library's Code module's `eval_str...
03:06


Interacting with Amazon's APIs with erlcloud

A comically brief overview of erlcloud and evidence that it does, ...
02:08


OAuth2 - Code Spelunking

A dig through Sonny Scroggins' example of integrating a Phoen...
04:24


inet

Basic TCP/IP interactions built into Erlang's kernel applicat...
02:29


Phoenix APIs and CORS

Building a basic API with Phoenix, and allowing remote domains to ...
07:46


erlang_js

Evaluating javascript on a SpiderMonkey interpreter and getting ba...
03:31


System Information

Exploring a running Erlang system using tools from the shell.
06:19


JInterface

Talking to Elixir from Java
10:23


ejabberd Packet Filters

Modifying messages inside of our ejabberd server, specifically - m...
08:24


ejabberd with Elixir

Getting started interacting with a battle-hardened XMPP chat serve...
06:22


WebAssembly

Generate markup from blocks of elixir code, in the style of _why t...
03:37


Mailman

Easily send emails, parse emails, and verify email related feature...
04:51


good_times

An elixir library for trivially specifying relative dates and times.
03:13


Erlang's calendar module

Interacting with Erlang's native date and time types.
03:08


Phoenix Generator

A project that adds code generation to Phoenix for building models...
06:26


escript

Building quick 'binaries' after a fashion using Elixir&a...
02:58


Set

Elixir ships with a Set behaviour, and a default HashSet implement...
01:54


Gopher

Using `goma`, which is essentially WebMachine for The Internet Gop...
07:47


hexdocs

Elixir's package manager, hex.pm, also provides a documentati...
02:33


Monitors and Links

Two of the core building blocks that the Erlang VM provides. I&ap...
04:21


Asterisk AGI with Elixir

Building out an erlagi handler module in Elixir that interacts wit...
03:51


Interfacing with Asterisk

Using the `erlagi` application from Elixir to control the logic of...
06:05


Benchwarmer

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


Elastic Search with Tirexs

An easy way to interact with ElasticSearch.
07:30


Boltun - Postgres Listen + Notify

An Elixir package providing fantastically simple support for Postg...
06:11


Randomness in the Erlang VM

An exploration of where our randomness in Tetris went so horribly ...
04:05


ExProf

An Elixir profiler, useful for finding where your program is spend...
03:44


Extris Web Client

Using Phoenix's websockets to build a JavaScript canvas-based...
12:54


egd

A module in the Erlang Standard Library meant for doing basic grap...
02:02


Managing Docker

Programmatically interacting with Docker using Elixir and erldocker.
03:03


SSH Client Commands

Becoming an SSH client and sending commands to an SSH server with ...
01:47


Piping Into Elixir

Handling typical unix-script style stdin and stdout pipes triviall...
01:36


Dialyzer

Letting the computer (rather than logs or users) tell you when you...
04:50


Typespecs

Layering type information over your functions to aid users and sta...
03:47


SDL Extris

Writing a renderer for the Tetris clone using SDL.
19:00


SDL

Using the SDL library for graphics from your Elixir programs.
05:52


Wx Extris, Part 8

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


Wx Extris, Part 7

Introducing collision detection and cleaning up the renderer / gam...
35:17


Wx Extris Part 6 - Concurrent Rendering

Introducing multiple processes into the game, and running the rend...
12:07


Wx Extris Part 5

Defining the bottom game board boundary and providing the next sha...
05:46


Wx Extris Part 4 - Testing

Writing some tests and implementing board boundary collision.
11:25


Wx Extris Part 3, Refactoring

Turning a gigantic module into something a little more sensible an...
07:51


Wx Extris Continued

Making pieces fall and drawing the game board.
05:50


Wx Keyboard Events

Handling keyboard input in a wx application.
05:30


Monitoring Network Traffic

Using libpcap from Elixir to see the stream of data passing across...
04:35


Benchfella

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


ExTwitter, Part 2

Streaming a Twitter search to the browser, because Phoenix Channel...
04:57


ExTwitter

A library for interacting with the Twitter API, using standard req...
03:00


Socket

A pleasant abstraction around `gen_tcp`, `gen_udp`, `gen_sctp`, an...
06:06


Release Upgrades

Upgrading a running app to a new version without losing state.
04:53


Phoenix Release

Using `exrm` to build a release of the BEAM Toolbox webapp, for de...
03:57


Text Parsing

Building a parser for a custom text format.
14:12


Farkov Chain

Generating killer marketing strategies with Elixir
12:34


Ruby to Elixir via BERT-RPC

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


BEAM Toolbox, Part 11

Switching to the expression style in Ecto, and using Phoenix'...
04:21


BEAM Toolbox, Part 10

Building a projects listing page, and reviewing some changes to th...
05:57


BEAM Toolbox, Part 9

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


Beam Toolbox, Part 8

Making the BEAM Toolbox a bit more useful, including adding in Dis...
09:47


BEAM Toolbox, Part 7

Managing relationships in Ecto, and integrating Ecto into a Phoeni...
08:45


Contributing to Open Source

In which we contribute to the elixir codebase and open a pull requ...
16:34
Free!


BEAM Toolbox, Part 6

Resurrecting the Toolbox with an Ecto-based data layer from scratc...
06:23


Arduino Motor Driver

An unusually formatted episode discussing an ad hoc serial protoco...
06:02


Link Extractor Part 4

Fixing some bugs and setting up a Zapier integration.
13:20


Link Extractor, Part 3

Deploying our application to a VPS from scratch and pushing in our...
06:38


Link Extractor, Part 2

Using Phoenix to build an HTTP API for posting links into the syst...
09:18


Link Extractor

Using poolboy to build a service for extracting data from a set of...
13:57


Test Coverage

Exploring test coverage report generation, using both Erlang'...
02:35


Websockets Terminal

Taking advantage of Phoenix's native websockets support to bu...
13:20


Protocol Buffers

Easy cross-language serialization and deserialization of data stru...
04:01


Porcelain

External Process interaction like the Port module but both simpler...
10:04


WordCloud

Using Elixir to do a word frequency count on a corpus of text and ...
10:57


put_in and get_in

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


Apex

Awesome Print for Elixir. An easy way to get insight into unfamili...
01:50


PCM Audio

Generating PCM Audio and making some noise
05:07
Free!


pg2

A replacement for the `pg` module that has some better semantics f...
05:32


Protocols

A fantastic method for polymorphism in Elixir. Pairs well with str...
03:59


EEx

Elixir's built-in templating language, useful for embedding E...
03:37
Free!


erlubi

A client for the Ubigraph visualization server, and an easy way to...
05:04


Tasks

An abstraction for computing a value in the background and receivi...
05:11


Agents

A simple abstraction around state.
05:45


Exceptions and Errors

Manually raising exceptions, handling them, defining your own, and...
02:18


Streams

A brief overview of Elixir's "lazy, composable Enumerabl...
03:09


DETS

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


ETS

Erlang term storage - a queryable database for your processes to s...
08:19


Process Dictionaries

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


WxCalc, Part 2

Implementing our calculator's logic and wiring it up to wx ev...
18:47


Wx

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


Hex

Elixir's new package manager.
02:59


Observer

A graphical tool for inspection of a running Erlang/Elixir system ...
03:59


Port

Interacting with external programs as if they were simple processes.
03:59


Deploying to Heroku

Using HashNuke's Elixir buildpack for Heroku to deploy BEAM T...
06:23


Plug.Static

Serving static files without an opaque and complicated-looking cow...
02:00


SSH

Using Erlang's `ssh` module to provide ssh access to a shell ...
02:07


Digraph

A look at using the `digraph`module from the Erlang standard libra...
10:57


Tracing

A quick tour of the `dbg` module from Erlang, and its tracing feat...
03:54


Quickie Synth

Using processes, gs, and shelling out to `sox` to build an Elixir-...
09:44
Free!


Plug

Exploring Elixir's library for building composable web applic...
06:08


New Style Comprehensions

An old dog got taught a new trick. But the new trick is kind of l...
02:39


Custom Mix Tasks

Looking at building a basic mix task, and how you can go about tes...
02:57


BEAM Toolbox, Part 5

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


BEAM Toolbox, Part 4

Moving our ad-hoc tuple-based data layer to one powered by maps/st...
08:29


Migrating Records to Maps

Converting a production use of Records to use maps instead.
03:00


Maps, Part 2

Introducing structs and demonstrating how they can take the place ...
02:24
Free!


Maps, Part 1

An introduction to maps, a new feature in Erlang R17 and Elixir 0.13
02:52
Free!


BEAM Toolbox, Part 3

Adding an integration testing layer that drives a browser using Ho...
07:41


BEAM Toolbox, Part 2

Further work on the data layer, and introducing defoverridable.
11:00


BEAM Toolbox, Part 1

Introducing BEAM Toolbox and starting work on the data layer.
07:59


Markdown Server, Part 5

Accepting environment variables for configuration and filtering ou...
04:16


Markdown Server, Part 4

Building a poor man's livereload system using inotify and web...
07:51


Markdown Server, Part 3

Using Eml for markup, and bringing in Compass and Zurb Foundation ...
08:46


Markdown Server, Part 2

Writing an integration test suite and dealing with macros for the ...
09:20


Markdown Server, Part 1

Building a HTTP Server to render Markdown files, using the Phoenix...
06:49


Joe Armstrong's Favorite Erlang Program

Sending messages to remote machines, and Joe Armstrong's favo...
03:10


Distribution

Sending messages from one node to another.
01:59


Releases with Relex

Making your Elixir application redistributable using Erlang releases.
04:12
Free!


File, Part 2

mkdir; rmdir; mkdir\_p; stat; open; stream!; read; stream\_to!; re...
04:14


File, Part 1

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


Bitwise

Manipulating bits; typically useful for wire protocols.
03:16


Binaries - Deconstructing an IP Packet

Deconstructing an IP Packet.
06:47


Binaries - Deconstructing and Constructing

Deconstructing and Constructing lists of bits in Elixir.
03:08


ExLager

Fantastic logging for your applications.
05:15


Weber, Part 2 - Performance

Building a simple cache for our API calls; Performance comparison ...
17:53


Elixiak

An ActiveRecord-like wrapper for Riak in Elixir.
03:34


Pry

A tool to inspect or debug a running process.
01:39


Command Line Scripts

Basic Introduction to writing Elixir scripts that can be invoked a...
06:34


TCP Servers

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


ExActor

Simplified generation of generic servers.
05:37


HTTP Clients

A survey covering: httpc; ibrowse; hackney
07:37


Parsing XML

Exploring the `xmerl` module that is built into Erlang, and intero...
09:21
Free!


Ecto, Part 2 - Dwitter

Using Ecto inside a Dynamo web application.
09:40


Ecto, Part 1

A brief introduction to using Ecto with Postgres for persistence.
08:45
Free!


OTP Part 5 - Supervisors and Persistent State

Storing state in a separate process in order to tolerate a crash w...
11:51


OTP Part 4 - Supervisors

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


Zeldacat, Part 2

Diving further into GenEvent
07:15


OTP Part 3 - GenEvent

Building an Entity-Component system in order to begin the zeldacat...
10:43


Enum, Part 3

map, map\_join, map\_reduce; max, max\_by, min, min\_by; member?, ...
07:40


Enum, Part 2

drop, drop\_while; each; empty?; fetch; filter, filter\_map; find,...
05:24


Enum, Part 1

all?; any?; at; chunks; chunks_by; concat; count
05:04


Pipe Operator

Used for building pipelines of functions; Similar to Unix pipes
13:23


Finite State Machines

What a Finite State Machine (FSM) is; An example FSM that we'll be...
12:55


Servers

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


Processes, Part 2

Modeling a Bank Account with a Process: Deposit; Withdraw; Balance...
10:25


Processes and messaging

What are processes? Playing with processes; Encapsulating state in...
09:49


Records

Note: Elixir Records in this style are deprecated now. You should...
03:54


List Comprehensions

Generating lists from lists (from lists); A real world example (de...
04:59


Unit Testing

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


Mix and Modules

Using mix to begin a new project; Defining a module; Compiling and...
06:58


Functions

Defining Anonymous Functions; Calling Anonymous Functions; Functio...
05:30


Pattern Matching

A discussion of pattern matching in Elixir.
05:48


Basic Elixir

A quick overview of some of the basic types in Elixir: Atoms, Numb...
05:36


Introduction + Installing Elixir

A quick introduction to the screencast, followed by an Erlang / El...
05:47
Free!