Elixir Complete Curriculum & Syllabus
Advance step-by-step through 10 structured progressive levels, taking learners from foundational core concepts to expert mastery. Explore the full syllabus below before enrolling.
Unlock All 10 Levels for Elixir
Get complete access to all modules, practical lessons, interactive quizzes, and advanced tracking tools designed to accelerate skill mastery.
Everything You Need to Succeed in Elixir
Our platform combines rigorous academic standards with engaging management tools built specifically to empower teachers, parents, and students alike.
Teacher/Parent Dashboard
Take complete control of education management. Assign seats, monitor overall group activity, and configure learning paths effortlessly from a centralized hub.
Student/Child Dashboard
An intuitive, distraction-free interface designed for learners. Easily navigate active lessons, pick up right where they left off, and view upcoming milestones.
Detailed Progress Reports
Never guess where a learner stands. Access granular analytics on quiz scores, module completion timelines, and skill proficiency gaps instantly.
Certificates of Completion
Celebrate academic milestones! Earn official, verifiable digital certificates with unique identification numbers upon mastering subject criteria.
Interactive Kanban Board
Organize daily study goals like a pro. Use our built-in drag-and-drop task workflow board to manage to-dos, assignments, and study schedules.
Star & Milestone Tracking
Keep motivation soaring high! Earn rewarding stars and precious gems for every correct answer and completed lesson to unlock achievements.
Comprehensive 10-Level Syllabus
Review the exact modules and learning milestones included inside every level of our Elixir program.
First Drops — Foundations, Basic Types & the IEx Playground
Begin your Elixir journey from absolute zero. You will meet the BEAM and the ideas behind functional programming, install the toolchain and make IEx your second home, then master every basic type — integers, floats, atoms, booleans, nil and UTF-8 strings — plus operators, strict vs loose equality, total term ordering, your first tuples, lists, keyword lists and maps, the immutability mindset, and your very first anonymous and named functions. Every lesson is pure theory with 10 fully-explained questions, and the level ends with an independent 50-question Full Practice Test.
Included Modules (6)
Meet Elixir, José Valim and the BEAM. Install the toolchain, make IEx your interactive hom...
The atoms and molecules of Elixir data: integers and floats, atoms, booleans and nil, plus...
The String module toolbox, charlists vs strings, strict vs loose equality, total term orde...
Your first containers: fixed-size tuples, linked lists, ordered keyword lists and the ever...
Anonymous functions, the capture operator, arity and calling conventions, your first defmo...
An independent 50-question graduation exam spanning every Level 1 module — mixed types, mi...
Pattern Forge — Pattern Matching & Data Structures in Depth
Pattern matching is the beating heart of Elixir — and Level 2 makes you fluent in it. Relearn the humble = as the match operator, destructure tuples, lists and maps (even nested ones), master the pin operator and underscore conventions, then dive deep into cons cells and improper lists, ++/--, the List module toolbox, charlists and code points, partial map matching, the Map and Keyword modules, your first defstruct structs, binaries and bitstrings with binary pattern matching, graphemes, the complete sigil set, the Tuple module and reading common errors. 25 theory lessons with 250 fully-explained questions, capped by an independent 50-question Full Practice Test.
Included Modules (6)
Relearn = as the match operator: rebinding vs matching, destructuring tuples, lists and ma...
Cons cells and [head | tail], improper lists, ++ and --, the List module toolbox and charl...
Partial map matching, updating and building maps, safe fetching with get/fetch/fetch!, the...
Binaries <<1, 2, 3>> and binary pattern matching, bitstrings vs binaries, UTF-8 graphemes...
Nested destructuring, the Tuple module, matching collections of maps, reading MatchError/K...
An independent 50-question graduation exam spanning every Level 2 module — mixed types, mi...
Function Alchemy — Modules, Recursion & Higher-Order Magic
Level 3 turns pattern matching into FUNCTION alchemy. Multiple function clauses and guards replace if-chains; default arguments and defp shape clean APIs; recursion — base cases, [head | tail] walks, tail calls with accumulators, nested data — replaces loops entirely. Then the magic deepens: functions as values, closures, functions returning functions, capturing named functions, partial application, module attributes, documentation and doctests, alias/import/require, use and behaviours, the atom nature of modules and dynamic dispatch with apply/3. You finish by hand-rolling map, filter and reduce, winning FizzBuzz with clauses, and reading function errors like a pro. 25 theory lessons with 250 fully-explained questions, capped by an independent 50-question Full Practice Test.
Included Modules (6)
Multiple function clauses, guard clauses with when, default arguments, defp and clause ord...
Base cases and recursive cases, [head | tail] list walks, tail calls with accumulators, re...
Functions as values, closures over their environment, functions returning functions, captu...
Compile-time attributes, @moduledoc/@doc and doctests, alias/import/require, use and behav...
Hand-rolling map, filter and reduce, FizzBuzz with clauses and guards, reading function er...
An independent 50-question graduation exam spanning every Level 3 module — mixed types, mi...
The Mix Workshop — Projects, Tooling, Docs & Testing
Level 4 opens the Mix Workshop: the toolchain that turns single files into real projects. Create projects with mix new and read every file it generates; master mix.exs (project/0, application/0, deps/0); run code with mix run, mix eval and iex -S mix; switch environments between :dev, :test and :prod; fetch dependencies from Hex with mix deps.get and pin them with mix.lock; decode the pessimistic version operator ~>; watch compilation produce .beam files under _build; wire up the Application behaviour with mod and start/2; enforce one style with mix format and .formatter.exs. Then ship knowledge: ExDoc and mix docs, typespecs with @type and @spec, @impl, @deprecated and @since. Finally test like a professional: ExUnit from your first assert through describe/setup context maps, tags and filtering, and doctests — plus the .ex/.exs split, mix aliases, custom mix tasks, config.exs vs runtime.exs, and project hygiene. 25 theory lessons with 250 fully-explained questions, capped by an independent 50-question Full Practice Test.
Included Modules (6)
Creating projects with mix new, the anatomy of mix.exs, running code with mix run, mix eva...
Fetching dependencies from Hex with mix deps.get, the pessimistic version operator ~>, com...
ExDoc and mix docs, typespecs with @type, function contracts with @spec, marking callback...
ExUnit end to end: your first test with mix test, assertions (assert, refute, assert_raise...
The .ex vs .exs split, mix aliases for your own shortcuts, custom mix tasks, config.exs vs...
An independent 50-question graduation exam spanning every Level 4 module — mixed types, mi...
Flow & Collections Mastery — Control Flow, Enum & Streams
Level 5 turns you into a flow master. First the branching toolbox: truthiness (only nil and false are falsy), if and unless, the cond cascade, case with patterns, pins and guards, the with happy-path pipeline and its else clauses, and error-aware flow with try, rescue, catch, throw and after. Then the collection engine room: Enum.map, filter and the universal reducer; iteration helpers like each, with_index and zip; sort and sort_by; slicing with take, drop, split and chunk_every; predicates find, any? and all?; count, member?, uniq and dedup; group_by and aggregation with sum, min and max; shape-shifters flat_map, concat and scan; and safe access with reduce_while, fetch and fetch!. Next, streams: laziness explained, streams vs enum trade-offs, infinite streams with iterate, cycle, unfold and resource, File.stream! and IO pipelines, plus the classic pitfalls. Finally comprehensions: for with generators, filters and patterns, into: to build maps and binaries, reduce: for accumulators, and a four-tool case study that ties everything together. 25 theory lessons with 250 fully-explained questions, capped by an independent 50-question Full Practice Test.
Included Modules (6)
The branching toolbox: truthiness, if and unless, the cond cascade, case with pins and gua...
The collection workhorses: map and filter, the universal reducer, iteration and pairing he...
Searching and measuring collections: find, find_index and find_value, any? and all?, count...
Laziness unlocked: what streams really are, streams vs eager Enum, infinite generators lik...
Declarative flow: for with generators, filters and pattern-skipping, into: collectors via...
An independent 50-question graduation exam spanning every Level 5 module — mixed types, mi...
Process Awakening — Concurrency, Messages & Links
Level 6 awakens the true superpower of the BEAM: processes. You start with the process model itself — tiny isolated heaps, per-process garbage collection, preemptive scheduling and message-passing-only communication — then create your first processes with spawn, meet self() and learn to read PIDs. You will send messages with send, watch them pile up in mailboxes, and pull them out with pattern-matched receive clauses, adding timeouts with the after clause and delayed delivery with Process.send_after. Next you design real conversations: ask-reply protocols tagged with make_ref, state held in tail-recursive loops, selective receive, registered names with Process.register and Process.whereis, and introspection with Process.info and Process.list. Then the safety net: links and exit signals, exit reasons like :normal and :kill, trapping exits, cascading failures and the let-it-crash philosophy. Monitors come next — Process.monitor, :DOWN messages, demonitor and spawn_monitor — plus racing and collecting from many processes, monitoring clients, and hand-rolling a resilient restarting worker. Finally you put concurrency to work: a parallel map, the one-process-owner state pattern, mailbox growth and overload, message-ordering guarantees and race conditions, and a capstone registered cache server that ties every skill together. 25 theory lessons with 250 fully-explained questions, capped by an independent 50-question Full Practice Test.
Included Modules (6)
From the BEAM process model to your first conversations: the cost model and isolation of p...
Real conversations between processes: ask-reply protocols with make_ref tags, state held i...
The safety net: bidirectional links and spawn_link, exit signals and reasons from :normal...
Non-fatal vigilance: Process.monitor and :DOWN messages, demonitor hygiene, links versus m...
Concurrency at work: a hand-rolled parallel map, the one-process-owner state pattern witho...
An independent 50-question graduation exam spanning every Level 6 module — mixed types, mi...
OTP Citadel — GenServers, Supervisors & Fault Tolerance
Level 7 raises the OTP citadel on top of the raw process skills of Level 6. You start with the behaviour contract itself — what OTP is, why the generic server machinery is written once and shared, and how callback modules plug into it — then bring up your first GenServer with GenServer.start_link and init/1, learning that init runs inside the brand-new process and that its return value decides whether the server lives. A clean client API keeps callers away from raw message tuples before you master the two workhorse callbacks: handle_call/3 for synchronous request-reply conversations and handle_cast/2 for fire-and-forget messages. The lifecycle module completes the picture: handle_info/2 for plain and timer messages, timeouts and :hibernate, deferred replies with GenServer.reply/2, handle_continue/2 for post-init warmup without blocking, and terminate/2 with its sharp edges and cleanup guarantees. Then the watchtowers rise: what a supervisor is and its child specs, the :one_for_one, :one_for_all and :rest_for_one restart strategies, restart intensity with max_restarts and max_seconds, :permanent/:transient/:temporary children, shutdown values from :brutal_kill to :infinity, and DynamicSupervisor for children born at runtime. The full tree follows: the Application behaviour as the root of every supervision tree, Task for supervised one-shot work, Agent for lightweight state, how to choose the right abstraction, and debugging OTP with Process.whereis, :sys and Logger. Fault tolerance in practice closes the level: the anatomy of a supervised crash step by step, GenServer pitfalls like blocking callbacks and swallowed errors, testing servers with start_supervised!, and a two-lesson capstone that builds a supervised key-value store and drills full crash recovery. 25 theory lessons with 250 fully-explained questions, capped by an independent 50-question Full Practice Test.
Included Modules (6)
The contract that replaces hand-rolled servers: what OTP behaviours are, your first GenSer...
Completing the server: handle_info for plain and timer messages, idle timeouts and :hibern...
Declarative fault tolerance: what supervisors and child specs are, the three restart strat...
Wiring the citadel together: the Application behaviour as tree root, Task for supervised o...
The level assembled: the anatomy of a supervised crash step by step, the pitfalls that bit...
An independent 50-question graduation exam spanning every Level 7 module — mixed types, mi...
Distributed Realms — Registry, ETS, Nodes & Resilience
Level 8 breaks the single-node walls of the OTP citadel and opens the distributed realms. It starts with naming: why plain atoms can hold only one process per name, and how Registry gives you supervised, partitioned, unique or duplicate key→pid stores with attached values, :via GenServer names and local pub/sub. Then ETS: in-memory tables owned by processes, the four table types, access rights from :private to :public, concurrency tuning, the daily insert/lookup/take/delete API, atomic counters and match specifications with :ets.fun2ms. Next, nodes: names and EPMD, connecting and hidden nodes, cookies and their real security meaning, remote execution with Node.spawn and :rpc, and node monitoring with :nodedown. Module 4 goes cluster-scale: :global names and locks, distributed GenServers and the singleton problem, cluster formation with libcluster, network partitions and split-brain, and the Horde/Swarm/HashRing ecosystem. The level closes with resilience engineering: the error kernel across nodes, failure detection limits, retries with backoff, jitter and idempotency, observability with remsh and :observer, and a capstone that designs a fault-tolerant distributed cache. 25 theory lessons with 250 fully-explained questions, capped by an independent 50-question Full Practice Test.
Included Modules (6)
From one-process-per-atom to supervised key→pid stores: unique and duplicate registries, p...
The VM's in-memory powerhouse: table ownership and lifetime, the four table types, access...
From one VM to a cluster: node names and EPMD, connecting and hidden nodes, cookies and th...
Naming at cluster scale: :global names and locks, distributed GenServers and the singleton...
Engineering for failure: the error kernel at cluster scale, the limits of failure detectio...
An independent 50-question graduation exam spanning every Level 8 module — mixed types, mi...
The Macro Codex — Metaprogramming, Protocols & DSLs
Level 9 opens the macro codex — the art of writing code that writes code. It begins with the deepest truth of the language: Elixir code is data. You will learn quote and the abstract syntax tree of literals and 3-tuples, metadata and dot-call nodes, Macro.to_string and Code.eval_quoted, unquote, unquote_splicing and Macro.escape. Module 2 builds real macros: defmacro and compile-time expansion, macro hygiene and var!, the __CALLER__ environment and Macro.expand, and the judgment of when a macro truly beats a function. Module 3 dissects the module lifecycle: what defmodule really does, import, require and alias, module attributes with register_attribute and accumulate, the use/__using__ extension protocol, and @before_compile alongside custom behaviours and @impl. Module 4 covers protocols: why they exist, defprotocol and defimpl syntax, @fallback_to_any, @derive and the built-in protocols Inspect, String.Chars, List.Chars, Enumerable and Collectable, protocol consolidation, and a full custom-protocol capstone. Module 5 assembles everything into DSL engineering: reading ExUnit and Ecto as DSLs, the accumulate-attribute pattern, generating functions with @before_compile and unquote_splicing, fail-fast compile-time error design, and a complete validation DSL built from scratch. 25 theory lessons with 250 fully-explained questions, capped by an independent 50-question Full Practice Test.
Included Modules (6)
Open the macro codex: quote, the AST of literals and 3-tuples, metadata and dot-call nodes...
Build real macros: compile-time expansion, hygiene and var!, the __CALLER__ environment an...
Dissect how modules come to life: the compile-time body, import/require/alias, attributes...
Master data-driven polymorphism: defprotocol and defimpl syntax, @fallback_to_any, @derive...
Turn metaprogramming into language design: read ExUnit and Ecto as DSLs, master the accumu...
An independent 50-question graduation exam spanning every Level 9 module — mixed types, mi...
Master Alchemist — Phoenix, Ecto & Production Elixir
Level 10 is the final transmutation — turning an Elixir artisan into a master alchemist who ships real products. Module 1 lays the Ecto bedrock: schemas and their structs, changesets built from cast and the validation family, reversible migrations with references and indexes, the Repo with insert, update, delete and on_conflict, and queries written with from, where, select and order_by. Module 2 deepens the data craft: has_many, belongs_to and many_to_many associations, Ecto.Multi transaction pipelines, preloading strategies that defeat the N+1 problem, cast_assoc versus put_assoc and embedded schemas, and aggregates, subqueries and fragments. Module 3 enters Phoenix itself: the endpoint and the Plug specification, the router with pipelines, scopes and resources, controllers and action_fallback, Plug.Conn — halt, assigns and responses — and views, layouts and rendering. Module 4 lights up real-time Phoenix: LiveView mount and the socket, assigns and handle_params with temporary assigns, HEEx function components with attrs and slots, PubSub and Presence, and Channels with topics and handle_in. Module 5 opens the production grimoire: mix release and self-contained builds, compile-time versus runtime configuration, telemetry instrumentation, logging and error-handling discipline, and the operational craft of clustering, health checks and performance. 25 theory lessons with 250 fully-explained questions, capped by an independent 50-question Full Practice Test.
Included Modules (6)
Lay the database bedrock: schemas and their structs, changesets with cast and the validati...
Deepen the data craft: has_many, belongs_to and many_to_many associations, Ecto.Multi tran...
Enter Phoenix itself: the endpoint and the Plug specification, the router with pipelines,...
Light up real-time: LiveView mount and the per-client socket process, assigns and handle_p...
Open the production grimoire: mix release self-contained builds, compile-time versus runti...
An independent 50-question graduation exam spanning every Level 10 module — mixed types, m...
Frequently Asked Questions
Everything you need to know about enrolling and learning Elixir on WordThesauri.
How are the 10 progressive levels structured for Elixir? +
Every subject is broken down into 10 structured levels moving systematically from foundational basics to expert proficiency, featuring modular units and interactive practice lessons.
Can I track my child or student’s progress in real-time? +
Yes! The Teacher/Parent Dashboard provides detailed progress reports, star & milestone tracking, and completion analytics for every student.
Is the first lesson of Elixir really free? +
Yes. The first lesson is completely free to try. Every other lesson shows Upgrade to learn until you enroll in the full annual subscription.
How does the student seat pricing work for classrooms or families? +
You can purchase licenses per student seat on an annual subscription basis. Each student receives their own dedicated dashboard, rewards, and Kanban task board.
Are certificates awarded upon completing the course? +
Yes, students earn official Certificates of Completion as they conquer modules and milestones across the curriculum.
Why Choose WordThesauri for Elixir Mastery?
Welcome to WordThesauri premier online learning track for Elixir. Built specifically for independent learners, homeschoolers, and classroom educators, our curriculum breaks down complex topics into 10 structured, bite-sized progressive levels.
Structured for Permanent Skill Retention
Every level features carefully curated modules and practice lessons equipped with step-by-step worked solutions, real-time analytics, and milestone rewards. Whether you are starting from absolute fundamentals or advancing toward expert proficiency, our interactive platform guarantees steady academic growth.
Flexible Enrollment & Group Pricing
Parents and teachers can easily scale seats across multiple students using our annual subscription model, complete with dedicated child dashboards, printable certificates of completion, and automated progress reports. Try the first lesson for free today!