Below, you'll find the list of episodes so far. A few are available to watch without a subscription. For the rest, just sign up below.
A quick introduction to the screencast, followed by an Erlang / Elixir installation walkthrough.
A quick overview of some of the basic types in Elixir: Atoms, Numbers, Lists, Tuples, Regexes, and Booleans...
An overview of functions in Elixir: Defining them, calling them, and using them as first-class types.
Using Mix to generate an app, and defining modules and functions.
The first part to an introduction to building a web application in Elixir using Dynamo.
An introduction to Amnesia for persistence, and a brief pointer to Ecto.
Integrating Amnesia and Dynamo to create a web app with a persistence layer.
An overview of list comprehensions in Elixir, or: buildings lists from lists (of lists?).
A discussion of processes in Elixir, and general concurrent programming with messaging.
Modeling a Bank Account in Elixir using processes: encapsulating state, CQRS, and Event Sourcing.
Introduction to OTP, and building and testing a module that implements GenServer.Behaviour.
An overview of what Finite State Machines are good for, and implementing GenFSM.Behaviour to build an acceptor state machine.
An introduction to the pipe operator, and an example app mimicking a unix pipeline.
A brief overview of the first portion of the Enum module from the standard library
A brief overview of the second portion of the Enum module from the standard library
Making a supervised process's state live through a crash.
Overhauling our Dynamo webapp to use Ecto for its persistence layer.
A glimpse into XML parsing in Elixir, by way of interoperating with an Erlang module.
Building network servers in Elixir using Erlang's `:gen_tcp` module.
Basic Introduction to writing Elixir scripts that can be invoked and passed arguments from the command line.
Building a simple cache, and a performance comparison with node.js and ruby.
Deconstructing and Constructing lists of bits in Elixir.
Deconstructing an IP Packet in Elixir.
A brief overview of the first portion of the File module from the standard library.
An overview of the second half of the File module from the standard library.
Sending messages to remote machines, and Joe Armstrong's favorite program.
Building an HTTP Server to render Markdown files, using the Phoenix web framework.
Writing an integration test suite and dealing with macros for the first time.
Using Eml for markup, and bringing in Compass and Zurb Foundation for styles.
Building a poor man's livereload system using inotify and websockets.
Accepting environment variables for configuration and filtering out files we don't want. Plus, a call to action to build BEAM Toolbox.
Introducing BEAM Toolbox and starting work on the data layer.
Further work on the data layer, and introducing defoverridable.
Adding an integration testing layer that drives a browser using Hound, extracting a Controller helper, and adding Project pages.
Introducing structs and demonstrating how they can take the place of public Records.
Converting a production use of Records to use maps instead.
Moving our ad-hoc, tuple-based data layer to one powered by maps/structs.
Building a module that caches our GitHub data for a given project.
Looking at building a basic mix task, and how you can go about testing it.
An overview of the revamped comprehensions in Elixir v0.13
Exploring Elixir's library for building composable web application modules.
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'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.
Using HashNuke's Elixir buildpack for Heroku to deploy BEAM Toolbox. Also, a brief intro to ExConf.
A graphical tool for inspection of a running Erlang/Elixir system and its processes.
Implementing our calculator's logic and wiring it up to wx events.
Process-local state that you likely should never use :)
Erlang term storage - a queryable database for your processes to store terms in.
Manually raising exceptions, handling them, defining your own, and using them idiomatically.
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's supervision tree in 3D.
Elixir'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.
Awesome Print for Elixir. An easy way to get insight into unfamiliar data structures.
(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.
Easy cross-language serialization and deserialization of data structures using Google's Protocol Buffers and exprotobuf.
Taking advantage of Phoenix's native websockets support to build an in-browser bash terminal proxy.
Exploring test coverage report generation, using both Erlang's `cover` application and the Coverex tool.
Using poolboy to build a service for extracting data from a set of links and collecting them into memory for viewing later.
Using Phoenix to build an HTTP API for posting links into the system, and a page to view posted links.
Deploying our application to a VPS from scratch and pushing in our first message.
Fixing some bugs and setting up a Zapier integration.
An unusually formatted episode discussing an ad hoc serial protocol for controlling an Arduino Motor Controller.
Resurrecting the Toolbox with an Ecto-based data layer from scratch, and synchronizing data with the Hex API.
In which we contribute to the elixir codebase and open a pull request.
Managing relationships in Ecto, and integrating Ecto into a Phoenix application.
Making the BEAM Toolbox a bit more useful, including adding in Disqus support.
Building a CLI utility for categorizing our projects as a Mix task.
Building a projects listing page, and reviewing some changes to the toolbox.
Switching to the expression style in Ecto, and using Phoenix's new routing helpers because we must.
Trivial interop between Ruby and Elixir processes using BERT-RPC.
Using `exrm` to build a release of the BEAM Toolbox webapp, for deployment.
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.
Streaming a Twitter search to the browser, because Phoenix Channels are meant to be paired with Elixir Streams, I promise.
Using libpcap from Elixir to see the stream of data passing across your computer's network interface.
Turning a gigantic module into something a little more sensible and well-factored.
Writing some tests and implementing board boundary collision.
Defining the bottom game board boundary and providing the next shape when needed.
Introducing multiple processes into the game, and running the render loop separately from the game logic.
Introducing collision detenction and cleaning up the renderer / game board data structure.
Test-driven implementation of clearing full lines off of the board.
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've written crap code.
Handling typical unix-script style stdin and stdout pipes trivially from your Elixir scripts.
Becoming an SSH client and sending commands to an SSH server with Elixir.
Programmatically interacting with Docker using Elixir and erldocker.
An Elixir profiler, useful for finding where your program is spending its time.
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.
An Elixir package providing fantastically simple support for Postgres's built-in pubsub notifications.
Another benchmarking tool, with a little bit less setup required.
Using the `erlagi` application from Elixir to control the logic of an extension in a PBX system via Asterisk's AGI protocol.
Building out an erlagi handler module in Elixir that interacts with a remote HTTP API.
Two of the core building blocks that the Erlang VM provides. I'd neglected discussing them until now. Oops.
Elixir's package manager, hex.pm, also provides a documentation server for elixir packages. We'll see how to push documentation up.
Using `goma`, which is essentially WebMachine for The Internet Gopher Protocol, to build an elixir-powered gopher server.
Elixir ships with a Set behaviour, and a default HashSet implementation.
A project that adds code generation to Phoenix for building models, controllers, templates, and channels.
Interacting with Erlang'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's markaby.
Getting started interacting with a battle-hardened XMPP chat server by writing Elixir modules for it.
Modifying messages inside of our ejabberd server, specifically - making everyone yell at each other.
Exploring a running Erlang system using tools from the shell.
Building a basic API with Phoenix, and allowing remote domains to access it from the browser.
Basic TCP/IP interactions built into Erlang's kernel application for you.
A dig through Sonny Scroggins' example of integrating a Phoenix application with GitHub via his OAuth2 package.
A comically brief overview of erlcloud and evidence that it does, in fact, work for me.
Exploring the standard library's Code module's `eval_string` function for fun and whatnot.
Using the `detergentex` library, which wraps the erlang `detergent` library, to interact with SOAP services in Elixir.
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 parser for cron-style job definitions.
Determining if a given time is matched by a Schedule.
Executing our jobs on their schedule. Bonus intro to defdelegate and ExUnit's `@tag`s.
Modeling a double-entry ledger. Terribly. And then discussing what went wrong.
Implementing the Logo graphical programming language in Elixir with wxWidgets. In this episode we just implement the underlying GenServer.
Using Semaphore CI to automatically test a Phoenix application each time we push new code.
Combining our L Systems and our Logo Interpreter to explore drunk sierpinski triangles.
Using Elixir to build a bot that can respond to messages in our Slack groups.
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.
Using the `arc` library to enable simple file uploads and image manipulation and versioning in your Phoenix applications.
Using SemaphoreCI to automatically deploy your Phoenix application after the tests run successfully.
Building a Phoenix Application that stores select tweets for display, applying filters, using Twitter's streaming search.
Using Scrivener to paginate Ecto queries and display pagination controls on our web pages.
Adding SemanticUI to ElixirFriends and making it look a little bit better. Also, we beef up the paginator to know what's active.
Using ports and wx to build a visualizer for an audio stream.
Using :observer to find memory leaks in your system, because the BEAM's basically on OS.
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.
Taking further advantage of the power given to us by the almighty BEAM to get faster code for free. Hype hype hype!
Building a React application that interfaces with our Phoenix API for ElixirFriends.
Pushing new posts to ElixirFriends into our React application's state using Phoenix Channels.
Using Mix to build an Erlang Archive Format file and install it as a local archive.
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.
Taking advantage of Elixir's amazing metaprogramming support to build our own AST and compile it into running functions.
Customizing your IEx prompt for productivity and aesthetic purposes.
Looking at the facilities Phoenix provides to assist in writing tests for your channels.
Using the underlying port driver that the Erlang 'REPL' uses to handle terminal-based input one character at a time.
Examining an up and coming coding style enforcement tool.
Writing a C program that has an Elixir interface by way of Erlang's Ports system.
A rapid jaunt through a little spaceship simulator I wrote that has a wx renderer.
Causing a few of the BEAM's failure modes so we can see them in a controlled environment...and because breaking things is fun.
Using Ulf Wiger's `gproc` application to register processes and look them up in interesting ways.
Building a register-based virtual machine with 4 registers and 2 instructions...And a bytecode format...And an assembly language.
Storing custom types in Ecto models...Specifically, storing a particularly-shaped 2-tuple, and barfing on anything else.
Tracing function calls in a running Erlang node, which should be massively helpful for debugging.
Monitoring exceptions in your production applications, whether they'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.
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.
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.
Making our compiler enforce business-level decisions about how functions in a particular module should be written, using @on_definition.
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.
A really nice library for parsing HTML and finding elements in it using CSS selectors.
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.
A lightweight tool that gives you an instant performance monitoring dashboard for Gauges, Counters, and TimeSeries.
A code linting tool focused on giving gentle suggestions and providing explanations for the issues it uncovers.
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.
A library for flexible user authentication, whether from an OAuth provider, a local database, or something else.
A tool to generate end-user API Documentation from your existing API Controller tests.
Kicking off a new project to test-drive a Phoenix app, using Hound for an acceptance test layer.
Using Arc to store product images on S3, make thumbnails, and render them in the templates.
Test-Driving a basic cart implementation, which requires adding a LineItem model. Bonus: Josh fixes bugs on the fly and gets really irritated!
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.
Adding support for removing and updating LineItem quantities. As a bonus, introducing vim-test, which makes ExUnit testing in vim far more pleasant.
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.
Adding the ability for the Register to charge a credit card for the Order via the Stripe API.
Using Stripe's `Checkout` library to provide a nice user experience and avoid handling sensitive credit card details server-side.
A new feature in Elixir 1.2 to provide information about any piece of data.
An explanation of one way hashes, HMACs, password hashing, and a discussion about encryption proper.
Building chatbots with Elixir. With XMPP, Slack, and HipChat adapters already available.
Modifying our existing Hedwig bot to interact with Twitter via ExTwitter.
Using `Task.Supervisor` to supervise our chatbot's ExTwitter streams, restarting them in the event of failure.
Beginning an exploration of OpenGL programming in Elixir, using wx. We'll be porting the NeHe OpenGL tutorials.
Introducing color to our scenes, and making use of the Z coordinates so that we aren't just drawing fancy 2D scenes.
Introducing trivially repeatable shapes with GL Display Lists, and rendering a bitmap as cubes in a scene.
Hooking our OpenGL Bitmap renderer into the Extris game, to render our Tetris clone in 3D.
Using `elm-brunch` to wire your Elm application into Phoenix's default build pipeline.
Using for comprehensions to solve some basic constraint modeling problems.
A library from Thoughtbot that makes it easy to send emails that is testable, composable, and adapter-based.
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!)
Calculating where 2 lines intersect, and using that to determine where walls occlude rays of light