Thirty-one short lessons move through Scratch, Foundation, Intermediate, and Project. Run a complete example first, then unpack terms and 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 erl. 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.
Run expressions in the Erlang shell and remember the final dot.
Learn numbers, atoms, tuples, lists, and maps.
Understand charlists, binaries, and UTF-8 text.
Learn capitalized variables, single assignment, and pattern matching.
Use `[Head | Tail]`, then keep passing scores with a list comprehension.
Trim a binary, turn it into an integer, and catch invalid input.
Match one value against branches, then add conditions with guards.
Stop at an empty list and use a head-and-tail pattern for the next item.
Save functions in an `.erl` file, compile them, and look ahead to BEAM.
Build fluency with collections, functions, control flow, modules, and basic tests.
Use arithmetic, strict equality, term order, and short-circuit Boolean operators.
Use map patterns, `maps:get/2`, and immutable map updates.
Compare code points, bytes, Unicode conversion, and bit-syntax segments.
Write named functions with patterns and guards in a module.
Compare explicit recursion with `lists:foldl/3`.
Use `case`, `if`, and `try` for three different decisions.
Use module attributes, exports, records, and record patterns.
Create an Erlang application and run a focused EUnit test.
Work with files, error boundaries, type contracts, and project tools.
Use tagged tuples so callers can handle every expected result.
Build a path, write bytes, and match the result of reading them back.
Filter, transform, and fold a list with small named steps.
Use a record internally and return a public map to callers.
Declare a callback and implement it in a separate module.
Add named types and function specs, then use Dialyzer to inspect suspicious paths.
Use EUnit for focused functions and Common Test for multi-step scenarios.
Use Rebar3 profiles for environments and an escript entry point for a small CLI.
Move from a small requirement and tests to a runnable, packaged program.
Turn a log-cleaner idea into exact input, output, and error examples.
Trim a binary, split once, normalize its level, and return a tagged result.
Separate file access, parsing, and pure summary logic.
Align specs, EDoc comments, and tests with the acceptance examples.
Keep `main/1` thin, log safe context, and build an escript.
Run the acceptance matrix, then finish with a short release checklist.
