Episodes | Elixir Sips

001: Introduction and Installing Elixir

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

002: Basic Elixir [Subscribers Only]

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

003: Pattern Matching [Subscribers Only]

A discussion of pattern matching in Elixir.

004: Functions [Subscribers Only]

An overview of functions in Elixir: Defining them, calling them, and using them as first-class types.

005: Mix and Modules [Subscribers Only]

Using Mix to generate an app, and defining modules and functions.

006: Unit Testing [Subscribers Only]

Test Driving a module into existence in Elixir.

007: Dynamo, Part 1

The first part to an introduction to building a web application in Elixir using Dynamo.

008: Dynamo, Part 2 [Subscribers Only]

An introduction to Amnesia for persistence, and a brief pointer to Ecto.

009: Dynamo, Part 3 [Subscribers Only]

Integrating Amnesia and Dynamo to create a web app with a persistence layer.

010: List Comprehensions [Subscribers Only]

An overview of list comprehensions in Elixir, or: buildings lists from lists (of lists?).

011: Records [Subscribers Only]

An overview of records in Elixir; what they are, how they're used.

012: Processes [Subscribers Only]

A discussion of processes in Elixir, and general concurrent programming with messaging.

013: Processes, Part 2 [Subscribers Only]

Modeling a Bank Account in Elixir using processes: encapsulating state, CQRS, and Event Sourcing.

014: OTP Part 1 - Servers [Subscribers Only]

Introduction to OTP, and building and testing a module that implements GenServer.Behaviour.

015: OTP Part 2 - Finite State Machines [Subscribers Only]

An overview of what Finite State Machines are good for, and implementing GenFSM.Behaviour to build an acceptor state machine.

016: Pipe Operator [Subscribers Only]

An introduction to the pipe operator, and an example app mimicking a unix pipeline.

017: Enum, Part 1 [Subscribers Only]

A brief overview of the first portion of the Enum module from the standard library

018: Enum, Part 2 [Subscribers Only]

A brief overview of the second portion of the Enum module from the standard library

019: Enum, Part 3 [Subscribers Only]

Wrapping up the Enum module

020: OTP, Part 3 - GenEvent [Subscribers Only]

Getting started with the GenEvent Behaviour

021: ZeldaCat, Part 2 [Subscribers Only]

More practice with GenEvent

022: OTP, Part 4 - Supervisors [Subscribers Only]

How supervisors can help you 'let it crash.'

023: OTP, Part 5 - Supervisors and Persistent State [Subscribers Only]

Making a supervised process's state live through a crash.

024: Ecto, Part 1

An introduction to using Ecto and Postgres for persistence.

025: Ecto, Part 2 - Dwitter [Subscribers Only]

Overhauling our Dynamo webapp to use Ecto for its persistence layer.

026: Dict, Part 1 [Subscribers Only]

A brief overview of the first portion of the Dict module.

027: Dict, Part 2 [Subscribers Only]

A brief overview of the second portion of the Dict module.

028: Parsing XML

A glimpse into XML parsing in Elixir, by way of interoperating with an Erlang module.

029: HTTP Clients [Subscribers Only]

A survey of the HTTP Client landscape.

030: ExActor [Subscribers Only]

Simplified generation of generic servers.

031: TCP Servers [Subscribers Only]

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

032: Command Line Scripts [Subscribers Only]

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

033: Pry [Subscribers Only]

Using IEx.pry to inspect and debug a running process.

034: Elixiak [Subscribers Only]

An ActiveRecord-like wrapper for Riak in Elixir

035: Weber [Subscribers Only]

Building a basic web app with the Weber MVC framework.

036: Weber, Part 2 - Performance [Subscribers Only]

Building a simple cache, and a performance comparison with node.js and ruby.

037: ExLager [Subscribers Only]

Fantastic logging for your application.

038: Binaries - Deconstructing and Constructing [Subscribers Only]

Deconstructing and Constructing lists of bits in Elixir.

039: Binaries - Deconstructing an IP Packet [Subscribers Only]

Deconstructing an IP Packet in Elixir.

040: Bitwise [Subscribers Only]

Manipulating bits; typically useful for wire protocols.

041: File, Part 1 [Subscribers Only]

A brief overview of the first portion of the File module from the standard library.

042: File, Part 2 [Subscribers Only]

An overview of the second half of the File module from the standard library.

043: Releases With Relex

Making your Elixir application redistributable using Erlang releases.

044: Distribution [Subscribers Only]

Sending messages from one Elixir node to another.

045: Distribution, Part 2 [Subscribers Only]

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

046: Markdown Server, Part 1 [Subscribers Only]

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

047: Markdown Server, Part 2 [Subscribers Only]

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

048: Markdown Server, Part 3 [Subscribers Only]

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

049: Markdown Server, Part 4 [Subscribers Only]

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

050: Markdown Server, Part 5 [Subscribers Only]

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

051: BEAM Toolbox, Part 1 [Subscribers Only]

Introducing BEAM Toolbox and starting work on the data layer.

052: BEAM Toolbox, Part 2 [Subscribers Only]

Further work on the data layer, and introducing defoverridable.

053: BEAM Toolbox, Part 3 [Subscribers Only]

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

054: Maps, Part 1

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

055: Maps, Part 2 - Structs

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

056: Migrating Records to Maps [Subscribers Only]

Converting a production use of Records to use maps instead.

057: BEAM Toolbox, Part 4 [Subscribers Only]

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

058: BEAM Toolbox, Part 5 [Subscribers Only]

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

059: Custom Mix Tasks [Subscribers Only]

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

060: New Style Comprehensions [Subscribers Only]

An overview of the revamped comprehensions in Elixir v0.13

061: Plug [Subscribers Only]

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

062: Quickie Synth

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

063: Tracing [Subscribers Only]

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

064: Digraph [Subscribers Only]

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

065: SSH [Subscribers Only]

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

066: Plug.Static [Subscribers Only]

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

067: Deploying to Heroku [Subscribers Only]

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

068: Port [Subscribers Only]

Interacting with external programs as if they were simple processes.

069: Observer [Subscribers Only]

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

070: Hex [Subscribers Only]

Elixir's new package manager.

071: Wx [Subscribers Only]

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

072: WxCalc, Part 2 [Subscribers Only]

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

073: Process Dictionaries [Subscribers Only]

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

074: ETS [Subscribers Only]

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

075: DETS [Subscribers Only]

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

076: Streams [Subscribers Only]

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

077: Exceptions and Errors [Subscribers Only]

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

078: Agents [Subscribers Only]

A simple abstraction around state

079: Tasks [Subscribers Only]

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

080: erlubi [Subscribers Only]

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

081: EEx

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

082: Protocols [Subscribers Only]

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

083: pg2 [Subscribers Only]

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

084: PCM Audio

Generating PCM Audio and making some noise

085: Apex [Subscribers Only]

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

086: put_in and get_in [Subscribers Only]

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

087: WordCloud [Subscribers Only]

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

088: Porcelain [Subscribers Only]

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

089: Protocol Buffers [Subscribers Only]

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

090: Websockets Terminal [Subscribers Only]

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

091: Test Coverage [Subscribers Only]

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

092: Link Extractor [Subscribers Only]

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

093: Link Extractor, Part 2 [Subscribers Only]

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

094: Link Extractor, Part 3 [Subscribers Only]

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

095: Link Extractor, Part 4 [Subscribers Only]

Fixing some bugs and setting up a Zapier integration.

096: Arduino Motor Driver [Subscribers Only]

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

097: BEAM Toolbox, Part 6 [Subscribers Only]

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

098: Contributing to Open Source [Subscribers Only]

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

099: BEAM Toolbox, Part 7 [Subscribers Only]

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

100: BEAM Toolbox, Part 8 [Subscribers Only]

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

101: BEAM Toolbox, Part 9 [Subscribers Only]

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

102: BEAM Toolbox, Part 10 [Subscribers Only]

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

103: BEAM Toolbox, Part 11 [Subscribers Only]

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

104: Ruby to Elixir via BERT-RPC [Subscribers Only]

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

105: Farkov Chain [Subscribers Only]

Generating killer marketing strategies with Elixir

106: Text Parsing [Subscribers Only]

Building a parser for a custom text format.

107: Phoenix Release [Subscribers Only]

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

108: Release Upgrades [Subscribers Only]

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

109: Socket [Subscribers Only]

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

110: ExTwitter [Subscribers Only]

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

111: ExTwitter, Part 2 [Subscribers Only]

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

112: Benchfella [Subscribers Only]

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

113: Monitoring Network Traffic [Subscribers Only]

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

114: Wx Keyboard Events [Subscribers Only]

Handling keyboard input in a wx application.

115: Wx Extris Continued [Subscribers Only]

Making pieces fall and drawing the game board.

116: Wx Extris Part 3 - Refactoring [Subscribers Only]

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

117: Wx Extris Part 4 - Testing [Subscribers Only]

Writing some tests and implementing board boundary collision.

118: Wx Extris Part 5 [Subscribers Only]

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

119: Wx Extris Part 6 [Subscribers Only]

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

120: Wx Extris Part 7 [Subscribers Only]

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

121: Wx Extris Part 8 [Subscribers Only]

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

122: SDL [Subscribers Only]

Using the SDL library for graphics from your Elixir programs.

123: SDL Extris [Subscribers Only]

Writing a renderer for the Tetris clone using SDL.

124: Typespecs [Subscribers Only]

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

125: Dialyzer [Subscribers Only]

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

126: Piping Into Elixir [Subscribers Only]

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

127: SSH Client Commands [Subscribers Only]

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

128: Managing Docker [Subscribers Only]

Programmatically interacting with Docker using Elixir and erldocker.

129: egd [Subscribers Only]

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

130: Extris Web Client [Subscribers Only]

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

131: ExProf [Subscribers Only]

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

132: Randomness in the Erlang VM [Subscribers Only]

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.

133: Boltun - Postgres Listen+Notify [Subscribers Only]

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

134: Elastic Search with Tirexs [Subscribers Only]

An easy way to interact with ElasticSearch.

135: Benchwarmer [Subscribers Only]

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

136: Interfacing with Asterisk [Subscribers Only]

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

137: Asterisk AGI with Elixir [Subscribers Only]

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

138: Monitors and Links [Subscribers Only]

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

139: hexdocs [Subscribers Only]

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

140: gopher [Subscribers Only]

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

141: Set [Subscribers Only]

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

142: escript [Subscribers Only]

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

143: phoenix_generator [Subscribers Only]

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

144: Erlang's `calendar` module [Subscribers Only]

Interacting with Erlang's native date and time types.

145: good_times [Subscribers Only]

An elixir library for trivially specifying relative dates and times.

146: mailman [Subscribers Only]

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

147: webassembly [Subscribers Only]

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

148: ejabberd with Elixir [Subscribers Only]

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

149: ejabberd Packet Filters [Subscribers Only]

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

150: JInterface [Subscribers Only]

Talking to Elixir from Java

151: System Information [Subscribers Only]

Exploring a running Erlang system using tools from the shell.

152: erlang_js [Subscribers Only]

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

153: Phoenix APIs and CORS [Subscribers Only]

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

154: inet [Subscribers Only]

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

155: OAuth2 Code Spelunking [Subscribers Only]

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

156: Interacting with Amazon's APIs with erlcloud [Subscribers Only]

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

157: Playing with the Code Module, Part 1 - eval_string [Subscribers Only]

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

158: SOAP with Detergentex [Subscribers Only]

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

159: Simple One for One Supervisors [Subscribers Only]

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

160: MultiDef [Subscribers Only]

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

161: Building a Cron System, Part 1 [Subscribers Only]

Building a parser for cron-style job definitions.

162: Building a Cron System, Part 2 [Subscribers Only]

Determining if a given time is matched by a Schedule.

163: Building a Cron System, Part 3 [Subscribers Only]

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

164: Fractals [Subscribers Only]

Exploring L Systems, on our way to generating fractals.

165: Accounting 101 [Subscribers Only]

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

166: Implementing Logo

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

167: Implementing Logo, Part 2 (the drawening)

Building a renderer for our Logo interpreter.

168: Continuous Integration

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

169: Fractals, Part 2 [Subscribers Only]

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

170: Building a Slack Bot [Subscribers Only]

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

171: Erlang 18 and Time [Subscribers Only]

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.

172: Arc File Uploads [Subscribers Only]

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

173: Continuous Deployment [Subscribers Only]

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

174: ElixirFriends - Saving Tweets with Streams and Filters [Subscribers Only]

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

175: Pagination with Ecto and Phoenix [Subscribers Only]

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

176: Prettying Up ElixirFriends [Subscribers Only]

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

177: Audio Visualizer [Subscribers Only]

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

178: Memory Leaks [Subscribers Only]

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

179: Rules Engine [Subscribers Only]

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

180: Collectable [Subscribers Only]

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

181: Native Compilation with HiPE [Subscribers Only]

Taking further advantage of the power given to us by the almighty BEAM to get faster code for free. Hype hype hype!

182: Phoenix API [Subscribers Only]

Building out an API endpoint for ElixirFriends in Phoenix

183: React with Phoenix [Subscribers Only]

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

184: React with Phoenix Channels [Subscribers Only]

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

185: Mix Archives [Subscribers Only]

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

186: Automatically Connecting Nodes [Subscribers Only]

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.

187: Compiling a Custom AST Into Elixir Functions [Subscribers Only]

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

188: ElixirScript [Subscribers Only]

Because writing Elixir is far preferable to writing JavaScript.

189: .iex.exs [Subscribers Only]

Customizing your IEx prompt for productivity and aesthetic purposes.

190: Testing Phoenix Channels [Subscribers Only]

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

191: Interesting I/O [Subscribers Only]

Building an ANSI Tetris renderer for the TTY using iolists.

192: Interesting I/O, Part 2 - Input with `tty_sl` [Subscribers Only]

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

193: Linting with Dogma [Subscribers Only]

Examining an up and coming coding style enforcement tool.

194: Interoperability - Ports [Subscribers Only]

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

195: Spaceships [Subscribers Only]

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

196: Crashing the BEAM [Subscribers Only]

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

197: gproc [Subscribers Only]

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

198: Elixir and Unity3D [Subscribers Only]

Rendering our spaceships simulator in 3D with Unity3D

199: Modeling a Virtual Machine [Subscribers Only]

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

200: Custom Types in Ecto [Subscribers Only]

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

201: Tracing and Debugging with erlyberly [Subscribers Only]

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

202: Exception Monitoring with Honeybadger.io [Subscribers Only]

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

203: plug_auth [Subscribers Only]

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

204: Behaviours [Subscribers Only]

Enforcing your own custom interfaces with Behaviours in Elixir.

205: The Opposite of Mocks [Subscribers Only]

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.

206: Getting a Nested Module From a String [Subscribers Only]

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.

207: XMLRPC [Subscribers Only]

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

208: Compile Time Interface Policy Enforcement [Subscribers Only]

Making our compiler enforce business-level decisions about how functions in a particular module should be written, using @on_definition.

209: Integration Tests with Hound [Subscribers Only]

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

210: Visualizing Another Node With `ex_top` [Subscribers Only]

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.

211: Parsing and Searching HTML With Floki [Subscribers Only]

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

212: Streaming Structured Data From Webpages With Stream.resource [Subscribers Only]

Combining Floki and Stream.resource to turn a static HTML site into a paginating stream of structured data.

213: Stripe [Subscribers Only]

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

214: Visualixir [Subscribers Only]

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

215: Tracking Performance Metrics with Beaker [Subscribers Only]

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

216: Code Linting with Credo [Subscribers Only]

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

217: Internationalizing a Phoenix Application with Gettext [Subscribers Only]

An overview of Phoenix's new Gettext support for allowing easy string translation in your app for various locales.

218: CSV [Subscribers Only]

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

219: User Authentication with Ueberauth [Subscribers Only]

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

220: Bureaucrat API Documentation [Subscribers Only]

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

221: `erl_festival` [Subscribers Only]

Using the festival speech synthesis tool from Elixir.

222: TDDing an E-Commerce Site With Phoenix, Part 1 - Setup [Subscribers Only]

Kicking off a new project to test-drive a Phoenix app, using Hound for an acceptance test layer.

223: TDDing an E-Commerce Site With Phoenix, Part 2 - Images [Subscribers Only]

Using Arc to store product images on S3, make thumbnails, and render them in the templates.

224: TDDing an E-Commerce Site With Phoenix, Part 3 - Cart [Subscribers Only]

Test-Driving a basic cart implementation, which requires adding a LineItem model. Bonus: Josh fixes bugs on the fly and gets really irritated!

225: TDDing an E-Commerce Site with Phoenix, Part 4 - Multiple Carts [Subscribers Only]

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.

226: TDDing an E-Commerce Site With Phoenix, Part 5 - Updating Carts [Subscribers Only]

Adding support for removing and updating LineItem quantities. As a bonus, introducing vim-test, which makes ExUnit testing in vim far more pleasant.

227: TDDing an E-Commerce Site With Phoenix, Part 6 - Completing an Order [Subscribers Only]

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.

228: TDDing an E-Commerce Site With Phoenix, Part 7 - Stripe [Subscribers Only]

Adding the ability for the Register to charge a credit card for the Order via the Stripe API.

229: TDDing an E-Commerce Site With Phoenix, Part 8 - Stripe Checkout [Subscribers Only]

Using Stripe's `Checkout` library to provide a nice user experience and avoid handling sensitive credit card details server-side.

230: The `i` Helper [Subscribers Only]

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

231: Pi Walk With Logo [Subscribers Only]

A random walk through Pi using our Logo interpreter.

232: Encryption and Hashing [Subscribers Only]

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

233: Hedwig Bot Framework [Subscribers Only]

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

234: Hedwig Twitter Bot [Subscribers Only]

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

235: Supervising Hedwig Twitter [Subscribers Only]

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

236: OpenGL in Elixir [Subscribers Only]

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

237: OpenGL Part 2 - Color and Depth [Subscribers Only]

Introducing color to our scenes, and making use of the Z coordinates so that we aren't just drawing fancy 2D scenes.

238: OpenGL: 3D Bitmaps [Subscribers Only]

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

239: OpenGL Extris [Subscribers Only]

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

240: Phoenix and Elm [Subscribers Only]

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

241: Constraint Solving [Subscribers Only]

Using for comprehensions to solve some basic constraint modeling problems.

242: Bamboo Email [Subscribers Only]

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

243: Moebius - Functional Database Queries [Subscribers Only]

A library from Rob Conery for querying PostgreSQL databases that is composable, supports JSONB document databases, and in general makes constructing queries extremely pleasant.

244: Raycaster [Subscribers Only]

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

245: Raycaster Part 2: Finding Intersections [Subscribers Only]

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

246: Raycaster Part 3: Finishing Up [Subscribers Only]

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

247: Phoenix.Presence Chat [Subscribers Only]

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

248: Hunt Gather [Subscribers Only]

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

249: Webpack, Phoenix, and Elm [Subscribers Only]

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.

250: Constraint Solving, Part 2: N-Queens Problem [Subscribers Only]

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

251: Constraint Solving, Part 3: N-Queens Problem, Part 2 [Subscribers Only]

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

252: Elixir 1.3 Mix Tasks [Subscribers Only]

Checking out the new mix tasks provided in Elixir 1.3: `xref`, `app.tree`, `deps.tree`, `test --stale`, and `escript.install`

253: `gen_state_machine` [Subscribers Only]

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

254: Ecto 2.0 [Subscribers Only]

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.

255: Ecto 2.0 Exploration [Subscribers Only]

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

256: OTP Pipeline [Subscribers Only]

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

257: with [Subscribers Only]

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

258: Commanding the Client with Phoenix Channels [Subscribers Only]

Adding a control channel for your frontend clients to facilitate sending RPC-style commands into them from the backend.

260: NIFs [Subscribers Only]

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

261: GenStage By Way of Pairing [Subscribers Only]

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.

262: Phoenix Is An Interface, Not Your Application [Subscribers Only]

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

263: Phoenix Is An Interface, Not Your Application, Part 2 [Subscribers Only]

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.

264: ShortMaps [Subscribers Only]

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

265: Currying (and More) with Quark [Subscribers Only]

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

266: Church Encoding in Elixir [Subscribers Only]

Or: The Coolest Thing I Know

267: Guardian and Phoenix APIs [Subscribers Only]

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

268: Making Sure the Other Party is Wrong [Subscribers Only]

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

269: Slurping Links Out of a Free Slack with ExIrc [Subscribers Only]

GenServers and Supervision and IRC bots and queues.

270: Phoenix Users with Coherence [Subscribers Only]

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

271: Boyd Multerer's `phoenix_integration` [Subscribers Only]

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

272: Phoenix API Pagination with Scrivener [Subscribers Only]

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

273: Boyd Multerer's `policy_wonk` [Subscribers Only]

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

274: Direct Uploads with S3 in a Phoenix API [Subscribers Only]

Providing a restricted S3 policy to a user requesting to upload a file, and using jQuery File Upload to send it to S3.

275: Slurping Links Out of a Free Slack with ExIrc, Part 2 [Subscribers Only]

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.