A case subtree has been cloned once per release, and one release's copy gets a corrected step. How does that correction reach the other releases' copies?
answer
- the tool propagates nothing
- an edit is one record's field write
- finding the siblings is the expensive half
- stamp a lineage value at clone time
- re-cloning over a copy destroys its edits
basics
~20 sSomeone carries it by hand. A cloned case is an independent record with no link back to its source, so the repository propagates nothing. You find the sibling copies yourself and re-apply the edit to each one you still support.
solid answer
~40 sNothing propagates. Each copy is a separate record, and an edit to a case is a field write on that record alone, so the other releases' copies are untouched and stay untouched until a person opens them. The work is therefore two jobs: **finding** the siblings, and **applying** the change to each. Finding is the expensive half - reliable only if a shared lineage value was stamped onto every copy at clone time, and fragile if you are matching on titles that have since been edited. Applying means reading each copy before you overwrite it, because a copy may carry deliberate release-specific wording you must not clobber. The tempting shortcut - re-cloning the source subtree over a stale copy - destroys exactly those edits and orphans the results already recorded against the replaced cases.
go deeper
Recall that copies are independent: editing one changes nothing anywhere else, and the other releases keep the old wording until somebody opens them.
Explain why - an edit is a write to one record, and the store has no notion that two records are the same logical case - then describe how you would find the siblings.
Demonstrate the operating side: classify the change before carrying it, read each copy before overwriting, and refuse the re-clone shortcut that orphans recorded results.
Frame the recurring hand-carry as the standing cost of the clone model, and be ready to argue when that cost outweighs the copies it buys.
## Nothing propagates, and that is the whole model When a case subtree is cloned per release, each release ends up with its own records. The repository stores an edit as a write to one record's fields. It has no notion that two cases in different folders are the same logical case, so an edit in one has no effect anywhere else - not on the source it was copied from, not on the sibling copies, not on any case that merely reads identically. That is worth stating flatly in an interview, because candidates often assume a copy behaves like a reference and will refresh itself. It will not. Any provenance note a product writes at clone time is descriptive text: useful for finding the source, but not a channel through which anything travels. ## How the correction actually travels 1. **Classify the change first.** Is this a correction to the *case* - a wrong expected result, a step that names the wrong screen, a typo - or a description of how *this release* behaves? Only the first kind should travel. Copying a behaviour description into an older release's copy makes that copy wrong for the release it describes. 2. **List the sibling copies** for every release still supported. This is the step that is cheap or expensive depending on decisions made at clone time. 3. **Open each copy and read it before editing.** A copy may carry deliberate release-specific wording; blind overwrite is how that wording is lost. 4. **Apply the edit, then record that you did.** A short note or a field value on each copy tells the next reader the set was reconciled, and on which day. ## Finding the siblings is the expensive half - **A shared lineage value** stamped into a field on every copy at clone time - the same value on all copies of one logical case. A filter on it lists the whole set in seconds. This is the only approach that stays reliable for years. - **Title matching**, which works until somebody edits a title, fixes a typo on one side, or splits a case in two. Its failures are silent: the match simply returns nothing, or the wrong case. - **Folder position**, which works until either tree is reorganised - and release trees get reorganised precisely because the releases diverge. - **Export and compare outside the repository**, which is the fallback when nothing was stamped: pull both subtrees into a flat file and match on text. Slow, lossy, and the reason to stamp a key in the first place. ## Three ways this goes wrong | Shortcut | What it costs | |---|---| | Re-cloning the source subtree over a stale copy to refresh it | Wipes the target's release-specific edits, and the results already recorded against the replaced cases are orphaned or point at cases that no longer exist | | Bulk-editing a selection that was assembled by search | Sweeps in cases from releases you did not mean to touch, and bulk edits are rarely reversible in one action | | Fixing only the release being worked on | The older supported release quietly keeps the wrong expected result, and the next person to run it either files a false defect or records a false pass | ## When the copies should stay different Divergence is not automatically a defect. Two supported releases genuinely can behave differently, and their copies *should* say so. The discipline is not *keep every copy identical* - that discards the only benefit of copying - but *know which differences are intentional*. A difference someone deliberately made and recorded is an asset. A difference nobody knows about is a trap, because the next reader cannot tell whether they are looking at a real release difference or a fix that never got carried across. The cheapest habit that makes all of this tractable costs one decision at clone time: stamp a stable lineage value on every copied case, and never derive it from the title, the folder or the release name. Derived values change when the thing they were derived from changes - which is exactly the moment you needed the value to still match.
- When is it right to leave the copies different rather than propagating the fix?When the difference is real. If the older release genuinely behaves the way its copy describes, because the change that altered the behaviour was never backported, then carrying the new wording across makes that copy wrong. Propagate corrections to the case; do not propagate a description of behaviour a release does not have.
- What single habit at clone time makes the later hand-carry cheapest?Stamping a stable lineage value into a field on every copied case at the moment of the clone, identical across all copies of one logical case. A filter on that value then lists every sibling instantly, which removes the expensive half of the job for as long as the copies exist.
Cloning a case subtree is photocopying a binder, not branching a repository. The two binders read alike on the day you make them, and from then on the only thing that moves a correction from one to the other is a person reading a page and writing it into the other binder.
saying these in an interview costs you the question
- Claims the repository merges the two copies for you
- Re-clones the whole subtree, wiping the target's own edits
- Assumes copies stay in sync because they started identical
- Edits only the current release and calls the fix done
- Matches siblings by title long after the clone