Home / Elixir
Elixir
Elixir beyond the basics: processes in depth, GenServer and supervisors, ETS tables, fault-tolerance patterns, macros and protocols, ExUnit depth, and four supervised projects. Every example is verified with the real interpreter.
Beginner Elixir teaches processes that send messages and keep count. Intermediate Elixir teaches the machinery that keeps those processes alive at scale: supervisors that restart crashed workers, shared tables that answer thousands of reads, and macros that write code before the program runs.
Course contents
Work top to bottom — the sidebar is the course. Topics later in the list assume the ones before them.
Elixir Intermediate Introduction
Intermediate · ⏱ 3 min · standalone lesson
Processes in Depth
- Elixir Process Mailboxes
- Elixir Selective Receive
- Elixir Process Links
- Elixir Process Monitors
- Elixir Exit Signals
- Elixir Trapping Exits
OTP Behaviours
- Elixir GenServer Callbacks
- Elixir GenServer State
- Elixir Supervisor: One for One
- Elixir Supervisor: Rest for One
- Elixir Supervisor: One for All
- Elixir Supervision Trees
- Elixir Dynamic Supervisors
- Elixir Applications and Children
ETS
- Elixir ETS Tables
- Elixir ETS Table Types
- Elixir ETS Concurrency
- Elixir ETS Match Specs
- Elixir ETS Patterns
Fault Tolerance
- Elixir Let It Crash
- Elixir Restart Intensity
- Elixir Backoff Strategies
- Elixir Circuit Breakers
- Elixir Graceful Shutdown
Metaprogramming
- Elixir Quote and Unquote
- Elixir Macros
- Elixir Macro Hygiene
- Elixir Macros with Using
- Elixir Compile-Time Code Generation
- Elixir DSLs with Macros
Protocols
- Elixir Protocol Definitions
- Elixir Protocol Implementations
- Elixir Protocol Fallback
- Elixir The Enumerable Protocol
- Elixir Protocol Patterns
Testing
- Elixir Async Tests
- Elixir Doctests
- Elixir Setup and Fixtures
- Elixir Test Doubles
- Elixir Testing GenServers
- Elixir Test Organization
Projects
- Elixir Project: Chat Server
- Elixir Project: Job Queue
- Elixir Project: Event Bus
- Elixir Project: Key-Value Store
Go deeper with Elixir
Elixir earned its place in chat systems, payment pipelines and telecom switches because a failing part does not take the whole system down. This course explains how that promise is built: a worker crashes, its supervisor notices, and a fresh worker takes over while its neighbours keep working. You will see each step happen in small scripts you can run.
Forty-six lessons move from single processes to full supervision trees. Early groups cover mailboxes, links, monitors and exit trapping, the four tools that decide what happens when a process dies. Then come GenServer callbacks, the three supervisor strategies, dynamic supervisors and applications, the pieces every production Elixir system is assembled from.
Later groups add the working tools of the trade. ETS tables hold shared state without a process bottleneck. Fault-tolerance patterns turn crashes into planned restarts with backoff and circuit breakers. Metaprogramming chapters show quote, macros and compile-time code generation, and the protocols chapters go past the beginner introduction into fallbacks and the Enumerable protocol itself. The course closes with ExUnit depth and four supervised projects.
What you will learn
The course covers the intermediate Elixir toolkit in this order:
- Process mailboxes, selective receive, links, monitors, exit signals and trapping exits
- GenServer callbacks and state, supervisor strategies, supervision trees and applications
- ETS tables, table types, concurrency options, match specs and table patterns
- Let-it-crash design, restart intensity, backoff, circuit breakers and graceful shutdown
- Quote and unquote, macros, hygiene, using, compile-time generation and small DSLs
- Protocol definitions, implementations, fallback, Enumerable and protocol patterns
- Async tests, doctests, fixtures, test doubles, GenServer testing and test layout
- Four projects: a chat server, a job queue, an event bus and a key-value store
Who this Elixir course is for
This course is for readers who finished the beginner Elixir course or already write Elixir with pattern matching, pipes, Enum and plain processes. It assumes that ground and does not repeat it. If GenServer, supervisors and ETS are new names to you, this is the course that turns them into working tools.
It suits developers moving toward backend work in Elixir, and anyone curious how fault-tolerant systems are actually put together. The projects at the end assemble everything into programs with supervisors, tables and message passing, the shape of a small production service.
How this course works
Every lesson is short: a plain-words definition first, then focused examples with real outputs, then one closing program that pulls the pieces together. Each example was run twice with the real Elixir interpreter and the stated output matches byte for byte, including the OTP behaviours and ETS tables.
The course takes about 169 minutes, from the opening lesson through the final project. Lessons build strictly in order: a concept appears only after the lesson that teaches it, so later chapters can rely on earlier ones without surprise. There is nothing to install to read along, and every snippet is a complete script you can run on your own machine.
Frequently asked questions
Do I need the beginner Elixir course before this one?
Yes, or equivalent experience. This course assumes pattern matching, the pipe operator, Enum, structs and plain processes, and it never re-teaches them. Readers new to Elixir should start with the beginner course first.
What is a GenServer?
A GenServer is a process with a standard shape: it holds state, answers synchronous calls, handles asynchronous casts, and reacts to messages. Supervisors start and restart GenServers, which is why they sit at the centre of fault-tolerant Elixir programs.
What is ETS?
ETS is Erlang term storage: in-memory tables shared between processes without a bottleneck process in the middle. This course covers table types, concurrency options, match specs for querying, and the patterns that keep tables fast and safe.
Do I need Elixir installed on my machine for this course?
Reading needs nothing installed, since every example shows its real output. To run the code yourself, install Elixir 1.19 with Erlang/OTP 27 and run each snippet as a script file.
How long does the Elixir intermediate course take?
About 169 minutes across 46 lessons, from process mailboxes through OTP behaviours, ETS, fault tolerance, metaprogramming and testing to four supervised projects.
Is the Elixir intermediate course free?
Yes. All 46 lessons, including the four projects, are free to read on A1Learner.