Thirty-one short lessons move through Scratch, Foundation, Intermediate, and Project. Run a complete example first, then unpack the syntax, change an input, and practice. Foundation is enough to enter the BEAM path; the rest builds a single-language project.
Enter the command in your terminal. Seeing the interactive prompt is enough. You do not need to create a project yet.
The language path makes sequential code solid first. Processes, supervision, and distribution belong to the BEAM mainline. Java, Python, and JavaScript comparisons appear only where an old mental model can mislead you.
Each lesson still begins with a concrete task and a complete example in IEx. Scratch builds confidence, Foundation builds independent modules, Intermediate handles real input, and Project combines the pieces.
Read inputs and results. Finish one 5–15 line task.
Open IEx, enter an expression, and tell code, results, and errors apart.
Run common values, then see why an Elixir string is a UTF-8 binary.
Use lists, tuples, and maps to hold groups of data.
Bind a list, transform it with `for`, and leave the original value unchanged.
Treat `=` as a match and unpack tuples, lists, and maps.
Match one value against branches, then add conditions with guards.
Trim text, turn it into an integer, and return a clear error for invalid input.
Write a full anonymous function before reading captures, Enum, and `|>`.
Write a module, meet def, files, and Mix, then head toward BEAM.
Build fluency with collections, functions, control flow, modules, and basic tests.
Compare values and separate truthy operators from strict Boolean operators.
Use keyword lists, maps, `get_in`, `put_in`, and `update_in` without changing the source value.
Compare graphemes, code points, bytes, and a simple Unicode-aware sigil.
Define named functions with defaults, patterns, and guards.
Compare explicit recursion with `Enum.reduce/3`.
Use `if`, `cond`, and `case` for different shapes of decisions.
Define a struct with module documentation, required keys, and a function that matches it.
Read a Mix project layout and run a focused ExUnit test.
Work with files, error boundaries, type contracts, and project tools.
Use tagged tuples, `with`, and a small error contract.
Build a path, write UTF-8 text, and handle the tagged read result.
Compare eager Enum work with a lazy Stream pipeline.
Define a protocol and implement it for two data types.
Define a generic behaviour and make a module satisfy it.
Describe public input and output shapes with `@type` and `@spec`.
Use setup data, doctests, focused assertions, and async-safe tests.
Add a custom Mix task and configure an escript entry point.
Move from a small requirement and tests to a runnable, packaged program.
Turn a vague log-cleaner idea into input, output, and error examples.
Trim input, split once, normalize the level, and return a tagged result.
Separate file access, parsing, and pure summary logic.
Add docs, specs, examples, and boundary tests to the project API.
Keep CLI parsing thin, log useful context, and build the escript.
Run the acceptance matrix, then finish with a short release checklist.
