Backpressure: When the Stream Tells You to Wait

A fly line holds about ninety feet in the air during a cast, and you learn quickly that you can’t feed more line until the loop travels forward and straightens. If you try, the line collapses. The cast has a rhythm: shoot line, wait for the loop to turn over, shoot again. The river doesn’t care if you’re ready. The line has capacity limits.

Backpressure works the same way. A producer generates data faster than a consumer can process it, so you need a bounded buffer between them. When the buffer fills, the producer blocks until space opens up. No data gets dropped, no memory explodes, but the producer has to wait.

Go’s channels handle this naturally. A buffered channel with capacity 3 holds three items; the fourth send blocks until someone receives:

package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int, 3)
    for i := 0; i < 5; i++ {
        select {
        case ch <- i:
            fmt.Printf("sent %d\n", i)
        default:
            fmt.Printf("%d blocked (buffer full)\n", i)
            go func() {
                time.Sleep(10 * time.Millisecond)
                <-ch
            }()
            ch <- i  // block until space available
            fmt.Printf("sent %d after waiting\n", i)
        }
    }
}

Lua doesn’t have channels, but you can build a bounded queue with a table and a pair of indices. When count hits capacity, the producer waits:

queue = {items={}, head=1, tail=1, count=0, capacity=3}
function push(q, item)
    while q.count >= q.capacity do
        -- blocked: wait or yield
    end
    q.items[q.tail] = item
    q.tail, q.count = q.tail + 1, q.count + 1
end

TCP does this with window sizes. Unix pipes do it with kernel buffers (typically 64KB). Kafka does it with partition lag. The pattern appears whenever two processes run at different speeds and you can’t afford to lose data. The downstream consumer controls the flow by consuming at its own pace, and the upstream producer respects that pace. It’s the computational equivalent of waiting for your backcast to load before driving forward.