ElixirCasts Alchemist's Edition Episodes

Hello everyone, these are the episodes that are part the Alchemist’s Edition, which is the paid subscription that helps support ElixirCasts.

Episode #114: Phoenix LiveView JS Hooks
Phoenix LiveView provides JS Hooks as a way to integrate LiveView with JavaScript. In this episode, we’ll create a new Phoenix LiveView project and see how we can use a hook to integrate it with a color-picker library.

Episode #109: DynamicSupervisor and Registry
In this episode we’ll pick up where we left off in #108 and refactor our application to create a process for each user shopping cart. To do this we’ll use DynamicSupervisor and Elixir’s Registry.

Episode #108: Shopping Cart Part 2
In part 2 of this series we’ll add to our existing shopping cart by allowing users to remove items from their existing carts.

Episode #107: Shopping Cart Part 1
There are many ready-made ecommerce solutions, but sometimes you need to write your own. In this episode we’ll start building custom shopping cart functionality into an existing application with OTP.

Episode #104: Generating RSS Feeds with Elixir
In this episode we’ll take an existing Elixir Phoenix application and build an Atom feed for it. To build the feed we’ll use the Atomex package.

Episode #102: OTP backed Web Application Part 4
In the final part of this series we’ll use Phoenix Channels to improve the UI so that our coin tracker page updates automatically when a new cryptocurrency price is found.

Episode #101: OTP backed Web Application Part 3
In part 3 we’ll create a schema for our coin data so that we don’t lose data when we restart our app.

Episode #99: OTP backed Web Application Part 2
In part 2 we’ll update our application to allow users to add cryptocurrencies from the UI. Once added, we’ll display the cryptocurrency and update pricing every minute using a GenServer.

Episode #98: OTP backed Web Application Part 1
In part one of this series we’ll lay the foundation for our application. First we’ll see how we can fetch cryptocurrency prices. Then we’ll create a GenServer to store the prices and add it to our supervision tree.

Episode #97: Schemaless Form Validations with Changesets
In this episode we’ll take an existing contact form and see how Ecto changesets can be used to perform schemaless form validations and display errors.

Episode #96: Contact Form
In this episode we’ll build a contact form for an existing Elixir Phoenix application. When a user submits the form, an email will be sent using the Bamboo library.

Episode #95: Phoenix LiveView Part 4
In part 4 of our Phoenix LiveView series we’ll use Phoenix Presence to track how many users are currently signed in to our application.

Episode #93: Ecto.Multi
In this episode we’ll explore Ecto.Multi in order to compose database transactions in Elixir.

Episode #90: Nested Forms with Phoenix
In this episode we’ll explore one way to use Phoenix to create a nested form that saves an associated record in our database.

Episode #89: Phoenix LiveView Part 3
In part 3 of our series we’ll broadcast album changes to all clients using Phoenix.PubSub and Phoenix LiveView.

Episode #86: API Authorization with API Keys Part 2
Now that we have our application generating API keys, we need to validate incoming API requests. In part 2 of this series, we’ll create a plug that validates the API key used.

Episode #85: API Authorization with API Keys Part 1
There are many different ways to authorize API requests. In part 1 of this series we will setup an Elixir application to generate an API key we can use to authorize API requests with.

Episode #84: JSON:API Pagination
In this episode we’ll learn how to paginate JSON API results according to the JSON:API specification using the JaSerializer package.

Episode #83: JSON:API with JaSerializer
In this episode we’ll update an existing JSON API to follow the JSON:API specification. To help us, we’ll use the the JaSerializer package.

Episode #80: Proactive Caching
In this episode we’ll use proactive caching with Cachex. Proactive caching can help ensure there is never a cache miss since data is loaded when the application starts.

Episode #79: Caching with Cachex
Here we look at how to use Cachex to create a cache in an Elixir application. We’ll start by seeing how to interact with Cachex and then we’ll implement a simple cache in our application.

Episode #77: Validating API Parameters Part 2
In this episode we’ll explore another way to validate API params. We’ll update our existing example to use the Params package, which reduces much of the boilerplate of defining Ecto schemas and changesets.

Episode #76: Validating API Parameters Part 1
In this episode we’ll see how we can validate API parameters . We’ll take a simple search API and use schemaless Ecto changesets to validate the request parameters.

Episode #74: Erlang Term Storage - ETS
In this episode we’re getting started with Erlang Term Storage or ETS. We’ll learn the basics of storing data with ETS, then we’ll expand on that to see how ETS can be used in a Phoenix application.

Episode #73: Basic Auth
HTTP Basic Authentication is a simple way to add authenticate users in an application. In this episode we’ll see how to add basic auth to an Elixir application.

Episode #72: Intro to Elixir Streams
In this episode we’ll get an introduction to Elixir Streams. We’ll see why they’re called “lazy enumerables” and how they can be composed to perform more complex transformations.

Episode #70: Updating Page Data with Channels
In this episode we’ll see how we can easily use Phoenix Channels to broadcast events from the server in order to update the client in realtime.

Episode #69: Receiving Webhooks
In this episode we’ll learn how to consume a webhook. Our application will take the data from a Stripe webhook and use it update the corresponding user.

Episode #67: Custom Mix Task
You’ll use Mix tasks all the time when using Elixir, from creating a new Elixir project to seeding the database. In this episode we’ll learn how to create a custom Mix task.

Episode #63: Getting Started with Tasks
In this episode we’ll be exploring one of the key features of Elixir: tasks. Tasks make it easy to run Elixir code concurrently. In this episode we’ll look at some common ways Task is used.

Episode #61: Twitter Authentication
In this episode we’ll be adding the ability for users to sign in to a Phoenix web application with Twitter. We’ll use Ueberauth to help us handle the OAuth flow to and from Twitter.

Episode #59: Getting State from a GenServer
In this episode we’ll explore how we can separate the client API of a GenServer from its server callbacks. This can be a good idea to help break GenServer modules up as they become more complex.

Episode #57: Using Plug to Secure Routes
Now that we’ve created our ‘Order History’ pages, we need to make sure only the respective customers are able to view their order history. We’ll use Plug to help us do this.

Episode #56: Completing Order History and Receipt Pages
In this episode we’ll build on the foundation we setup in part 1. We’ll populate our ‘order history’ and ‘receipt’ pages with actual data and make them accessible to our customers.

Episode #55: Defining Routes and Structuring Data
In this episode we get started building an order history page. We’ll look at how our application is structured, how we can fetch data from an API to build our receipts, and how to structure that data.

Episode #53: Parsing HTML with Floki
In this episode we’ll learn how to parse HTML with the Floki package. Floki makes it easy to search for specific nodes in HTML using CSS selectors.

Episode #51: Feature Flags
In this episode we’ll learn how we can use feature flags to toggle different features of an application to different users. To do this we’ll be using the FunWithFlags package in an existing Elixir application.

Episode #49: Concurrency with Task.async_stream
In this episode we’ll update an existing Elixir application to make it use a Stream throughout. Then we’ll see how we can use Task.async_stream to make concurrent API calls.

Episode #48: CSV with Elixir
In this episode we’ll learn the basics of working with CSV files in Elixir. We’ll parse and existing CSV to get specific data from it. We’ll also learn how to build a new CSV file.

Episode #45: Access an FTP
In this episode we’ll create a new Mix project to interact with an FTP server. We’ll learn how to connect to the server, change directories, download and upload files.

Episode #43: Supervisors in Elixir 1.5
Ready to dig into Supervisors? In this episode we’ll get introduced to them by updating an existing supervisor and its corresponding worker to use the Elixir 1.5 syntax.

Episode #41: File Uploads with Arc
If you’ve needed to upload and transform images in your Phoenix application this episode’s for you. We’ll use Arc to create multiple versions of our files and upload them to Amazon S3.

Episode #39: Accepting Payments with Stripe
In this episode we’ll learn how to accept payments using Stripe. We’ll integrate Stripe Checkout into an existing Phoenix application in order to easily accept payment and shipping information.

Episode #37: Charts with Chart.js Part 2
In this episode we’ll take what we did in Charts with Chart.js Part 1 and build on it. Let’s take advantage of Phoenix and use Channels to make our chart update in realtime.

Episode #36: Charts with Chart.js Part 1
In Part 1 of this series we’ll set the foundation by building a simple chart using the chart.js library. Our chart will display a static count of our movie genres.

Episode #30: Moving to Elixir Part 6
In part 6 we experiment with OTP to see how we can make our inventory import more resilient. Then we’ll use the power of concurrency in Elixir to speed up our inventory import.

Episode #29: Moving to Elixir Part 5
Now that our interface is working, we turn our attention to making sure our inventory it displays is current. We’ll create a custom Mix Task that we can run to import and update our inventory.

Episode #28: Moving to Elixir Part 4
In part 4 we work on some improvements to our interface. We’ll add pagination, use Ecto to ensure we’re only displaying the cars we want to. Then we’ll see how helper functions can be used in our templated.

Episode #27: Moving to Elixir Part 3
In part 3 we tackle URLs. We create a new URL structure to go along with our new app. Then we use Plug to create a custom redirect module to handle traffic to the old URL structure.

Episode #26: Moving to Elixir Part 2
In part 2 of our series we take our existing data and determine how to structure it inside our Elixir application.

Episode #25: Moving to Elixir Part 1
In the first episode of the Moving to Elixir course we create our application with a MySQL database. Then we import our existing database and make sure our application starts.


New episode alert.


New episode alert - using Waffle to handle file uploads and transformations.

1 Like

New episode alert - sometimes all you need is Plug.


New episode alert - deploying Plug to Heroku.


In this episode we’ll update the example user notifications generated by Phx.Gen.Auth to trigger emails using Swoosh.


New episode alert.

1 Like

New episode alert.


New episode alert. This is one I’ve wanted to cover for a while. In it we look at how you can use Twilio with Phoenix LiveView to send text messages.

1 Like

In this episode we’ll learn how to encrypt Ecto fields with Cloak.


Cloak is so great I had to do another episode with it.

1 Like

An intro to Phoenix LiveView Uploads.

1 Like

Using ExMachina to create test data.


Is there a Github repo with the code used for #137? I logged in to my account but couldn’t find a link

1 Like

My mistake - I’ve added the link to the GitHub repo in the episode: GitHub - elixircastsio/137-ex-machina


Thanks! Works perfectly.


Creating PDFs with ChromicPDF.

1 Like

Couple new episodes to add to this:

1 Like

Part 2 of authentication with LiveView:

1 Like

Multiple Layouts with Phoenix LiveView:

1 Like