Since we are on Hacker News, I will say that this is not only a very cool technique in the physical world, it's also an amazing pattern to have when writing algorithms: think about your "support" and your "feature building" as potentially separate passes.

Say you have a bunch of dynamic business rules that you need to apply onto a calendar of days, or a canvas of spreadsheet cells, or another discrete collection of slots where information could go, or even a continuous domain (in all of which some type of gap-filling and continuity might be desired).

Rather than looping in one pass over your rules, and trying to figure out how to simultaneously fill gaps and write meaningful information into specific places, it might be helpful to first pass over your rules and think "where is the support area that might be needed, all of the places where some rule or combo of rules might write information." After all, if you're just thinking about support, you can trivially combine things, because you're just applying some kind of union operation as you go along.

Then you can do another pass, where you worry about order and precedence and complex inter-rule interactions, while knowing you already have a pre-made "canvas" on which you can paint and - in the real-world analogy - play with color and texture and all that fun stuff.

Of course, you no longer have an algorithm that can handle streaming data, but two passes are still O(N), and the resulting code can be infinitely more readable.

(To the mathematicians out there, I do apologize for being inspired by, but completely ignoring the nuance of, https://en.wikipedia.org/wiki/Support_(measure_theory) - but I think it's a useful mental model even when generalized in a less-than-mathematical way!)

I love this idea. I've had to make this decision before (one or two passes). Now I'll do two passes for readability and stick this comment in my code:

// Daddy, chill. Two passes are still O(N).

// O notation is another example of what you measure, you get

// Got a performance issue, hide it in the constant, don't expose it in the f(N) :-)

Two passes can be far more efficient if you take memory layout and pagefaults into account.

Same logic as to why you can assemble a set of identical pieces of IKEA furniture faster if you first do step 1 for all pieces, then step 2 for all pieces etc, than if you assemble the pieces one by one.

> (To the mathematicians out there, I do apologize for being inspired by, but completely ignoring the nuance of, https://en.wikipedia.org/wiki/Support_(measure_theory) - but I think it's a useful mental model even when generalized in a less-than-mathematical way!)

Mathematician here. We steal real-world terms and use them in technical ways all the time. It's OK to use real-world terms like "support" non-mathematically.

This sounds eerily like double (k-able) buffering? Don't get me wrong still pretty cool!