Bounded Mechanism Families And Canonical Realizations #

Use this to keep mechanism study bounded.

The rule:

keep the number of top-level mechanism families small
treat longer phrases as composed realizations, not new primitives

So:

claim + lease + fencing is a realization of ownership control
watch + local snapshot is a realization of state propagation
manifest + blob publish is a realization of immutable publication
batched matching is a realization of selection / assignment

How To Use This #

For any concrete mechanism phrase:

identify the family
name the realization
say what invariant it is protecting
map it to a real system or paper

Template:

family:
realization:
protects:
canonical systems/specs:

Core Families #

Family	What It Does	Canonical Realizations	Representative Systems / Specs
`Guarded Write`	protects a truth update from duplicate, stale, or conflicting mutation	CAS, conditional insert, unique constraint, multi-row transaction	Postgres `INSERT/UPDATE ... WHERE version`, DynamoDB conditional write / `TransactWriteItems`, Spanner transactions
`Ownership Control`	gives one actor temporary authority to act and rejects stale actors	claim, lease, fencing token, heartbeat, reaper	Chubby, ZooKeeper, etcd leases
`Append + Replay`	records immutable progress/events and lets consumers resume from position	append log, offset, cursor, checkpoint, replay	Kafka, WAL/CDC logs, Pulsar
`Projection + Catch-Up`	builds read models asynchronously from source truth and repairs lag/drift	CDC projector, materialized view updater, reindex, tombstone propagation	Debezium, Kafka Streams, Flink, Elasticsearch indexing pipelines
`State Propagation`	moves authoritative state from a source of truth to many consumers	poll, watch, push, push-version/pull-snapshot, local snapshot apply	xDS, Kubernetes watch/resourceVersion, etcd watch
`Immutable Publication`	publishes immutable content safely through versioned metadata or references	blob/chunk upload, manifest/version record, head/ref publish, reachability GC	Git, OCI Distribution Spec, package registries
`Time Gating`	makes work or state eligible only after a time boundary	due-time index, delay queue, timing wheel, expiry scan	Quartz, timing wheel systems, delayed job queues
`Frontier Progression`	advances through a large workset while tracking what is covered and resumable	progress cursor, range claim, checkpoint, resumable scan	crawlers, backfill scanners, ETL/frontier systems
`Selection / Assignment`	chooses winners, candidates, or assignments from a larger set	candidate retrieval, scoring, nearest-match, batched matching, top-k	Uber matching, marketplace dispatch, Redis ZSET, ANN retrieval
`Delivery + Acknowledgment`	delivers work or notifications with retry, replay, and uncertainty handling	outbox, ack/retry, replay window, inbox dedup, recent-message buffer	webhook delivery systems, message brokers, WebSocket replay windows
`Aggregation / Approximation`	maintains summaries instead of scanning raw truth every time	counters, windows, sketches, heavy hitters, approximate distinct	streaming top-k systems, Count-Min Sketch, HyperLogLog, Flink windows
`Placement / Scheduling`	decides where work should run and how capacity is consumed	queue dispatch, scoring/bin-pack, fair scheduling, work stealing, warm pools	Borg, Kubernetes scheduler, Mesos, execution fleets

Canonical Phrase Mapping #

Use this table to keep concrete anchor phrases bounded.

Concrete Phrase	Family	Why It Is Not A New Primitive
`claim + lease + fencing`	`Ownership Control`	it is one safe ownership realization, not a new top-level family
`watch + local snapshot`	`State Propagation`	it is one propagation realization into a local applied view
`manifest + blob publish`	`Immutable Publication`	it is one publish discipline for immutable content plus reference advance
`delta sync + conflict materialization`	`State Propagation` or `Immutable Publication`	it is synchronization plus divergence handling, not a new base family
`batched matching`	`Selection / Assignment`	it is assignment with a batch optimization window
`outbox + idempotent receiver`	`Delivery + Acknowledgment`	it is a delivery/uncertainty realization
`timing wheel + claim worker`	`Time Gating` + `Ownership Control`	it is a composition of time eligibility and exclusive claim
`log + offset commit`	`Append + Replay`	it is the standard resume discipline for append logs
`CDC + projector + rebuild`	`Projection + Catch-Up`	it is one projection maintenance realization
`top-k heap + window`	`Aggregation / Approximation`	it is one aggregation realization under a windowing policy

Best Representative Studies #

If you want a bounded serious study plan, one representative per family is enough at first.

Family	First Thing To Study
`Guarded Write`	Postgres transactions and conditional updates
`Ownership Control`	Chubby or etcd leases
`Append + Replay`	Kafka protocol and consumer offsets
`Projection + Catch-Up`	Debezium or Elasticsearch indexing pipeline
`State Propagation`	xDS and Kubernetes watch/resourceVersion
`Immutable Publication`	Git and OCI Distribution Spec
`Time Gating`	timing wheel paper and one delayed-job system
`Frontier Progression`	crawler/backfill checkpoint-and-claim system
`Selection / Assignment`	Uber marketplace matching
`Delivery + Acknowledgment`	outbox pattern and webhook retry model
`Aggregation / Approximation`	Redis ZSET plus one sketch family
`Placement / Scheduling`	Kubernetes scheduler or Borg

Practical Rule #

When you hear a new concrete mechanism phrase, do not add a new top-level category first.

Ask:

Which family does this belong to?
Is it one realization or a composition of two families?
What invariant is it protecting?

Only add a new family if it repeatedly explains many systems that do not fit the existing ones.

That should be rare.

Interview Shortcut #

Good answer shape:

The concrete mechanic here is watch + local snapshot, but I’d classify that under state propagation: the control plane owns truth, clients watch for version changes, then apply a local snapshot with monotonic version checks.

That keeps the language concrete without letting the taxonomy explode.