Buffering & Windowing

Buffering and windowing convert an unbounded stream of individual items into a stream of bounded collections—arrays, Observables, or time-bounded groups. They are the bridge between reactive streams and batch processing, essential whenever downstream consumers need to work with groups of events rather than individual ones. `bufferTime(1000)` in RxJS collects all emissions within a 1-second window into an array and emits that array. This converts a high-frequency event stream into a metered batch output suitable for bulk database writes, batched API calls, or aggregated metrics. `bufferCount(100)` does the same by item count. Combining them as `bufferTime(1000, undefined, 100)` limits both time and count—emit whichever comes first. `windowTime` and `windowCount` emit inner Observables instead of arrays, enabling lazy processing of each window as it streams rather than waiting for it to complete. This is more memory-efficient for high-volume streams: you don't accumulate items in memory until the window closes. Kotlin Flow's `chunked` extension and `windowed` from the collections API apply to synchronous sequences; for Flow, the idiomatic approach is `buffer(capacity)` to decouple emission from collection, combined with a manual accumulator in `scan`. `conflate()` drops intermediate values when the collector is slow—keeping only the latest emission per collection cycle. `collectLatest()` cancels and restarts the collection block for each new emission. Apache Kafka's native consumer API groups records into batches via `max.poll.records`; Kotlin Flow's `buffer()` serves the same function at the in-process level, decoupling a fast producer coroutine from a slower processor coroutine. Pekko Streams provides `groupedWithin(count, duration)`, which emits a sequence of items when either the count or the duration threshold is reached—clean, declarative, and composable with any downstream `Flow` stage. This pattern is common in financial tick data processing, IoT sensor aggregation, and log pipeline batching where downstream storage is optimized for bulk inserts rather than individual writes.