Practice algorithms and functional thinking until they actually stick
Deliberate practice for programmers who want functional thinking, Elixir, and the BEAM to stop slipping through their fingers — graded exercises, escalating hints, and spaced repetition. The early steps use JavaScript, so no Elixir experience is required. Bring your own docs and videos; practice here.
Full access, no card. In exchange: tell us honestly when something breaks or confuses you.
This is probably for you if
- You've finished a tutorial or bootcamp and still freeze on a blank editor.
- You want to think in functional style, not just translate syntax from JavaScript.
- You'd rather struggle with one hard problem than watch someone else solve an easy one.
- You're fine with rough edges if it means your feedback shapes what gets built next.
The feedback loop
Wrong answers teach. Passes schedule your return.
A wrong answer starts a conversation
def sum([]), do: 0
def sum([head | tail]), do: sum(tail)Mockratis — You dropped the head. Walk it by hand: what does sum([1, 2]) return with your second clause?
Every attempt is compiled and run against real test cases. Get it wrong and a Socratic tutor points at where your reasoning diverged — escalating each time, but never revealing the answer.
A pass is a promise to return
Solving something schedules a return visit — sooner if it was a struggle, later once it sticks. Your dashboard always shows what's due today, so retention is built into the practice, not bolted on.
The path
From imperative habits to functional fluency
One deliberate path, each stage building on the last. No Elixir knowledge needed at the start — you begin in JavaScript and cross over when you're ready.
Foundations
Refactor imperative JavaScript into the functional style and trace recursive calls by hand — the two skills everything else stands on.
Recall drills
Substitutions, functions, and boolean logic in small, graded doses — the mechanical fluency that makes real problems approachable.
Algorithms
LeetCode-style problems with real test cases, in Elixir, Erlang, TypeScript, or Lua — graded by execution, with a tutor that hints instead of solving.
The summit
Proofs, induction, and lambda calculus — where functional thinking stops being a technique and becomes the way you reason.
Language introductions
Guided first steps in Elixir and Lua once you're thinking functionally — placed in the path exactly when you need them.
Long-form articles
Human-written deep dives that connect the exercises into a bigger picture — read between practice sessions.
Why it works
Practice built for retention, not streak-chasing
Graded by execution
Your code actually compiles and runs against the test cases — in four languages, with a strict time budget. Correctness is proven, never asserted.
Hints that never reveal
A cantankerous old tutor meets you where your reasoning broke and asks the one question that gets you unstuck — so next month you can re-derive it, not just recall it.
Spaced repetition, everywhere
Every exercise, drill, and memory card feeds one SM-2 scheduler. Struggle shortens the interval; mastery stretches it. You never guess what to practice next.
Help shape how this gets built
What you get
- Full access to every exercise, drill, and article — free during alpha.
- A direct line to the developer — your feedback goes straight into the roadmap.
What we ask
- Honest feedback — especially when something confuses or frustrates you.
- Patience with rough edges — this is an alpha, and things will break.
No card, no trial timer — an account is all it takes.