Ring Buffers and Closed-Loop Systems

A terrarium is a fixed container where resources cycle endlessly—water evaporates, condenses on the glass, drips back into the soil. Nothing leaves. Nothing new enters. The same molecules circulate through different states, finding equilibrium within hard boundaries.

Ring buffers work identically. You allocate a fixed array and two pointers: one for writing, one for reading. When the write pointer reaches the end, it wraps back to the beginning and overwrites the oldest data. The buffer never grows. The same memory addresses are reused indefinitely. This was critical in the 1970s when RAM cost thousands of dollars per kilobyte—you couldn’t afford to allocate and free memory dynamically, and you certainly couldn’t let buffers grow unbounded.

Here’s Go implementing a three-slot ring for sensor readings:

package main
import "fmt"

type Ring struct { data [3]float64; write int }

func (r *Ring) Add(v float64) {
    r.data[r.write] = v
    r.write = (r.write + 1) % 3
}

func main() {
    r := Ring{}
    for _, v := range []float64{20.1, 21.3, 19.8, 22.4, 23.1} {
        r.Add(v)
        fmt.Println(r.data)
    }
}

And Lua, which makes the modulo arithmetic explicit:

ring = {data = {}, size = 3, write = 1}

function ring:add(v)
    self.data[self.write] = v
    self.write = (self.write % self.size) + 1
end

for _, v in ipairs({20.1, 21.3, 19.8, 22.4, 23.1}) do
    ring:add(v)
    print(table.concat(ring.data, ", "))
end

After five writes into three slots, you keep only the most recent three. The oldest measurements vanish, overwritten by new ones. Audio buffers use this for real-time streaming. Serial ports use it to prevent overflow. Embedded systems use it everywhere because the alternative—dynamic allocation—introduces unpredictable latency and fragmentation.

The terrarium’s water cycle is a ring buffer where the size is determined by the volume of the container. Get the initial conditions right, and the system sustains itself indefinitely within those fixed bounds.