What does deep-freezing every object reachable from a published price list cost as that graph grows?

Deep immutability is a property of a value's reachable closure, and there are two moments at which you can establish it: when data enters, or when the value is published. This question is about what the second one costs. ## The shape of the cost Freezing the closure is a graph traversal. Let **n** be the number of objects reachable from the published price list — the root, the container of tier rows, each row, and anything a row reaches in turn. The walk visits each of them, so the work is proportional to n. The important part is what n is *not* proportional to. It is not the number of fields that changed. It is not the number of rows edited. A publication in which a single amount moved by one unit costs the same walk as a publication that rebuilt every tier, because a traversal cannot know which parts changed without visiting them. If the value is republished on a schedule, that cost recurs at the schedule's rate, mostly over parts that were identical last time. ## The costs behind the walk - **Repeated work over unchanged structure.** Most of what the walk touches is the same as at the last publication, and it is re-walked anyway. - **Allocation, where freezing means wrapping.** If unwritability is achieved by producing a substitute object per node rather than by flipping something on the node itself, the walk allocates in proportion to n as well as visiting in proportion to n. - **Indirection at read time.** A per-node wrapper adds a hop on every subsequent read of that node, which is paid by readers forever rather than once at publication. - **A window before the freeze.** The value exists in a writable state between construction and the freeze, and anyone who obtained a reference during that window is unaffected by the later freeze. ## Where the owner cannot freeze at all Unwritability is a property an object has to be able to support. If a part of the graph arrived from somewhere else and offers no way to become unwritable, the owner cannot impose it from outside; the only route left is to build a substitute out of parts the owner controls and use that. At that point the deep freeze has quietly become a rebuild, and pricing it as a cheap sweep at the end is wrong. This is the practical reason whole-graph freezing tends not to survive contact with real data: the graph is rarely made entirely of objects you defined. ## Moving the boundary instead The alternative is to fix **where** the guarantee is established. Admit incoming data at a single entry point, converting it there into structures that cannot be written, and build everything inside out of those. The interior is then unwritable by construction and never needs a later pass. ``` // entry point: pay once, on the way in function admit(incomingRows) return fixedSequence(map(incomingRows, r -> fixedRow(r.threshold, r.amount))) // publication: no traversal, nothing to prove function publish(fixedRows) return { tiers: fixedRows } ``` The conversion at the entry point costs work proportional to k, the size of the data arriving. That is not free, and it is not nothing — but it is paid once per arrival instead of once per publication, and it closes the window, because there is never an interval during which the interior is writable. ## Choosing between them | | Freeze the graph at publication | Unwritable at the entry point | |---|---|---| | Cost paid when | On every publication | Once, when data arrives | | Cost proportional to | n reachable objects | k incoming items | | Unchanged parts | Re-walked every time | Never revisited | | Objects you do not control | May be unfreezable | Converted on arrival | | Writable window | Exists until the freeze runs | None | Neither column is universally right. A small graph published rarely does not justify reshaping how data enters the system, and a freeze at the end is a reasonable local move there. A large graph, published often, built from parts that arrived from several places, is where the per-publication walk becomes the wrong place to pay — and where it is also least likely to succeed, because that is exactly the graph containing objects the owner cannot make unwritable. ## What a strong answer sounds like State the cost as a quantity and say what n is. Note that it is independent of the edit's size. Then add the two things that make it worse than the traversal alone — the parts that cannot be frozen from outside, and the window before the freeze runs — and name moving the boundary as the alternative, with its own honest cost per arrival rather than as a free win.