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 runs a chain to the bottom, and every link is forced.

Correspondence means the two cannot be written independently, because two independent authors produce two different courses. Not-independent means one is written first and the other follows 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 the requirement.

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, because syncing structure, code, and links across two independent authors is not hard — it is impractical to the point of producing two different products. Every later edit would need to be applied twice, by two people, with no mechanism to prove they matched.

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        two independent authors -> two different courses
FORCED        so: they are not independent
     |
     v
FORCED        so: one is written first, the other follows
     |
     v
FORCED        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,
                  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
     -> two products, and no mechanism 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. 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