You Cannot Forget on Command

The Chain That Forces the Design

Start from a requirement nobody argues with: the two versions must be the same course. Same structure, same examples, same code, same links, same claims. That single requirement, met the way this workshop meets it, runs a chain to the bottom.

The first link is a choice, and it is worth saying so. Two versions can be kept in correspondence by writing both in parallel against one detailed shared specification; localization teams do exactly that. This workshop weighed that route — it is the clean room further down — and rejected it for a corpus whose versions share code, links and structure, because every later edit would have to land twice with nothing to prove the two still matched. Once one version is written first, the rest follows: the other is written after it. Following means the second author holds the first version while writing. Holding it means the second version is shaped by it. So contamination is not a mistake in the process; it is a consequence of how the requirement is met.

Which changes the question entirely. You do not get to ask how to avoid contamination. You only get to ask where it is removed — and it cannot be removed by the context that produced it, because that context is exactly what would have to be set aside.

Why One Pass Cannot Do Both

Authoring and de-contaminating are not two halves of a task; they are two tasks with incompatible requirements. The authoring session must hold the source — that is its job, and withholding it would produce a different course. The repairing session must not hold it — that is its job, and holding it produces exactly the defect being repaired.

Asking one session to do both is asking it to forget on command, which is the single thing attention does not do on request. Every failed attempt in this workshop's history was a version of that request, phrased more and more politely.

The Alternative That Was Measured and Rejected

The obvious escape is a clean room: let a second author write the other version from scratch, from the same outline, never seeing the first. It was considered seriously and rejected for this corpus. Done well, against a detailed enough specification, the route works — localization teams run it. Here the versions share code, links and structure, every later edit would need to be applied twice, by two people, and the workshop had no mechanism to prove the two still matched; the likely result was two drifting products.

What survives from that idea is narrower and still useful: a different author may write the second version as translation, with the source in frame. That keeps correspondence and moves the contamination to a different mind, which is worth something. It does not remove the need for the cold pass, because the second author is still holding the source.

When a defect is a consequence of a requirement you are not willing to drop, stop trying to prevent it and start designing where it gets removed. Prevention work on a forced consequence is the most expensive kind of effort there is, because it can feel productive indefinitely without ever moving the number.

Code

The forced chain, and the escape that was rejected·text

REQUIREMENT   the two versions are ONE course
     |
     v        parallel authors against one shared spec: possible,
CHOSEN        weighed and rejected here (the clean room below)
              so: they are not independent
     |
     v
FOLLOWS       so: one is written first, the other follows
     |
     v
FOLLOWS       so: the follower HOLDS the first while writing
     |
     v
CONSEQUENCE   the second version is shaped by the first
              ^^^ this is not a mistake. it is the requirement,
                  met this way, arriving.

THE ONLY REMAINING QUESTION
     where does the shaping get removed?
     -> not here. this context is what would have to be unlearned.
     -> a later pass, in a context that never held the source.


REJECTED ESCAPE - the clean room
     second author writes from the outline, never sees version one
     x  structure drifts     x  code samples diverge
     x  links diverge        x  every future edit applied twice
     -> for THIS corpus: likely two products, and no mechanism
        here to prove they match

SURVIVING NARROW FORM
     a DIFFERENT author writes version two AS TRANSLATION, source
     in frame. correspondence holds; contamination moves to another
     mind. the cold pass is still required.

Exercise

Find a pair of artifacts in your work that must correspond, and identify which one is authored first (if both are written in parallel against a shared specification, pick a pair where one does come first). Then ask the second one's most recent author what they had open while writing it. That is your contamination source. Now find the step in your process where somebody reads the second artifact without the first — if there is no such step, you have located a defect class that nothing in your process can currently see.

Hint

Documentation is the most common second artifact and almost never gets a cold read, because reading the docs without the code feels like reading them wrong. That feeling is the whole point: a reader who cannot use the code to fill gaps is exactly the reader the documentation is for.

The Chain That Forces the Design

Why One Pass Cannot Do Both

The Alternative That Was Measured and Rejected

Code

External links

Exercise

Progress

Comments 0