Reactive Programming

The signal grammar: a run carries any number of value signals and then at most one terminal signal, completion or failure, never both. A failure is that ending, not another value, so the source must go silent after it.

Subscribing starts the work; building a stream only describes it. A subscription call attaches a subscriber to the source, triggers whatever the source does to produce values, and hands back a handle the caller uses to cancel that run.

Nothing was found and nothing failed: empty completion is a third outcome beside a value and a failure. The caller must decide what absence means here - a default, a fallback source, or an error it raises itself.

The source is cold: it describes work instead of sharing a sequence that is already running, so every subscriber starts a fresh, independent run. Three panels subscribed, so the query executed three times.

Signals must be delivered one at a time, with each one seeing what the previous one wrote. Every stage downstream is written on that promise and keeps its accumulated state unsynchronised, so overlapping deliveries corrupt it.

Lockstep pairing consumes one value from each source per result, so its rate is the slowest source's rate. Latest-value combination keeps each source's most recent value and emits on every arrival, so its rate is the sum of all rates.

A mapping step returns exactly one output element per input; a predicate filter returns zero or one, dropping the rest; a running accumulator emits a value derived from every element seen so far, so it carries state between elements.

Building the chain runs ordinary code. The expressions handed to each step are evaluated as the chain is described, so a log line or a computed value written there fires once at assembly, not on each later run of the pipeline.

It depends on the joining rule. Lockstep pairing ends as soon as a completed source's queue is empty, discarding whatever is buffered elsewhere. Latest-value combination keeps going on the completed source's last value until all sources complete. A source that emits nothing leaves the output empty.

Sequential concatenation keeps one call in flight: results arrive in queue order, throughput is capped at one call per call-latency. Bounded merging runs several at once, trading that ordering for throughput and putting the bound's worth of load on the dependency.

An unbounded hold converts a sustained rate mismatch into memory exhaustion. Every line the writer cannot take is retained, so the pipeline behaves normally for as long as the spare memory lasts, then the process dies all at once.

Up to 15 values, and not one more. Requests accumulate additively into a single outstanding count, each delivered value spends one unit, and the producer is barred from sending a sixteenth value until the consumer asks again.

Classify the item first. A position is a snapshot that the next one supersedes, so discarding intermediates costs the consumer nothing. A settlement instruction has an effect of its own that no later item re-derives, so discarding it is a lost transfer.

Bounded buffering spends memory and adds latency and only postpones the decision; dropping the newest arrival sacrifices freshness; keeping only the latest sacrifices every superseded value; failing fast sacrifices availability but is the only one that reports the loss.

Flow control moves into the adapter wrapping the source. A clock cannot wait for demand, so the adapter decides each tick's fate: discard it, overwrite a stored latest value, or hold it in a bounded buffer.

A parked worker is unavailable to every subscription that shares it. Asynchronous pipelines multiplex many requests over a pool sized to the processor count, so a few simultaneous waits occupy every worker and unrelated routes queue behind them.

Ambient storage is attached to the worker, not to the request: a read resolves against whatever worker is executing right now. Once a stage runs on a different worker, nothing ever wrote that worker's slot.

A hop is not free: it enqueues the value, wakes another worker and adds latency for every element. For a short non-blocking stage, running inline on whichever worker delivered the value costs less than moving the work somewhere else.

Match the worker to where a stage spends its time. Compute-bound decoding belongs on a small fixed pool sized near the processor count; a stage that spends its wall-clock time waiting on remote storage belongs on an elastic pool that can grow.

A reactive sequence is serial by contract: values reach each stage one at a time, in order, however many workers the execution context owns. That choice decides which worker runs a stage, never how many elements run at once.

Retrying resubscribes to the source, so every stage above the retry point runs again from the start: the recipient is loaded a second time, a second attempt record is written, and the carrier is called again.

An observe-only hook changes nothing about the signal. It is a tap: it sees the failure, records it, and lets the same failure continue downstream, so the sequence still ends and every later stage still sees it.

Nothing runs in them. A failure signal travels past every stage that only handles values, so the formatting stages are skipped and the substituted value enters the sequence below them — it must therefore already be in the shape the subscriber expects.

A retry decision needs three inputs: the kind of failure, since some can never clear; a bound on attempts, as a count or a deadline; and some space between attempts. When the bound is reached, the failure must reach the subscriber.

Nothing processes them. A failure signal is terminal: it ends the sequence at row twelve and releases the subscription, so the source is never asked for rows thirteen onward and nothing downstream sees them.

Only for the message to be accepted for delivery, not for packing to run. Picking holds no thread and no result, and hears about the outcome only if a later message tells it.

Asynchronous data flow buys capacity, not speed: it stops workers being parked while waiting on input and output. A tool with a dozen users never runs out of workers, so there is no parked capacity to reclaim.

Addressing. A message is directed at a named recipient and expresses intent toward it; an event is a broadcast fact about what already happened, addressed to nobody, which zero or many observers may consume.

All four remain unclaimed, because the four properties are claims about the boundary between components and that boundary is still synchronous. Internal streams buy more concurrent conversations per worker, which is a capacity gain, not one of the properties.

A high percentile of one named request, measured over every outcome including timeouts and refusals, at a stated arrival rate, across the spike window. Responsiveness is a bounded tail under load, not a healthy average.