Firestorm Pairing Session 5 - Josh Adams and Andrew Vy Working with Ecto Polymorphism
Working through polymorphism in Ecto for Views and Follows (and ev...
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.
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
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.
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...
Building an entirely reasonable service for synchronous Markdown t...
Adding an LRU Cache to Fly
Using a Least-Recently-Used Cache to store our work and avoid repe...
Building a Plug to route requests to our job processing application.
Building a File Processing Server
Starting a new OTP application to provide on-the-fly, configurable...
Setting up neovim to have a nice Elixir editing environment
An introduction to GraphQL, using the Absinthe package to create a...
Building a Dashboard with Kitto
A dashboard framework descended from Dashing, with flair.
Debugging Situations Where You Haven't Fully
Let It Crash
Identifying why our application stops working in certain crashing ...
Using Distillery to Create a Release of our ExIrc Slack Bot
Painlessly rolling a release tarball of our Elixir application, an...
Metaprogramming Model Validation Tests
A quick tip for writing data-driven ExUnit tests.
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...
Slurping Links Out of a Free Slack with ExIrc, Part 2
Pushing messages with links into the queue, building a quick WordP...
Direct Uploads with S3 in a Phoenix API
Providing a restricted S3 policy to a user requesting to upload a ...
A library for painlessly enforcing authorization policies in your ...
Phoenix API Pagination with Scrivener
Using Scrivener.Headers to add pagination link information to the ...
A supremely pleasant library for performing browserless integratio...
Phoenix Users with Coherence
A relatively full-featured User Management System, with a broad fe...
Slurping Links Out of a Free Slack with ExIrc
GenServers and Supervision and IRC bots and queues.
Making Sure the Other Party is Wrong
Because the only thing better than knowing you're right is knowing...
Guardian and Phoenix APIs
Because you shouldn't let just **anyone** screw up your database. ...
Church Encoding in Elixir
Or: The Coolest Thing I Know
Currying (and More) with Quark
A library that adds some great features like Currying, Partial Fun...
A small library that provides a sigil to get the equivalent of ES6...
Phoenix Is An Interface, Not Your Application, Part 2
Completing our Channels-based collaboration, seeing another "I did...
Phoenix Is An Interface, Not Your Application
All of this has happened before. All of this will happen again.
GenStage By Way of Pairing
In which Theron Boerner and I paired on prototyping a Continuous I...
Building a Native Implemented Function and corresponding Elixir mo...
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...
Exploring Elixir's `with` Special Form, to ease error handling.
Building an umbrella application with 2 OTP apps in it, to produce...
Digging into the corners a bit in the latest features in Ecto 2.0
Ecto 2.0 was released. We'll look at it from the ground up, point...
Exploring Erlang 19's new `gen_statem` behaviour by way of an idio...
Checking out the new mix tasks provided in Elixir 1.3: `xref`, `ap...
Constraint Solving, Part 3: N-Queens Problem, Part 2
Finishing up our solution to the N-Queens Problem, driven by tests...
Constraint Solving, Part 2: N-Queens Problem
Solving the "N-Queens Problem" driven by tests and types.
Webpack, Phoenix, and Elm
A walkthrough of starting a new webpack-based project in Phoenix, ...
An Elixir pattern for trivially parallelizing work that has no ord...
Implementing chat and a user list on top of Phoenix.Presence, a ne...
Raycaster Part 3: Finishing Up
Wrapping up our raycaster project, resulting in a really fun simul...
Raycaster Part 2: Finding Intersections
Calculating where 2 lines intersect, and using that to determine w...
Casting rays and simulating how light falls when cut off by variou...
Moebius - Functional Database Queries
A library from Rob Conery for querying PostgreSQL databases that i...
A library from Thoughtbot that makes it easy to send emails that i...
Using for comprehensions to solve some basic constraint modeling p...
Using `elm-brunch` to wire your Elm application into Phoenix's def...
Hooking our OpenGL Bitmap renderer into the Extris game, to render...
Introducing trivially repeatable shapes with GL Display Lists, and...
OpenGL Part 2 - Color and Depth
Introducing color to our scenes, and making use of the Z coordinat...
Beginning an exploration of OpenGL programming in Elixir, using wx...
Supervising Hedwig Twitter
Using `Task.Supervisor` to supervise our chatbot's ExTwitter strea...
Modifying our existing Hedwig bot to interact with Twitter via ExT...
Building chatbots with Elixir. With XMPP, Slack, and HipChat adap...
An explanation of one way hashes, HMACs, password hashing, and a d...
A random walk through Pi using our Logo interpreter.
A new feature in Elixir 1.2 to provide information about any piece...
TDDing an E-Commerce Site With Phoenix, Part 8 - Stripe Checkout
Using Stripe's `Checkout` library to provide a nice user experienc...
TDDing an E-Commerce Site With Phoenix, Part 7 - Stripe
Adding the ability for the Register to charge a credit card for th...
TDDing an E-Commerce Site With Phoenix, Part 6 - Completing an Order
Introducing an Order model, and a Register module that encapsulate...
TDDing an E-Commerce Site With Phoenix, Part 5 - Updating Carts
Adding support for removing and updating LineItem quantities. As ...
TDDing an E-Commerce Site with Phoenix, Part 4 - Multiple Carts
Introducing an actual Cart model. Involves multiple browser sessi...
TDDing an E-Commerce Site With Phoenix, Part 3 - Cart
Test-Driving a basic cart implementation, which requires adding a ...
TDDing an E-Commerce Site With Phoenix, Part 2 - Images
Using Arc to store product images on S3, make thumbnails, and rend...
TDDing an E-Commerce Site With Phoenix, Part 1 - Setup
Kicking off a new project to test-drive a Phoenix app, using Hound...
Using the festival speech synthesis tool from Elixir.
Bureaucrat API Documentation
A tool to generate end-user API Documentation from your existing A...
User Authentication with Ueberauth
A library for flexible user authentication, whether from an OAuth ...
A look at an unbelievably well-built CSV encoding and decoding lib...
Internationalizing a Phoenix Application with Gettext
An overview of Phoenix's new Gettext support for allowing easy str...
A code linting tool focused on giving gentle suggestions and provi...
Tracking Performance Metrics with Beaker
A lightweight tool that gives you an instant performance monitorin...
A tool to visualize your application and trace messages between pr...
Using Rob Conery's `stripity_stripe` library to easily work with S...
Streaming Structured Data From Webpages With Stream.resource
Combining Floki and Stream.resource to turn a static HTML site int...
Parsing and Searching HTML With Floki
A really nice library for parsing HTML and finding elements in it ...
Visualizing Another Node With
A quick demonstration of the `ex_top` tool for visualizing a remot...
Integration Testing with Hound
Compile-Time Interface Policy Enforcement using
Making our compiler enforce business-level decisions about how fun...
Integrating with systems that use XMLRPC as their remote execution...
Getting a Nested Module From a String
A few unsafe ways to turn user input into a module, a wrongheaded ...
A strategy that I employed to get around a module that was particu...
Enforcing your own custom interfaces with Behaviours in Elixir.
An unbelievably simple plug for adding authentication and role-bas...
Exception Monitoring with Honeybadger.io
Monitoring exceptions in your production applications, whether the...
Tracing and Debugging with erlyberly
Tracing function calls in a running Erlang node, which should be m...
Storing custom types in Ecto models. Specifically, storing a part...
Modeling a Virtual Machine
Building a register-based virtual machine with 4 registers and 2 i...
Rendering our spaceships simulator in 3D with Unity3D
Using Ulf Wiger's `gproc` application to register processes a...
Causing a few of the BEAM's failure modes so we can see them ...
A rapid jaunt through a little spaceship simulator I wrote that ha...
Writing a C program that has an Elixir interface by way of Erlang&...
Examining an up and coming coding style enforcement tool.
Interesting IO, Part 2 - Input with
Using the underlying port driver that the Erlang "REPL" ...
Building an ANSI Tetris renderer for the TTY using iolists.
Looking at the facilities Phoenix provides to assist in writing te...
Customizing your IEx prompt for productivity and aesthetic purposes.
Compiling a Custom AST Into Elixir Functions
Taking advantage of Elixir's amazing metaprogramming support ...
Automatically Connecting Nodes
Using Erlang's sys.config file to tell our application to wir...
Using Mix to build an Erlang Archive Format file and install it as...
React with Phoenix Channels
Pushing new posts to ElixirFriends into our React application&apos...
Building a React application that interfaces with our Phoenix API ...
Building out an API endpoint for ElixirFriends in Phoenix
Native Compilation with HiPE
Taking further advantage of the power given to us by the almighty ...
Implementing the Collectable protocol to clean up a common pattern...
Building a Rules Engine and benchmarking a couple of different pro...
Using :observer to find memory leaks in your system, because the B...
Using ports and wx to build a visualizer for an audio stream.
Prettying Up ElixirFriends
Adding SemanticUI to ElixirFriends and making it look a little bit...
Pagination with Ecto and Phoenix using Scrivener
Using Scrivener to paginate Ecto queries and display pagination co...
ElixirFriends - Saving Tweets with Streams and Filters
Building a Phoenix Application that stores select tweets for displ...
Deploying Phoenix Applications to Heroku
Using SemaphoreCI to automatically deploy your Phoenix application...
Using the `arc` library to enable simple file uploads and image ma...
Learning how to replace calls to `:erlang.now` with the new API fo...
Using Elixir to build a bot that can respond to messages in our Sl...
Combining our L Systems and our Logo Interpreter to explore drunk ...
Using Semaphore CI to automatically test a Phoenix application eac...
Implementing Logo, Part 2
Building a renderer for our Logo interpreter.
Implementing Logo, Part 1
Implementing the Logo graphical programming language in Elixir wit...
Modeling a double-entry ledger. Terribly. And then discussing what...
Exploring L Systems, on our way to generating fractals.
Building a Cron System, Part 3
Executing our jobs on their schedule. Bonus intro to defdelegate ...
Building a Cron System, Part 2
Determining if a given time is matched by a Schedule.
Building a Cron System - Part 1
Building a parser for cron-style job definitions.
A less-verbose way to define multiple function clauses, courtesy o...
Simple One for One Supervisors
Getting a dynamically spawned process into a supervision tree to a...
Using the `detergentex` library, which wraps the erlang `detergent...
Playing with the Code Module, Part 1 -
Exploring the standard library's Code module's `eval_str...
Interacting with Amazon's APIs with erlcloud
A comically brief overview of erlcloud and evidence that it does, ...
A dig through Sonny Scroggins' example of integrating a Phoen...
Basic TCP/IP interactions built into Erlang's kernel applicat...
Building a basic API with Phoenix, and allowing remote domains to ...
Exploring a running Erlang system using tools from the shell.
Talking to Elixir from Java
Modifying messages inside of our ejabberd server, specifically - m...
Getting started interacting with a battle-hardened XMPP chat serve...
Generate markup from blocks of elixir code, in the style of _why t...
Easily send emails, parse emails, and verify email related feature...
An elixir library for trivially specifying relative dates and times.
Interacting with Erlang's native date and time types.
A project that adds code generation to Phoenix for building models...
Building quick 'binaries' after a fashion using Elixir&a...
Elixir ships with a Set behaviour, and a default HashSet implement...
Using `goma`, which is essentially WebMachine for The Internet Gop...
Elixir's package manager, hex.pm, also provides a documentati...
Two of the core building blocks that the Erlang VM provides. I&ap...
Building out an erlagi handler module in Elixir that interacts wit...
Interfacing with Asterisk
Using the `erlagi` application from Elixir to control the logic of...
Another benchmarking tool, with a little bit less setup required.
Elastic Search with Tirexs
An easy way to interact with ElasticSearch.
Boltun - Postgres Listen + Notify
An Elixir package providing fantastically simple support for Postg...
Randomness in the Erlang VM
An exploration of where our randomness in Tetris went so horribly ...
An Elixir profiler, useful for finding where your program is spend...
A module in the Erlang Standard Library meant for doing basic grap...
Programmatically interacting with Docker using Elixir and erldocker.
Becoming an SSH client and sending commands to an SSH server with ...
Handling typical unix-script style stdin and stdout pipes triviall...
Letting the computer (rather than logs or users) tell you when you...
Layering type information over your functions to aid users and sta...
Writing a renderer for the Tetris clone using SDL.
Using the SDL library for graphics from your Elixir programs.
Test-driven implementation of clearing full lines off of the board.
Introducing collision detection and cleaning up the renderer / gam...
Wx Extris Part 6 - Concurrent Rendering
Introducing multiple processes into the game, and running the rend...
Defining the bottom game board boundary and providing the next sha...
Wx Extris Part 4 - Testing
Writing some tests and implementing board boundary collision.
Wx Extris Part 3, Refactoring
Turning a gigantic module into something a little more sensible an...
Making pieces fall and drawing the game board.
Handling keyboard input in a wx application.
Monitoring Network Traffic
Using libpcap from Elixir to see the stream of data passing across...
A pleasant-to-use benchmarking tool that includes graph output.
Streaming a Twitter search to the browser, because Phoenix Channel...
A library for interacting with the Twitter API, using standard req...
A pleasant abstraction around `gen_tcp`, `gen_udp`, `gen_sctp`, an...
Upgrading a running app to a new version without losing state.
Using `exrm` to build a release of the BEAM Toolbox webapp, for de...
Building a parser for a custom text format.
Generating killer marketing strategies with Elixir
Ruby to Elixir via BERT-RPC
Trivial interop between Ruby and Elixir processes using BERT-RPC.
Switching to the expression style in Ecto, and using Phoenix'...
Building a projects listing page, and reviewing some changes to th...
Building a CLI utility for categorizing our projects as a Mix task.
Making the BEAM Toolbox a bit more useful, including adding in Dis...
Managing relationships in Ecto, and integrating Ecto into a Phoeni...
Contributing to Open Source
In which we contribute to the elixir codebase and open a pull requ...
Resurrecting the Toolbox with an Ecto-based data layer from scratc...
An unusually formatted episode discussing an ad hoc serial protoco...
Fixing some bugs and setting up a Zapier integration.
Deploying our application to a VPS from scratch and pushing in our...
Using Phoenix to build an HTTP API for posting links into the syst...
Using poolboy to build a service for extracting data from a set of...
Exploring test coverage report generation, using both Erlang'...
Taking advantage of Phoenix's native websockets support to bu...
Easy cross-language serialization and deserialization of data stru...
External Process interaction like the Port module but both simpler...
Using Elixir to do a word frequency count on a corpus of text and ...
(and friends) Easy access to deeply nested data structures.
Awesome Print for Elixir. An easy way to get insight into unfamili...
Generating PCM Audio and making some noise
A replacement for the `pg` module that has some better semantics f...
A fantastic method for polymorphism in Elixir. Pairs well with str...
Elixir's built-in templating language, useful for embedding E...
A client for the Ubigraph visualization server, and an easy way to...
An abstraction for computing a value in the background and receivi...
A simple abstraction around state.
Manually raising exceptions, handling them, defining your own, and...
A brief overview of Elixir's "lazy, composable Enumerabl...
A disk-based version of ETS with a few restrictions.
Erlang term storage - a queryable database for your processes to s...
Process-local state that you likely should never use :)
Implementing our calculator's logic and wiring it up to wx ev...
Building a GUI calculator using Erlang's native wx bindings.
Elixir's new package manager.
A graphical tool for inspection of a running Erlang/Elixir system ...
Interacting with external programs as if they were simple processes.
Using HashNuke's Elixir buildpack for Heroku to deploy BEAM T...
Serving static files without an opaque and complicated-looking cow...
Using Erlang's `ssh` module to provide ssh access to a shell ...
A look at using the `digraph`module from the Erlang standard libra...
A quick tour of the `dbg` module from Erlang, and its tracing feat...
Using processes, gs, and shelling out to `sox` to build an Elixir-...
Exploring Elixir's library for building composable web applic...
An old dog got taught a new trick. But the new trick is kind of l...
Looking at building a basic mix task, and how you can go about tes...
Building a module that caches our GitHub data for a given project.
Moving our ad-hoc tuple-based data layer to one powered by maps/st...
Migrating Records to Maps
Converting a production use of Records to use maps instead.
Introducing structs and demonstrating how they can take the place ...
An introduction to maps, a new feature in Erlang R17 and Elixir 0.13
Adding an integration testing layer that drives a browser using Ho...
Further work on the data layer, and introducing defoverridable.
Introducing BEAM Toolbox and starting work on the data layer.
Accepting environment variables for configuration and filtering ou...
Building a poor man's livereload system using inotify and web...
Using Eml for markup, and bringing in Compass and Zurb Foundation ...
Writing an integration test suite and dealing with macros for the ...
Building a HTTP Server to render Markdown files, using the Phoenix...
Joe Armstrong's Favorite Erlang Program
Sending messages to remote machines, and Joe Armstrong's favo...
Sending messages from one node to another.
Making your Elixir application redistributable using Erlang releases.
mkdir; rmdir; mkdir\_p; stat; open; stream!; read; stream\_to!; re...
cd; cp_r; chgrp; cwd; chmod; dir?; chown; exists? close; ls; copy
Manipulating bits; typically useful for wire protocols.
Binaries - Deconstructing an IP Packet
Deconstructing an IP Packet.
Binaries - Deconstructing and Constructing
Deconstructing and Constructing lists of bits in Elixir.
Fantastic logging for your applications.
Weber, Part 2 - Performance
Building a simple cache for our API calls; Performance comparison ...
An ActiveRecord-like wrapper for Riak in Elixir.
A tool to inspect or debug a running process.
Basic Introduction to writing Elixir scripts that can be invoked a...
Building network servers in Elixir using Erlang's `:gen_tcp` module.
Simplified generation of generic servers.
A survey covering:
httpc; ibrowse; hackney
Exploring the `xmerl` module that is built into Erlang, and intero...
Using Ecto inside a Dynamo web application.
A brief introduction to using Ecto with Postgres for persistence.
OTP Part 5 - Supervisors and Persistent State
Storing state in a separate process in order to tolerate a crash w...
"Let It Crash"
But seriously, do. And then recover.
Diving further into GenEvent
Building an Entity-Component system in order to begin the zeldacat...
map, map\_join, map\_reduce; max, max\_by, min, min\_by; member?, ...
drop, drop\_while; each; empty?; fetch; filter, filter\_map; find,...
all?; any?; at; chunks; chunks_by; concat; count
Used for building pipelines of functions; Similar to Unix pipes
What a Finite State Machine (FSM) is; An example FSM that we'll be...
What is OTP?; Implementing GenServer Behaviour; Where to go from here
Modeling a Bank Account with a Process: Deposit; Withdraw; Balance...
What are processes? Playing with processes; Encapsulating state in...
Note: Elixir Records in this style are deprecated now. You should...
Generating lists from lists (from lists); A real world example (de...
ExUnit; Building an example module via TDD; Exercism.io; DocTests
Using mix to begin a new project; Defining a module; Compiling and...
Defining Anonymous Functions; Calling Anonymous Functions; Functio...
A discussion of pattern matching in Elixir.
A quick overview of some of the basic types in Elixir: Atoms, Numb...
Introduction + Installing Elixir
A quick introduction to the screencast, followed by an Erlang / El...