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.
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.
Each lesson focuses on a single aspect of building the project, like modeling the data, building a GraphQL server in Elixir, or building a mobile client for it in Flutter.
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...
A discussion of pattern matching in Elixir.
Defining Anonymous Functions; Calling Anonymous Functions; Functions as First Class Types
Using mix to begin a new project; Defining a module; Compiling and using a module; `defmodule` return value; Documenting a module; Generating HTML Docs
ExUnit; Building an example module via TDD; Exercism.io; DocTests
Note: Deprecated Episode. Introduction to Dynamo; Creating your first app; Views; Routers
Note: Dynamo itself is deprecated. Persistence; Ecto; Amnesia
Note: Dynamo itself is deprecated. Integrating Dynamo and Amnesia
Generating lists from lists (from lists); A real world example (deck of cards) NOTE: Syntax changes, see Episode 060 for details
Note: Elixir Records in this style are deprecated now. You should likely be using maps instead. Defining Records; Pattern Matching on Records
What are processes? Playing with processes; Encapsulating state in a process Note: The `a <- b` syntax has been replaced with `send(a, b)`
Modeling a Bank Account with a Process: Deposit; Withdraw; Balance Inquiry; Command-Query Responsibility Segregation; Event Sourcing
What is OTP?; Implementing GenServer Behaviour; Where to go from here
What a Finite State Machine (FSM) is; An example FSM that we'll be implementing; How to implement an FSM in Elixir using OTP's GenFSM.
Used for building pipelines of functions; Similar to Unix pipes
all?; any?; at; chunks; chunks_by; concat; count
drop, drop\_while; each; empty?; fetch; filter, filter\_map; find, find\_index, find\_value; first; flat\_map; join
map, map\_join, map\_reduce; max, max\_by, min, min\_by; member?, partition, reduce; reject, reverse, shuffle; slice, sort, split; split\_while, take, take\_every; take_while, to\_list, uniq; with\_index, zip
Building an Entity-Component system in order to begin the zeldacat roguelike game.
Diving further into GenEvent
"Let It Crash" But seriously, do. And then recover.
Storing state in a separate process in order to tolerate a crash without losing track of data.
A brief introduction to using Ecto with Postgres for persistence.
Using Ecto inside a Dynamo web application.
delete; drop; empty; equal?; fetch; get; has_key?; keys; merge
pop; put; put\_new; size; split; take; to\_list; update; update!; values
Exploring the `xmerl` module that is built into Erlang, and interoperating with it.
A survey covering: httpc; ibrowse; hackney
Simplified generation of generic servers.
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.
A tool to inspect or debug a running process.
An ActiveRecord-like wrapper for Riak in Elixir.
An MVC Web framework for Elixir, with: Flexible routing; Websocket support; Sessions; Grunt integration; Html Helpers
Building a simple cache for our API calls; Performance comparison with node.js and ruby
Fantastic logging for your applications.
Deconstructing and Constructing lists of bits in Elixir.
Deconstructing an IP Packet.
Manipulating bits; typically useful for wire protocols.
cd; cp_r; chgrp; cwd; chmod; dir?; chown; exists? close; ls; copy
mkdir; rmdir; mkdir\_p; stat; open; stream!; read; stream\_to!; regular?; touch; rm; write; rm\_rf; write\_stat
Making your Elixir application redistributable using Erlang releases.
Sending messages from one node to another.
Sending messages to remote machines, and Joe Armstrong's favorite program, the universal server.
Building a 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.
An introduction to maps, a new feature in Erlang R17 and Elixir 0.13
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 old dog got taught a new trick. But the new trick is kind of like 20 tricks in one.
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.
Interacting with external programs as if they were simple processes.
A graphical tool for inspection of a running Erlang/Elixir system and its processes.
Elixir's new package manager.
Building a GUI calculator using Erlang's native wx bindings.
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.
A disk-based version of ETS with a few restrictions.
A brief overview of Elixir's "lazy, composable Enumerables"
Manually raising exceptions, handling them, defining your own, and using them idiomatically.
A simple abstraction around state.
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.
Generating PCM Audio and making some noise
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.
Generating killer marketing strategies with Elixir
Building a parser for a custom text format.
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.
A pleasant-to-use benchmarking tool that includes graph output.
Using libpcap from Elixir to see the stream of data passing across your computer's network interface.
Handling keyboard input in a wx application.
Making pieces fall and drawing the game board.
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 detection and cleaning up the renderer / game board data structure.
Test-driven implementation of clearing full lines off of the board.
Using the SDL library for graphics from your Elixir programs.
Writing a renderer for the Tetris clone using SDL.
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.
A module in the Erlang Standard Library meant for doing basic graphics.
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.
An easy way to interact with ElasticSearch.
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-power gopher server.
Elixir ships with a Set behaviour, and a default HashSet implementation.
Building quick 'binaries' after a fashion using Elixir's tooling.
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.
Talking to Elixir from Java
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.
Exploring L Systems, on our way to generating fractals.
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.
Building a renderer for our Logo interpreter.
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 out an API endpoint for ElixirFriends in Phoenix
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.
Building an ANSI Tetris renderer for the TTY using iolists.
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.
Rendering our spaceships simulator in 3D with Unity3D
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.
Enforcing your own custom interfaces with Behaviours in Elixir.
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.
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.
Using the festival speech synthesis tool from Elixir.
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.
A random walk through Pi using our Logo interpreter.
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
Wrapping up our raycaster project, resulting in a really fun simulation of light occlusion.
Implementing chat and a user list on top of Phoenix.Presence, a new feature coming in Phoenix 1.2
An Elixir pattern for trivially parallelizing work that has no ordering constraints.
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.
Solving the "N-Queens Problem" driven by tests and types.
Finishing up our solution to the N-Queens Problem, driven by tests and types.
Checking out the new mix tasks provided in Elixir 1.3: `xref`, `app.tree`, `deps.tree`, `test --stale`, and `escript.install`
Exploring Erlang 19's new `gen_statem` behaviour by way of an idiomatic Elixir wrapper, by modeling a door lock with it.
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.
Digging into the corners a bit in the latest features in Ecto 2.0
Building an umbrella application with 2 OTP apps in it, to produce a decoupled RSS handling pipeline.
Exploring Elixir's `with` Special Form, to ease error handling.
Adding a control channel for your frontend clients to facilitate sending RPC-style commands into them from the backend.
Persisting message in chat and providing the chat history to clients when they connect.
Building a Native Implemented Function and corresponding Elixir module, writing the Makefile, and integrating it into mix.
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.
All of this has happened before. All of this will happen again.
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.
A small library that provides a sigil to get the equivalent of ES6 Object Destructuring and Shorthand Property Names in Elixir.
A library that adds some great features like Currying, Partial Function Application, and Composition to Elixir.
Or: The Coolest Thing I Know
Because you shouldn't let just **anyone** screw up your database. That's your users's job!
Because the only thing better than knowing you're right is knowing someone else is a failure.
GenServers and Supervision and IRC bots and queues.
A relatively full-featured User Management System, with a broad feature set, that's pretty painless to set up.
A supremely pleasant library for performing browserless integration tests against your Phoenix application.
Using Scrivener.Headers to add pagination link information to the headers in our API responses, per an RFC Draft.
A library for painlessly enforcing authorization policies in your Phoenix applications.
Providing a restricted S3 policy to a user requesting to upload a file, and using jQuery File Upload to send it to S3.
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.
Using GenStage to completely replace our queue-based system and provide us additional avenues for enhancement.
A quick tip for writing data-driven ExUnit tests.
Painlessly rolling a release tarball of our Elixir application, and producing a systemd unit to run it on system boot.
Identifying why our application stops working in certain crashing situations, and fixing it.
A dashboard framework descended from Dashing, with flair.
An introduction to GraphQL, using the Absinthe package to create a GraphQL server.
Setting up neovim to have a nice Elixir editing environment
Starting a new OTP application to provide on-the-fly, configurable file transformations.
Building a Plug to route requests to our job processing application.
Using a Least-Recently-Used Cache to store our work and avoid repeating ourselves and avoid repeating ourselves.
Building an entirely reasonable service for synchronous Markdown to HTML conversion, via Mechanical Turk
Work on an Elm API client for a project to view Elixir source packages.
I pair with Claudio Ortolina to build my first Flow application.
Josh and Claudio Pair Further on RedditFlow
Pairing a bit to get the Firestorm UI started on good footing.
Working through polymorphism in Ecto for Views and Follows (and eventually tags)
The code in the applications was produced by:
Our content library is pretty great, here are a few lessons we think you might like.
Some other people were willing to publicly state that they like us!
Smooth Terminal has easily been one of the most helpful resources on my journey to better understand Elixir and the Phoenix web framework.
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 Smooth Terminal does this and more.
Smooth Terminal is by far the best resource for learning Elm anywhere, and among the very best online learning platforms, period.