Learn: Functional & Parallel Thinking

A self-paced path of tiny puzzles — 5 to 10 minutes each — on the ideas behind functional and massively parallel programming: pure functions, recursion, higher-order functions, closures, algebraic data types, pattern matching, folds, continuations, and the map/reduce/scan thinking that lets a runtime spread your work across many cores without you ever writing a lock.

Each lesson stands on its own and re-explains the terms it uses, so you can drop in anywhere. When a lesson builds on an earlier one, it links back. Solve the puzzle, then read the solution page for the full explanation. Your spot is remembered so you can pick up on any device.

Loading your spot…

All lessons

  1. 001 Spot the Pure Function — Pure functions
  2. 002 The List That Wouldn't Change — Immutability
  3. 003 Sum a List Without a Loop — Recursion over lists
  4. 004 Find the Last Element — Recursion: base-case design
  5. 005 Count the List — Recursion: counting & accumulators
  6. 006 Reverse a List — Twice — Recursion: efficiency & accumulators
  7. 007 The Substitution Game — Referential transparency
  8. 008 Push the Effects to the Edge — Side effects at the boundary
  9. 009 Find It, Then Transform It — Recursion: membership & transform
  10. 010 Keep, Drop, and Slice — Recursion: filter, take, drop
  11. 011 Flatten the Nesting — Recursion: nested structures
  12. 012 Tail Calls and the Accumulator Pattern — Tail recursion
  13. 013 Functions Are Values — Functions as values
  14. 014 Build Map and Filter — Building map and filter
  15. 015 Build the Fold — Fold / reduce
  16. 016 Closures Capture Variables, Not Values — Closures
  17. 017 Curry, Partial, Compose — Currying & composition
  18. 018 Reduce Reconstructs Everything — Reduce as universal