You're a programmer, so you don't need spoon feeding with the conventional drivel about "this is an integer." No. You need to know what's different, and you want to know quickly.

But you want more. True mastery of Elixir comes from understanding the underlying idioms: functional programming, transformations, concurrency, and application structure. You need to know the tools, such as IEx and mix. And you need to understand the frameworks, such as OTP and Phoenix. This course will get you started down this road (and your experience will take you the rest of the way),

The course has videos to show you stuff, text to give you facts, quizzes to help you remember, and exercises to let you practice.

  • Over 9 hours of video, now with captions
  • 88 individual course units in 20 chapters
  • 44 exercises
  • Average 4.8/5 stars in over 280 reviews (previous edition)

More and more developers are switching to Elixir. Take this course and join them.


Team discounts available. 

Course curriculum

  • 1

    Welcome to Elixir for Programmers

    • Welcome

    • Finding Your Way Around
  • 2

    Getting Started

    • Installing Elixir

    • Introduction to IEx
  • 3

    Our First Project

    • What We're Going to Do

    • Create a New Project

    • Start Coding

    • Start Writing the Dictionary

    • Make it More Functional

    • Onward!
  • 4

    A Mad Dash Through Elixir Types

    • Introduction

    • Integers and Floats

    • Atoms

    • Booleans

    • Ranges

    • Strings (and Sigils)

    • Regular Expressions

    • Tuples

    • Lists

    • Maps
  • 5

    Pattern Matching

    • Introduction

    • The Basics

    • Ignoring Values With Underscores

    • Pinning the Values of Variables

    • Pattern Matching and Function Calls

    • Lists and Recursion
  • 6

    Let's Start Coding

    • The Plan

    • The API

    • Typespecs

    • Start Coding

      FREE PREVIEW

    • And Start Testing

    • Pattern Matching Game State

    • Check for Duplicate Moves

    • Score a Good Guess

    • And a Bad Guess
  • 7

    Write a Text-based Client

    • Mostly About Loops

    • Create the Text Client App

    • Finish Up the Text Client
  • 8

    Refactor The Dictionary

    • First, You Do It...

    • Then I'll Do It
  • 9

    Processes and Maintaining State

    • Why We're Looking At This Backwards

    • spawn: Create a New Process

    • Sending and Receiving Messages

    • Pattern Matching Messages

    • Linking Our Fate to Our Child's Fate

    • Agents: An Abstration Over State
  • 10

    Use an Agent for the Dictionary

    • Keeping the Wordlist in a Process

    • The Runtime vs Implementation Time Divide

    • Implement Dictionary Runtime
  • 11

    Applications: Making Our Code Independent

    • Applications Are Projects That Can Run Themselves

    • Run Dictionary as an Application
  • 12

    No Mr Dictionary, I Expect You to Die

  • 13

    The Story So Far...

    • Supervisors and Servers
  • 14

    Hangman: The OTP Server

    • Make Hangman a Server

    • Change to API to Use the Server

    • How Others Do It
  • 15

    Nodes and Distributed Elixir

  • 16

    From Server to Service: Make The Hangman Server Free-Standing

  • 17

    Distributed Text Clients

    • Update The Text Client to the New API

    • Don't Run Hangman Automatically

    • Creating Remote Servers
  • 18

    Installing Phoenix

    • Introduction

    • Installing Phoenix

    • Playing with Phoenix: Views and Templates
  • 19

    Hangman Using HTML Pages

    • Create an HTML Hangman App

    • Paths and Routes

    • Integrate the Game server with the Phoenix Front End

    • Start to Tidy Up

    • More Tidying

    • You're Never Done Until You Refactor...

    • Cleanup Unused Servers
  • 20

    Introduction to LiveView

    • LiveView: What's The Big Deal?

    • Example: Dynamically Display Memory Use
  • 21

    Hangman Using LiveView

    • Starting on LiveView Hangman

    • Writing the WordSoFar Component

    • Writing the Alphabet Component

    • Finish the Hangman Game
  • 22

    It's a Wrap

    • Congratulations!

Changes from the previous edition

  • All new video. Updated text content
  • Video now 1080p, with captions and selectable playback speed.
  • Updated to Elixir 1.12 and Phoenix 1.6.
  • Two new chapters covering LiveView
  • API modules now use typespecs
  • New code organization in servers separates runtime concerns from implementation.

Instructor(s)

Dave Thomas

Dave Thomas is probably responsible for introducing Ruby to the western world with the book Programming Ruby back in 2000. More recently, he played a similar role in launching Elixir, both with the book Programming Elixir and with many talks at conferences around the world. Dave Thomas is an author of the Manifesto for Agile Software Development. Who better to introduce developers to the exciting world of functional programming in Elixir?