Knowledge/Domain
Algorithms, data structures, and what they cost.
Drag to pan · hold ⌘/ctrl and scroll — or pinch — to zoom.
A coarse language for how an algorithm's cost grows as its input grows.
Computation & Algorithms·19 connections
A key-value structure that uses a digest of the key to index an array of buckets.
Computation & Algorithms·17 connections
Recording the intent of a change durably before applying it, so a crash can be recovered.
Finding a value in a sorted range by repeatedly discarding half of it.
Computation & Algorithms·10 connections
A fixed-capacity cache that evicts whichever entry has gone untouched the longest.
A wrapper type with a way to lift a value in and a way to chain functions that return more wrappers.
Computation & Algorithms·9 connections
A function whose output depends only on its input and which causes no observable effect outside itself.
A function bundled with the variables from its enclosing scope at the point it was created.
Computation & Algorithms·7 connections
A hashing scheme where adding or removing a node remaps only a small fraction of keys, not nearly all of them.
A model with a fixed set of states, one active at a time, and defined transitions between them on each input.
A value that cannot change after construction, so sharing it never risks a caller seeing another caller's edit.
A program that executes source code directly, statement by statement, without a separate translation step first.
A function defined in terms of itself, solving a problem by solving smaller instances of the same problem.
A concurrency model where isolated actors communicate only by asynchronous message, never by shared memory.
Computation & Algorithms·6 connections
A self-balancing tree with many children per node, designed to minimize the number of disk reads a lookup costs.
A program that translates source code into another form, ahead of running it, checking it along the way.
A single-threaded runtime's mechanism for pulling the next callback off a queue once the call stack is empty.
A runtime automatically reclaiming memory occupied by objects nothing can reach anymore.
Deferring a computation until its result is actually needed, and then caching it so it never runs twice.
Caching a function's result against its input so a repeat call with the same input skips recomputation.
Testing a value against a shape and binding its parts to names in one step, instead of inspecting it field by field.
A tree that stores strings by shared prefix, so each node represents a prefix all its descendants extend.
A compiler deriving a value's type from how it's used, so a programmer doesn't have to write it down.
Averaging cost over a sequence of operations so occasional expensive ones don't distort the per-operation bound.
Computation & Algorithms·5 connections
A probabilistic set membership structure that can say "definitely not present" but only "probably present."
Concurrency is structuring independent tasks together; parallelism is actually running them at the same instant.
Reusing a function's stack frame for a call in tail position so recursion runs in constant stack space.
Transforming a function of several arguments into a chain of one-argument functions, each returning the next.
Computation & Algorithms·4 connections
Treating an object as suitable for a role based on what it can do, not what type it's declared to be.
Solving a problem by solving each distinct overlapping subproblem exactly once and reusing the results.
A function that takes another function as an argument, returns one, or both.
A program inspecting or modifying its own structure — types, methods, fields — while it runs.
A pattern language for matching text, compiled internally into a finite state machine that runs over the input.