LetItCrash

Articles

Foundations

Reading Elixir as a JS developer
Foundations
Factoring: rewriting an expression into an equivalent form
Foundations
Higher-order functions: when functions take functions
Foundations
Substitution: replace a name with a value
Foundations
Function evaluation: what a mapping does to one input
Foundations
Equivalence: are two expressions the same for every value?
Foundations
Time and monotonicity: JavaScript vs. Elixir
Foundations
When dates break computers: Y2K, Y2K22, and the year 2038
Foundations
Real numbers, and the lies programming languages tell about them
Foundations
What the BEAM actually is, in 5 minutes
Foundations Concurrency & the BEAM
Function composition, pipelines, and currying: from JavaScript closures to the Elixir pipe
Foundations
Recursion: the pattern that calls itself
Foundations
The rules of functional programming
Foundations
Reading Erlang as a JS developer
Foundations
Composition: one function's output feeding the next
Foundations
The role of types in programming, and why this site teaches Elixir
Foundations
How to trace an expression, step by step
Foundations
Pattern matching: the = you've been reading wrong
Foundations
Functional JavaScript vs. functional Elixir: where it's slow, and where it isn't
Foundations
Currying in JavaScript vs. Elixir: same idea, opposite decisions
Foundations
Metaprogramming in Elixir: code that writes code
Foundations
Why you'll write JavaScript before Elixir here
Foundations Learning how to learn
Bits have no meaning: the stored-program bargain
Foundations
Reading Lua as a JS developer
Foundations

Learning how to learn

How a strong solver approaches an algorithm problem
Learning how to learn
What stays true: invariants and reduction
Learning how to learn
Reading the problem before solving it
Learning how to learn
Committing and looking back
Learning how to learn
Conjecture, kill it, pivot
Learning how to learn
How to read a proof exercise
Learning how to learn Proofs & logic
Parsons puzzles: why ordering code teaches more than typing it
Learning how to learn
Refactoring: the small-steps skill this site starts with
Learning how to learn
Why this site makes you review
Learning how to learn
Why you'll write JavaScript before Elixir here
Foundations Learning how to learn
Mathematical shorthand: the symbols that are just words
Learning how to learn

Algorithms & theory

Dynamic programming: recursion with a cache
Algorithms & theory
Hash tables: the O(1) that has fine print
Algorithms & theory
Rate limiting: the window that expires before it floods
Algorithms & theory
Backpressure: the queue that says no before it overflows
Algorithms & theory
Graphs: when the answer is a hop away
Algorithms & theory
a monad is a monoid in the category of endofunctors
Algorithms & theory
Binary tree traversals: pre, in, and post-order as views of recursive state
Algorithms & theory
Tables all the way down: learning algorithms without standard library magic
Algorithms & theory
When an approximate answer is worth an infinite speedup: Bloom filters, Count-Min sketches, and HyperLogLog
Algorithms & theory
What O(n) actually promises
Algorithms & theory
Stacks, queues, and associative arrays: the data shapes your algorithms run on
Algorithms & theory
Binary trees: where the log in O(log n) lives
Algorithms & theory
P vs NP: when a thousand cores won't help
Algorithms & theory
The halting problem: why code can only be run, never read
Algorithms & theory
What a comparison is worth: the log from first principles
Algorithms & theory
Amortized: the expensive step you almost never take
Algorithms & theory
The encoding: how complex structures hide in simple ones
Algorithms & theory
Two pointers: the pattern hiding in plain sight
Algorithms & theory
Counting the work: from recurrences to big O
Algorithms & theory
Compilers for the practicing programmer
Algorithms & theory
Binary search: halving the search space in O(log n)
Algorithms & theory
Backtracking: recursion that can undo a choice
Algorithms & theory
Strings: the array of characters hiding a stack of agreements
Algorithms & theory
Earliest deadline first: the algorithm behind your review schedule
Algorithms & theory
Heaps: the structure behind every scheduler
Algorithms & theory
Sorting: the wall at n log n
Algorithms & theory
Dijkstra's algorithm: when every hop costs something
Algorithms & theory
Greedy: when the local choice is the global one
Algorithms & theory
Parsing: turning text into trees
Algorithms & theory
An interpreter is just an evaluator
Algorithms & theory
Algorithms past the interview: what the handshake is actually measuring
Algorithms & theory

Concurrency & the BEAM

Publish-subscribe: the pattern that decouples everything
Concurrency & the BEAM
The BEAM is the broker: pub/sub without a broker
Concurrency & the BEAM
Consistency models: what "strong" vs "eventual" actually buys you
Concurrency & the BEAM
What the BEAM actually is, in 5 minutes
Foundations Concurrency & the BEAM
Let it crash: the error philosophy behind this site's name
Concurrency & the BEAM
The dining developers: five computer scientists, five forks, and a deadlock
Concurrency & the BEAM
Orchestration: what Elixir is for, and when to reach for another language
Concurrency & the BEAM
What concurrency is: one thread vs. a million processes
Concurrency & the BEAM
Why Lua on the BEAM: sandboxed user code, Robert Virding's Luerl, and the abstraction trade-off
Concurrency & the BEAM
Embedding Luerl in Elixir: sandboxing untrusted scripts without crashing your node
Concurrency & the BEAM

Proofs & logic

How to read a proof exercise
Learning how to learn Proofs & logic
What is a proof?
Proofs & logic
Truth tables: the logic your code already runs on
Proofs & logic
The named logic laws
Proofs & logic
Algebra you forgot, and why it's the on-ramp to lambda calculus
Proofs & logic
Lambda calculus: a formal system in three rules
Proofs & logic
Induction: the proof pattern recursion already uses
Proofs & logic
The laws hidden in your code: what associativity buys you
Proofs & logic
Why lambda calculus is on this site
Proofs & logic