# Streaming / Pipeline / Dataflow Processing

> Every principle in this category is listed as a record.

Page: Ontology · Principles
Canonical: https://banes-lab.com/ontology#arch-category-streaming-pipeline-dataflow-processing

Every principle in this category is listed as a record. Each record carries its kind, its severity, the scopes it applies at and the layer it lives in, then the edge relations that join it to other records, the records that point back at it, the contracts that answer to it and the tensions it takes part in. The descriptors say how it is violated, detected, measured, repaired and enforced. Where the record carries one, an exemplar shows the shape before and after the principle is applied.

Relations diagram

The relations inside this category.

```mermaid
flowchart LR
n_streaming_architecture["Streaming Architecture"]
n_single_pass_processing["Single-Pass Processing"]
n_pipeline_architecture["Pipeline Architecture"]
n_lazy_evaluation["Lazy Evaluation"]
n_sequential_access["Sequential Access"]
n_forward_only_processing["Forward-Only Processing"]
n_dataflow_architecture["Dataflow Architecture"]
n_stateless_processing["Stateless Processing"]
n_windowing["Windowing"]
n_fan_out_fan_in["Fan-out/Fan-in"]
n_batch_vs_stream["Batch-vs-Stream"]
n_streaming_architecture --> n_single_pass_processing
n_forward_only_processing --> n_single_pass_processing
n_dataflow_architecture --> n_pipeline_architecture
n_windowing --> n_streaming_architecture
```

### Streaming Architecture

- Kind: [style](https://banes-lab.com/records/kind/style.md)
- Severity: contextual
- Scope: data processing, integration
- Layer: [Execution Core](https://banes-lab.com/records/layer/execution-core.md)

Details

Requires
[Event Stream](https://banes-lab.com/records/arch/event-stream.md), [Backpressure](https://banes-lab.com/records/arch/backpressure.md)

Reinforces
[Single-Pass Processing](https://banes-lab.com/records/arch/single-pass-processing.md)

Enables
[Continuous Processing](https://banes-lab.com/records/lex/continuous-processing.md)

In tension with
[Ordering/State](https://banes-lab.com/records/lex/ordering-state.md), [Batch-Only Processing](https://banes-lab.com/records/lex/batch-only-processing.md)

Conflicts with
none

Referenced by
[Event Stream](https://banes-lab.com/records/arch/event-stream.md), [Windowing](https://banes-lab.com/records/arch/windowing.md)

Tensions
[Streaming Architecture Ordering/State](https://banes-lab.com/records/tension/ordering-state-streaming-architecture.md), [Streaming Architecture Batch-Only Processing](https://banes-lab.com/records/tension/batch-only-processing-streaming-architecture.md)

Violated by
materializing unbounded streams

Detected by
unbounded collection over stream source

Measured by
lag, [throughput](https://banes-lab.com/records/arch/throughput.md), memory usage

Refactored by
Use Stream Processor, Add Backpressure

Enforced by
load/memory tests

Before

```typescript
const foos = await source.readAll();
const results = foos.map(transformFoo);
await sink.writeAll(results);
```

After

```typescript
for await (const foo of source.stream()) {
await sink.write(transformFoo(foo));
}
```

### Single-Pass Processing

- Kind: [principle](https://banes-lab.com/records/kind/principle.md)
- Severity: contextual
- Scope: algorithm, stream, parser
- Layer: [Execution Core](https://banes-lab.com/records/layer/execution-core.md)

Details

Requires
[Forward-Only State Model](https://banes-lab.com/records/lex/forward-only-state-model.md)

Reinforces
[Memory Efficiency](https://banes-lab.com/records/arch/memory-efficiency.md)

Enables
[Large Input Handling](https://banes-lab.com/records/lex/large-input-handling.md)

In tension with
[Global Optimization](https://banes-lab.com/records/lex/global-optimization.md), [Multi-Pass Full Materialization](https://banes-lab.com/records/lex/multi-pass-full-materialization.md)

Conflicts with
none

Referenced by
[Streaming Architecture](https://banes-lab.com/records/arch/streaming-architecture.md), [Forward-Only Processing](https://banes-lab.com/records/arch/forward-only-processing.md)

Tensions
[Single-Pass Processing Global Optimization](https://banes-lab.com/records/tension/global-optimization-single-pass-processing.md), [Single-Pass Processing Multi-Pass Full Materialization](https://banes-lab.com/records/tension/multi-pass-full-materialization-single-pass-processing.md)

Violated by
repeated scans over large data where avoidable

Detected by
multiple loops/materializations over same large input

Measured by
pass count, memory use

Refactored by
Fuse Passes, Use Iterator/Accumulator

Enforced by
performance review

Before

```typescript
const names = foos.map(foo => foo.name);
const active = foos.filter(foo => foo.active);
const total = foos.reduce((sum, foo) => sum + foo.count, 0);
```

After

```typescript
const names: string[] = [];
const active: Foo[] = [];
let total = 0;
for (const foo of foos) {
names.push(foo.name);
if (foo.active) active.push(foo);
total += foo.count;
}
```

### Pipeline Architecture

- Kind: [pattern](https://banes-lab.com/records/kind/pattern.md)
- Severity: recommended
- Scope: processing, dataflow, build
- Layer: [Execution Core](https://banes-lab.com/records/layer/execution-core.md)

Details

Requires
[Stage Contracts](https://banes-lab.com/records/lex/stage-contracts.md)

Reinforces
[Composability](https://banes-lab.com/records/arch/composability.md), [Streaming](https://banes-lab.com/records/lex/streaming.md)

Enables
[Stepwise Transformation](https://banes-lab.com/records/lex/stepwise-transformation.md)

In tension with
[Error Propagation/Debugging](https://banes-lab.com/records/lex/error-propagation-debugging.md)

Conflicts with
[Monolithic Processing Function](https://banes-lab.com/records/lex/monolithic-processing-function.md)

Referenced by
[Composability](https://banes-lab.com/records/arch/composability.md), [Dataflow Architecture](https://banes-lab.com/records/arch/dataflow-architecture.md)

Tensions
[Pipeline Architecture Error Propagation/Debugging](https://banes-lab.com/records/tension/error-propagation-debugging-pipeline-architecture.md)

Violated by
one large processor handling all stages

Detected by
long procedural transformation chain

Measured by
stage cohesion, stage contract coverage

Refactored by
Split into Stages, Define Stage Contracts

Enforced by
pipeline tests

Before

```typescript
function processFoo(raw: string) {
const parsed = JSON.parse(raw);
const validated = validateFoo(parsed);
const normalized = normalizeFoo(validated);
return saveFoo(normalized);
}
```

After

```typescript
const fooPipeline = pipeline(
parseJson,
validateWith(FooSchema),
normalizeFoo,
saveFoo,
);
fooPipeline.run(raw);
```

### Lazy Evaluation

- Kind: [approach](https://banes-lab.com/records/kind/approach.md)
- Severity: contextual
- Scope: computation, collection, stream
- Layer: [Execution Core](https://banes-lab.com/records/layer/execution-core.md)

Details

Requires
[Deferred Execution Semantics](https://banes-lab.com/records/lex/deferred-execution-semantics.md)

Reinforces
[Memory Efficiency](https://banes-lab.com/records/arch/memory-efficiency.md)

Enables
[Avoiding Unneeded Work](https://banes-lab.com/records/lex/avoiding-unneeded-work.md)

In tension with
[Debuggability/Resource Lifetime](https://banes-lab.com/records/lex/debuggability-resource-lifetime.md), [Eager Full Materialization](https://banes-lab.com/records/lex/eager-full-materialization.md)

Conflicts with
none

Tensions
[Lazy Evaluation Debuggability/Resource Lifetime](https://banes-lab.com/records/tension/debuggability-resource-lifetime-lazy-evaluation.md), [Lazy Evaluation Eager Full Materialization](https://banes-lab.com/records/tension/eager-full-materialization-lazy-evaluation.md)

Violated by
computing/materializing unused results

Detected by
eager loading of large unused data

Measured by
avoided work, memory reduction

Refactored by
Use Iterator/Generator, Defer Computation

Enforced by
performance tests

Before

```typescript
const normalized = millionFoos.map(normalizeFoo);
const active = normalized.filter(foo => foo.active);
const firstTen = active.slice(0, 10);
```

After

```typescript
const firstTen = sequence(millionFoos)
.map(normalizeFoo)
.filter(foo => foo.active)
.take(10)
.toArray();
```

### Sequential Access

- Kind: [pattern](https://banes-lab.com/records/kind/pattern.md)
- Severity: contextual
- Scope: file, stream, iterator
- Layer: [Execution Core](https://banes-lab.com/records/layer/execution-core.md)

Details

Requires
[Ordered Read Model](https://banes-lab.com/records/lex/ordered-read-model.md)

Reinforces
[Memory Efficiency](https://banes-lab.com/records/arch/memory-efficiency.md)

Enables
[Large Data Processing](https://banes-lab.com/records/lex/large-data-processing.md)

In tension with
[Lookup Performance](https://banes-lab.com/records/lex/lookup-performance.md), [Random Access Requirement](https://banes-lab.com/records/lex/random-access-requirement.md)

Conflicts with
none

Tensions
[Sequential Access Lookup Performance](https://banes-lab.com/records/tension/lookup-performance-sequential-access.md), [Sequential Access Random Access Requirement](https://banes-lab.com/records/tension/random-access-requirement-sequential-access.md)

Violated by
random access over stream-only source

Detected by
seek/index assumptions on sequential source

Measured by
access pattern cost

Refactored by
Use Buffer/Index or Stream Sequentially

Enforced by
performance tests

Before

```typescript
for (const id of fooIds) await fooStore.randomRead(id);
```

After

```typescript
for await (const foo of fooStore.scan({ orderBy: "id" })) {
processFoo(foo);
}
```

### Forward-Only Processing

- Kind: [constraint](https://banes-lab.com/records/kind/constraint.md)
- Severity: contextual
- Scope: stream, parser, iterator
- Layer: [Execution Core](https://banes-lab.com/records/layer/execution-core.md)

Details

Requires
[No Backtracking Requirement](https://banes-lab.com/records/lex/no-backtracking-requirement.md)

Reinforces
[Single-Pass Processing](https://banes-lab.com/records/arch/single-pass-processing.md)

Enables
[Streaming Parsers](https://banes-lab.com/records/lex/streaming-parsers.md)

In tension with
[Complex Grammar/Global State](https://banes-lab.com/records/lex/complex-grammar-global-state.md), [Backtracking Algorithm](https://banes-lab.com/records/lex/backtracking-algorithm.md)

Conflicts with
none

Tensions
[Forward-Only Processing Complex Grammar/Global State](https://banes-lab.com/records/tension/complex-grammar-global-state-forward-only-processing.md), [Forward-Only Processing Backtracking Algorithm](https://banes-lab.com/records/tension/backtracking-algorithm-forward-only-processing.md)

Violated by
requiring prior/future full data in stream path

Detected by
buffering full stream to look back

Measured by
buffer size, pass count

Refactored by
Add Rolling State, Redesign Parser

Enforced by
memory tests

Before

```typescript
const cursor = fooStream.cursor();
cursor.next();
cursor.previous();
cursor.seek(0);
```

After

```typescript
for await (const foo of fooStream) {
await processFoo(foo);
}
```

### Dataflow Architecture

- Kind: [style](https://banes-lab.com/records/kind/style.md)
- Severity: contextual
- Scope: processing, workflow, stream
- Layer: [Execution Core](https://banes-lab.com/records/layer/execution-core.md)

Details

Requires
[Data Dependencies](https://banes-lab.com/records/lex/data-dependencies.md), [Stages](https://banes-lab.com/records/lex/stages.md)

Reinforces
[Pipeline Architecture](https://banes-lab.com/records/arch/pipeline-architecture.md)

Enables
[Parallel/Stream Processing](https://banes-lab.com/records/lex/parallel-stream-processing.md)

In tension with
[State Coordination](https://banes-lab.com/records/lex/state-coordination.md)

Conflicts with
[Control-Flow-Centric Monolith](https://banes-lab.com/records/lex/control-flow-centric-monolith.md)

Tensions
[Dataflow Architecture State Coordination](https://banes-lab.com/records/tension/dataflow-architecture-state-coordination.md)

Violated by
hidden data dependencies between stages

Detected by
implicit shared state in pipeline

Measured by
data dependency clarity

Refactored by
Make Data Edges Explicit, Split Stages

Enforced by
pipeline contracts

Before

```typescript
controller.runFoo();
controller.runBar();
controller.runBaz();
```

After

```typescript
const graph = dataflow()
.source("foo", fooSource)
.map("bar", "foo", toBar)
.map("baz", "bar", toBaz)
.sink("output", "baz", bazSink);
await graph.run();
```

### Stateless Processing

- Kind: [principle](https://banes-lab.com/records/kind/principle.md)
- Severity: recommended
- Scope: function, stream processor, service
- Layer: [Execution Core](https://banes-lab.com/records/layer/execution-core.md)

Details

Requires
[Explicit Inputs](https://banes-lab.com/records/lex/explicit-inputs.md), [No Hidden State](https://banes-lab.com/records/lex/no-hidden-state.md)

Reinforces
[Scalability](https://banes-lab.com/records/arch/scalability.md), [Testability](https://banes-lab.com/records/arch/testability.md)

Enables
[Parallel Processing](https://banes-lab.com/records/lex/parallel-processing.md)

In tension with
[Stateful Business Rules](https://banes-lab.com/records/lex/stateful-business-rules.md)

Conflicts with
[Stateful Hidden Accumulation](https://banes-lab.com/records/lex/stateful-hidden-accumulation.md)

Tensions
[Stateless Processing Stateful Business Rules](https://banes-lab.com/records/tension/stateful-business-rules-stateless-processing.md)

Violated by
hidden mutable state in processor

Detected by
mutable state across records/requests

Measured by
stateful operator count

Refactored by
Externalize State, Pass State Explicitly

Enforced by
[code review](https://banes-lab.com/records/arch/code-review.md), [tests](https://banes-lab.com/records/lex/tests.md)

Before

```typescript
class FooProcessor {
private previous?: Foo;
process(foo: Foo) {
const result = merge(this.previous, foo);
this.previous = foo;
return result;
}
}
```

After

```typescript
function processFoo(foo: Foo, context: Readonly<FooContext>): FooResult {
return deriveFooResult(foo, context);
}
```

### Windowing

- Kind: [mechanism](https://banes-lab.com/records/kind/mechanism.md)
- Severity: contextual
- Scope: data processing, streaming, aggregation
- Layer: [Execution Core](https://banes-lab.com/records/layer/execution-core.md)

Details

Requires
[Event Time](https://banes-lab.com/records/lex/event-time.md)

Reinforces
[Streaming Architecture](https://banes-lab.com/records/arch/streaming-architecture.md), [Bounded State](https://banes-lab.com/records/lex/bounded-state.md)

Enables
[Bounded Aggregation over Unbounded Streams](https://banes-lab.com/records/lex/bounded-aggregation-over-unbounded-streams.md)

In tension with
[Late-Data Handling](https://banes-lab.com/records/lex/late-data-handling.md)

Conflicts with
[Unbounded Accumulation](https://banes-lab.com/records/lex/unbounded-accumulation.md)

Tensions
[Windowing Late-Data Handling](https://banes-lab.com/records/tension/late-data-handling-windowing.md)

Violated by
aggregating an unbounded stream into ever-growing state

Detected by
unbounded accumulator over a stream

Measured by
aggregation state growth rate

Refactored by
Aggregate over Windows

Enforced by
streaming design review

Before

```typescript
const total = allFooEvents.reduce((sum, event) => sum + event.value, 0);
```

After

```typescript
for await (const window of fooStream.tumbling({ seconds: 60 })) {
emit(window.start, window.events.reduce((sum, event) => sum + event.value, 0));
}
```

### Fan-out/Fan-in

- Kind: [pattern](https://banes-lab.com/records/kind/pattern.md)
- Severity: contextual
- Scope: data processing, parallelism, pipeline
- Layer: [Execution Core](https://banes-lab.com/records/layer/execution-core.md)

Details

Requires
[Independent Work Units](https://banes-lab.com/records/lex/independent-work-units.md)

Reinforces
[Parallelism](https://banes-lab.com/records/arch/parallelism.md), [Throughput](https://banes-lab.com/records/arch/throughput.md)

Enables
[Parallel Branch Processing](https://banes-lab.com/records/lex/parallel-branch-processing.md), [Result Aggregation](https://banes-lab.com/records/lex/result-aggregation.md)

In tension with
[Coordination Overhead](https://banes-lab.com/records/lex/coordination-overhead.md), [Serial Item Processing](https://banes-lab.com/records/lex/serial-item-processing.md)

Conflicts with
none

Tensions
[Fan-out/Fan-in Coordination Overhead](https://banes-lab.com/records/tension/coordination-overhead-fan-out-fan-in.md), [Fan-out/Fan-in Serial Item Processing](https://banes-lab.com/records/tension/fan-out-fan-in-serial-item-processing.md)

Violated by
independent items processed strictly one at a time

Detected by
serial loop over parallelizable work

Measured by
parallelism utilization

Refactored by
Fan Out Work, Fan In Results

Enforced by
pipeline design review

Before

```typescript
const report = await buildFullFooReport(foos);
```

After

```typescript
const partials = await fanOut(partition(foos), buildPartialFooReport);
const report = fanIn(partials, mergeFooReports);
```

### Batch-vs-Stream

- Kind: [approach](https://banes-lab.com/records/kind/approach.md)
- Severity: contextual
- Scope: data processing, latency, architecture
- Layer: [Execution Core](https://banes-lab.com/records/layer/execution-core.md)

Details

Requires
[Latency Requirement Clarity](https://banes-lab.com/records/lex/latency-requirement-clarity.md)

Reinforces
[Fitness for Purpose](https://banes-lab.com/records/lex/fitness-for-purpose.md)

Enables
[Latency-Appropriate Processing Model](https://banes-lab.com/records/lex/latency-appropriate-processing-model.md)

In tension with
[Operational Duplication](https://banes-lab.com/records/lex/operational-duplication.md)

Conflicts with
[One-Size-Fits-All Processing](https://banes-lab.com/records/lex/one-size-fits-all-processing.md)

Tensions
[Batch-vs-Stream Operational Duplication](https://banes-lab.com/records/tension/batch-vs-stream-operational-duplication.md)

Violated by
low-latency needs served by periodic batch jobs

Detected by
batch cadence mismatched to freshness requirements

Measured by
data-freshness lag vs requirement

Refactored by
Choose Batch or Stream by Latency Need

Enforced by
data architecture review

Before

```typescript
schedule.daily(() => reprocessAllFoos());
```

After

```typescript
fooStream.subscribe(foo => processFoo(foo));
```

## Links to

- [style](https://banes-lab.com/records/kind/style.md)
- [Execution Core](https://banes-lab.com/records/layer/execution-core.md)
- [Event Stream](https://banes-lab.com/records/arch/event-stream.md)
- [Backpressure](https://banes-lab.com/records/arch/backpressure.md)
- [Single-Pass Processing](https://banes-lab.com/records/arch/single-pass-processing.md)
- [Continuous Processing](https://banes-lab.com/records/lex/continuous-processing.md)
- [Ordering/State](https://banes-lab.com/records/lex/ordering-state.md)
- [Batch-Only Processing](https://banes-lab.com/records/lex/batch-only-processing.md)
- [Windowing](https://banes-lab.com/records/arch/windowing.md)
- [Streaming Architecture / Ordering/State](https://banes-lab.com/records/tension/ordering-state-streaming-architecture.md)
- [Streaming Architecture / Batch-Only Processing](https://banes-lab.com/records/tension/batch-only-processing-streaming-architecture.md)
- [Throughput](https://banes-lab.com/records/arch/throughput.md)
- [principle](https://banes-lab.com/records/kind/principle.md)
- [Forward-Only State Model](https://banes-lab.com/records/lex/forward-only-state-model.md)
- [Memory Efficiency](https://banes-lab.com/records/arch/memory-efficiency.md)
- [Large Input Handling](https://banes-lab.com/records/lex/large-input-handling.md)
- [Global Optimization](https://banes-lab.com/records/lex/global-optimization.md)
- [Multi-Pass Full Materialization](https://banes-lab.com/records/lex/multi-pass-full-materialization.md)
- [Streaming Architecture](https://banes-lab.com/records/arch/streaming-architecture.md)
- [Forward-Only Processing](https://banes-lab.com/records/arch/forward-only-processing.md)
- [Single-Pass Processing / Global Optimization](https://banes-lab.com/records/tension/global-optimization-single-pass-processing.md)
- [Single-Pass Processing / Multi-Pass Full Materialization](https://banes-lab.com/records/tension/multi-pass-full-materialization-single-pass-processing.md)
- [pattern](https://banes-lab.com/records/kind/pattern.md)
- [Stage Contracts](https://banes-lab.com/records/lex/stage-contracts.md)
- [Composability](https://banes-lab.com/records/arch/composability.md)
- [Streaming](https://banes-lab.com/records/lex/streaming.md)
- [Stepwise Transformation](https://banes-lab.com/records/lex/stepwise-transformation.md)
- [Error Propagation/Debugging](https://banes-lab.com/records/lex/error-propagation-debugging.md)
- [Monolithic Processing Function](https://banes-lab.com/records/lex/monolithic-processing-function.md)
- [Dataflow Architecture](https://banes-lab.com/records/arch/dataflow-architecture.md)
- [Pipeline Architecture / Error Propagation/Debugging](https://banes-lab.com/records/tension/error-propagation-debugging-pipeline-architecture.md)
- [approach](https://banes-lab.com/records/kind/approach.md)
- [Deferred Execution Semantics](https://banes-lab.com/records/lex/deferred-execution-semantics.md)
- [Avoiding Unneeded Work](https://banes-lab.com/records/lex/avoiding-unneeded-work.md)
- [Debuggability/Resource Lifetime](https://banes-lab.com/records/lex/debuggability-resource-lifetime.md)
- [Eager Full Materialization](https://banes-lab.com/records/lex/eager-full-materialization.md)
- [Lazy Evaluation / Debuggability/Resource Lifetime](https://banes-lab.com/records/tension/debuggability-resource-lifetime-lazy-evaluation.md)
- [Lazy Evaluation / Eager Full Materialization](https://banes-lab.com/records/tension/eager-full-materialization-lazy-evaluation.md)
- [Ordered Read Model](https://banes-lab.com/records/lex/ordered-read-model.md)
- [Large Data Processing](https://banes-lab.com/records/lex/large-data-processing.md)
- [Lookup Performance](https://banes-lab.com/records/lex/lookup-performance.md)
- [Random Access Requirement](https://banes-lab.com/records/lex/random-access-requirement.md)
- [Sequential Access / Lookup Performance](https://banes-lab.com/records/tension/lookup-performance-sequential-access.md)
- [Sequential Access / Random Access Requirement](https://banes-lab.com/records/tension/random-access-requirement-sequential-access.md)
- [constraint](https://banes-lab.com/records/kind/constraint.md)
- [No Backtracking Requirement](https://banes-lab.com/records/lex/no-backtracking-requirement.md)
- [Streaming Parsers](https://banes-lab.com/records/lex/streaming-parsers.md)
- [Complex Grammar/Global State](https://banes-lab.com/records/lex/complex-grammar-global-state.md)
- [Backtracking Algorithm](https://banes-lab.com/records/lex/backtracking-algorithm.md)
- [Forward-Only Processing / Complex Grammar/Global State](https://banes-lab.com/records/tension/complex-grammar-global-state-forward-only-processing.md)
- [Forward-Only Processing / Backtracking Algorithm](https://banes-lab.com/records/tension/backtracking-algorithm-forward-only-processing.md)
- [Data Dependencies](https://banes-lab.com/records/lex/data-dependencies.md)
- [Stages](https://banes-lab.com/records/lex/stages.md)
- [Pipeline Architecture](https://banes-lab.com/records/arch/pipeline-architecture.md)
- [Parallel/Stream Processing](https://banes-lab.com/records/lex/parallel-stream-processing.md)
- [State Coordination](https://banes-lab.com/records/lex/state-coordination.md)
- [Control-Flow-Centric Monolith](https://banes-lab.com/records/lex/control-flow-centric-monolith.md)
- [Dataflow Architecture / State Coordination](https://banes-lab.com/records/tension/dataflow-architecture-state-coordination.md)
- [Explicit Inputs](https://banes-lab.com/records/lex/explicit-inputs.md)
- [No Hidden State](https://banes-lab.com/records/lex/no-hidden-state.md)
- [Scalability](https://banes-lab.com/records/arch/scalability.md)
- [Testability](https://banes-lab.com/records/arch/testability.md)
- [Parallel Processing](https://banes-lab.com/records/lex/parallel-processing.md)
- [Stateful Business Rules](https://banes-lab.com/records/lex/stateful-business-rules.md)
- [Stateful Hidden Accumulation](https://banes-lab.com/records/lex/stateful-hidden-accumulation.md)
- [Stateless Processing / Stateful Business Rules](https://banes-lab.com/records/tension/stateful-business-rules-stateless-processing.md)
- [Code Review](https://banes-lab.com/records/arch/code-review.md)
- [Tests](https://banes-lab.com/records/lex/tests.md)
- [mechanism](https://banes-lab.com/records/kind/mechanism.md)
- [Event Time](https://banes-lab.com/records/lex/event-time.md)
- [Bounded State](https://banes-lab.com/records/lex/bounded-state.md)
- [Bounded Aggregation over Unbounded Streams](https://banes-lab.com/records/lex/bounded-aggregation-over-unbounded-streams.md)
- [Late-Data Handling](https://banes-lab.com/records/lex/late-data-handling.md)
- [Unbounded Accumulation](https://banes-lab.com/records/lex/unbounded-accumulation.md)
- [Windowing / Late-Data Handling](https://banes-lab.com/records/tension/late-data-handling-windowing.md)
- [Independent Work Units](https://banes-lab.com/records/lex/independent-work-units.md)
- [Parallelism](https://banes-lab.com/records/arch/parallelism.md)
- [Parallel Branch Processing](https://banes-lab.com/records/lex/parallel-branch-processing.md)
- [Result Aggregation](https://banes-lab.com/records/lex/result-aggregation.md)
- [Coordination Overhead](https://banes-lab.com/records/lex/coordination-overhead.md)
- [Serial Item Processing](https://banes-lab.com/records/lex/serial-item-processing.md)
- [Fan-out/Fan-in / Coordination Overhead](https://banes-lab.com/records/tension/coordination-overhead-fan-out-fan-in.md)
- [Fan-out/Fan-in / Serial Item Processing](https://banes-lab.com/records/tension/fan-out-fan-in-serial-item-processing.md)
- [Latency Requirement Clarity](https://banes-lab.com/records/lex/latency-requirement-clarity.md)
- [Fitness for Purpose](https://banes-lab.com/records/lex/fitness-for-purpose.md)
- [Latency-Appropriate Processing Model](https://banes-lab.com/records/lex/latency-appropriate-processing-model.md)
- [Operational Duplication](https://banes-lab.com/records/lex/operational-duplication.md)
- [One-Size-Fits-All Processing](https://banes-lab.com/records/lex/one-size-fits-all-processing.md)
- [Batch-vs-Stream / Operational Duplication](https://banes-lab.com/records/tension/batch-vs-stream-operational-duplication.md)

## Linked from

- [The layer topology](https://banes-lab.com/ontology/schema/the-layer-topology.md)
- [The membership](https://banes-lab.com/ontology/schema/the-membership.md)
