skip to content

conflate() is equivalent to which buffer(...) configuration, and what does that imply about its buffer size and overflow handling?

level: middleimportance: must knowfreq 45%

answer

  1. buffer(1, DROP_OLDEST)
  2. Channel.CONFLATED
  3. Capacity exactly one
  4. DROP_OLDEST keeps newest; DROP_LATEST keeps stale
  5. Overflow drops, never suspends producer

basics

~10 s

conflate() is the same as a buffer of size one that throws away the oldest value when a new one arrives. So at most one value waits, and it's always the newest.

solid answer

~40 s

conflate() is shorthand for buffer(capacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST), equivalently buffer(Channel.CONFLATED). The implication: the channel between producer and collector holds a single slot. When the slot is full and a new value arrives, the previously buffered (oldest) value is dropped — never the incoming one — so the collector always reads the freshest value. Because of this, the producer never suspends on a full buffer (overflow is resolved by dropping, not by suspending). Contrast with the default buffer() (capacity 64, SUSPEND), which preserves all values and back-pressures the producer, or DROP_LATEST, which keeps the buffered value and discards the newcomer — the opposite of what conflate wants. Knowing the equivalence lets you reason about emission counts and choose between conflate() and an explicit buffer() call.

code

kotlin · 4 lines
kotlin
// Equivalent forms
flow.conflate()
flow.buffer(capacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST)
flow.buffer(Channel.CONFLATED)

go deeper

for a junior

Recognizes conflate() involves a small buffer that keeps the latest value.

for a middle

States the exact equivalence buffer(1, DROP_OLDEST) and explains DROP_OLDEST vs DROP_LATEST and the no-suspend consequence.

for a senior

Reasons about emission/throughput implications and when to use an explicit buffer with a larger capacity instead of conflate.

for a principal

Connects the channel-capacity/overflow model to latency budgets and chooses the right strategy across a streaming system.

## The exact equivalence ```kotlin // These behave the same: flow.conflate() flow.buffer(capacity = 1, onBufferOverflow = BufferOverflow.DROP_OLDEST) flow.buffer(Channel.CONFLATED) ``` `conflate()` is a convenience operator built on top of `buffer`. Internally the operator inserts a **conflated channel** between the producer coroutine and the collector. ## What each piece means - **capacity = 1** — the buffer can hold at most one pending value. - **`BufferOverflow.DROP_OLDEST`** — when a new value arrives and the buffer is full, the **oldest** element is evicted to make room. Since capacity is 1, the single buffered value is replaced by the newcomer. Net effect: *keep the latest*. `BufferOverflow` has three options; only `DROP_OLDEST` gives conflate semantics: | Strategy | On overflow | Producer suspends? | |---|---|---| | `SUSPEND` (default of `buffer()`) | wait for room | yes | | `DROP_OLDEST` | evict oldest buffered value | no | | `DROP_LATEST` | discard the incoming value | no | ## Why the producer never suspends Because overflow is resolved by **dropping** rather than waiting, `emit()` on the producer side never blocks waiting for free buffer space. This is what makes conflate good for *fast* producers — emission throughput is unaffected by collector speed. ## DROP_OLDEST vs DROP_LATEST — easy to confuse `DROP_LATEST` would keep the value already in the buffer and throw away the **new** emission — meaning the collector could read a *stale* value while the freshest one is discarded. That is the opposite of conflate's goal, so conflate uses `DROP_OLDEST`. ## Practical consequence If you ever need conflate-like behaviour but with, say, capacity 2 (keep a tiny tail), you write `buffer(2, BufferOverflow.DROP_OLDEST)` directly. conflate() simply hard-codes capacity 1. ```kotlin // conflate() and this are interchangeable upstream .buffer(1, BufferOverflow.DROP_OLDEST) .collect { render(it) } ```

  • What would buffer(1, BufferOverflow.DROP_LATEST) do differently from conflate()?
    It keeps the value already in the buffer and discards the newly emitted one, so the collector can see a stale value — the opposite of conflate, which always keeps the freshest.
  • Does conflate() ever suspend the producer on backpressure?
    No. Overflow is handled by dropping the oldest buffered value, so emit() never blocks waiting for buffer space — unlike the default SUSPEND strategy.

saying these in an interview costs you the question

  • Says conflate() uses DROP_LATEST
  • Claims it has a large/default buffer of 64
  • Thinks the producer suspends on overflow like the default buffer()
  • Cannot name BufferOverflow.DROP_OLDEST

context

resolving links…