When a learner can reproduce a familiar example but a small variation causes confusion, the problem is usually an incomplete model rather than a lack of effort. The fastest useful response is to expose the hidden state and test one boundary at a time.
git merge-file performs a three-way merge of one current file, one common-base file and one other file. By default it writes the merged result into the current file, so correct role assignment and disposable practice matter. Cleanly independent changes can be combined automatically; overlapping edits produce conflict markers and a non-zero status that must be inspected. Mastery means predicting hunks from the base, preserving originals, choosing marker and output policies deliberately, and never confusing a syntactically clean merge with a semantically correct result. This guide begins with that mechanism, then develops it through worked traces, deliberate mistakes, explained practice and transfer decisions.
The aim is independent reasoning. A learner should be able to predict behaviour, locate the earliest wrong assumption, use a safe diagnostic procedure and defend a design choice in a new project.
Punggol families can use the guide in short sessions around homework, CCAs and rest. The activities are proposed learning exercises, not claims about a physical branch, timetable, class size, fee, school relationship or guaranteed result.
Use disposable data and repositories, preserve backups, and check version-sensitive details against the official source. Current documentation settles a technical contract; observation and explanation turn that contract into usable knowledge.
Find your next learning step
Choose the route that matches the present difficulty. Use the complete index for a systematic course.
Build the model
Chapters 1-4 . Begin here, then continue after the learner can predict, verify and explain.
Use the core tools
Chapters 5-8 . Begin here, then continue after the learner can predict, verify and explain.
Handle boundaries
Chapters 9-12 . Begin here, then continue after the learner can predict, verify and explain.
Debug and verify
Chapters 13-16 . Begin here, then continue after the learner can predict, verify and explain.
Transfer with judgment
Chapters 17-20 . Begin here, then continue after the learner can predict, verify and explain.
Open the full chapter index . Jump to capstone practice . Use the How Studying Works hub . Read the official documentation
Complete chapter index
Chapters 1-4 . Build the model
Chapters 5-8 . Use the core tools
Chapters 9-12 . Handle boundaries
Chapters 13-16 . Debug and verify
Chapters 17-20 . Transfer with judgment
The arguments are current, base and other; the tool compares both sides with the base to decide what changed. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is passing files in chronological or alphabetical order rather than semantic roles. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Label each file with its relationship to the common ancestor before running the command.
For the Three roles define the merge chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on passing files in chronological or alphabetical order rather than semantic roles. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file current.txt base.txt other.txtExplained result. Independent changes from current and other are combined relative to base. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: homework outline. Predict the rule using combining two edits made from one shared essay plan. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The arguments are current, base and other; the tool compares both sides with the base to decide what changed.” Apply this procedure: Label each file with its relationship to the common ancestor before running the command. The expected mechanism is: Independent changes from current and other are combined relative to base. For the homework outline, add one near-miss that exposes passing files in chronological or alphabetical order rather than semantic roles. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: CCA programme. Contrast the rule using merging timetable wording changed by two organisers. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The arguments are current, base and other; the tool compares both sides with the base to decide what changed.” Apply this procedure: Label each file with its relationship to the common ancestor before running the command. The expected mechanism is: Independent changes from current and other are combined relative to base. For the CCA programme, add one near-miss that exposes passing files in chronological or alphabetical order rather than semantic roles. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: science report. Stress-test the rule using reconciling independent edits around one baseline paragraph. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The arguments are current, base and other; the tool compares both sides with the base to decide what changed.” Apply this procedure: Label each file with its relationship to the common ancestor before running the command. The expected mechanism is: Independent changes from current and other are combined relative to base. For the science report, add one near-miss that exposes passing files in chronological or alphabetical order rather than semantic roles. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: revision notes. Explain the rule using joining additions to different sections of one topic file. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The arguments are current, base and other; the tool compares both sides with the base to decide what changed.” Apply this procedure: Label each file with its relationship to the common ancestor before running the command. The expected mechanism is: Independent changes from current and other are combined relative to base. For the revision notes, add one near-miss that exposes passing files in chronological or alphabetical order rather than semantic roles. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers passing files in chronological or alphabetical order rather than semantic roles.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Label each file with its relationship to the common ancestor before running the command.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from Three roles define the merge?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing passing files in chronological or alphabetical order rather than semantic roles be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny transport guide with combining station notes edited from a common draft. Include one ordinary case, one boundary and one deliberate failure caused by passing files in chronological or alphabetical order rather than semantic roles. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The arguments are current, base and other; the tool compares both sides with the base to decide what changed. It shows a trace, not only a final value. The ordinary case should demonstrate “Independent changes from current and other are combined relative to base.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Label each file with its relationship to the common ancestor before running the command. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Three roles define the merge, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
Without an output option, the merged result replaces the first pathname. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is experimenting on the only copy of schoolwork and expecting an automatic backup. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Copy fixtures into a disposable directory and verify hashes before and after.
For the The current file is overwritten by default chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on experimenting on the only copy of schoolwork and expecting an automatic backup. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file ours.txt base.txt theirs.txtExplained result. ours.txt becomes the merge output, while the base and other pathnames are inputs. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: science report. Contrast the rule using reconciling independent edits around one baseline paragraph. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Without an output option, the merged result replaces the first pathname.” Apply this procedure: Copy fixtures into a disposable directory and verify hashes before and after. The expected mechanism is: ours.txt becomes the merge output, while the base and other pathnames are inputs. For the science report, add one near-miss that exposes experimenting on the only copy of schoolwork and expecting an automatic backup. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: revision notes. Stress-test the rule using joining additions to different sections of one topic file. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Without an output option, the merged result replaces the first pathname.” Apply this procedure: Copy fixtures into a disposable directory and verify hashes before and after. The expected mechanism is: ours.txt becomes the merge output, while the base and other pathnames are inputs. For the revision notes, add one near-miss that exposes experimenting on the only copy of schoolwork and expecting an automatic backup. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family checklist. Explain the rule using resolving overlapping changes to one shared list. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Without an output option, the merged result replaces the first pathname.” Apply this procedure: Copy fixtures into a disposable directory and verify hashes before and after. The expected mechanism is: ours.txt becomes the merge output, while the base and other pathnames are inputs. For the family checklist, add one near-miss that exposes experimenting on the only copy of schoolwork and expecting an automatic backup. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: transport guide. Transfer the rule using combining station notes edited from a common draft. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Without an output option, the merged result replaces the first pathname.” Apply this procedure: Copy fixtures into a disposable directory and verify hashes before and after. The expected mechanism is: ours.txt becomes the merge output, while the base and other pathnames are inputs. For the transport guide, add one near-miss that exposes experimenting on the only copy of schoolwork and expecting an automatic backup. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers experimenting on the only copy of schoolwork and expecting an automatic backup.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Copy fixtures into a disposable directory and verify hashes before and after.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from The current file is overwritten by default?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing experimenting on the only copy of schoolwork and expecting an automatic backup be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny project configuration with merging nearby key-value edits with validation afterward. Include one ordinary case, one boundary and one deliberate failure caused by experimenting on the only copy of schoolwork and expecting an automatic backup. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: Without an output option, the merged result replaces the first pathname. It shows a trace, not only a final value. The ordinary case should demonstrate “ours.txt becomes the merge output, while the base and other pathnames are inputs.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Copy fixtures into a disposable directory and verify hashes before and after. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For The current file is overwritten by default, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
The –stdout option writes the merge result to standard output instead of replacing the current file. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is redirecting stdout back onto the same input path and defeating the safety benefit. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Send output to a new path, inspect it, then replace deliberately if correct.
For the –stdout preserves input paths chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on redirecting stdout back onto the same input path and defeating the safety benefit. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file --stdout ours base theirs > merged.txtExplained result. merged.txt receives the result and the three input files remain available for comparison. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family checklist. Stress-test the rule using resolving overlapping changes to one shared list. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The –stdout option writes the merge result to standard output instead of replacing the current file.” Apply this procedure: Send output to a new path, inspect it, then replace deliberately if correct. The expected mechanism is: merged.txt receives the result and the three input files remain available for comparison. For the family checklist, add one near-miss that exposes redirecting stdout back onto the same input path and defeating the safety benefit. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: transport guide. Explain the rule using combining station notes edited from a common draft. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The –stdout option writes the merge result to standard output instead of replacing the current file.” Apply this procedure: Send output to a new path, inspect it, then replace deliberately if correct. The expected mechanism is: merged.txt receives the result and the three input files remain available for comparison. For the transport guide, add one near-miss that exposes redirecting stdout back onto the same input path and defeating the safety benefit. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: project configuration. Transfer the rule using merging nearby key-value edits with validation afterward. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The –stdout option writes the merge result to standard output instead of replacing the current file.” Apply this procedure: Send output to a new path, inspect it, then replace deliberately if correct. The expected mechanism is: merged.txt receives the result and the three input files remain available for comparison. For the project configuration, add one near-miss that exposes redirecting stdout back onto the same input path and defeating the safety benefit. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: repository rehearsal. Predict the rule using testing labels, conflict style, output mode and exit status safely. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The –stdout option writes the merge result to standard output instead of replacing the current file.” Apply this procedure: Send output to a new path, inspect it, then replace deliberately if correct. The expected mechanism is: merged.txt receives the result and the three input files remain available for comparison. For the repository rehearsal, add one near-miss that exposes redirecting stdout back onto the same input path and defeating the safety benefit. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers redirecting stdout back onto the same input path and defeating the safety benefit.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Send output to a new path, inspect it, then replace deliberately if correct.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from –stdout preserves input paths?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing redirecting stdout back onto the same input path and defeating the safety benefit be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny repository rehearsal with testing labels, conflict style, output mode and exit status safely. Include one ordinary case, one boundary and one deliberate failure caused by redirecting stdout back onto the same input path and defeating the safety benefit. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The –stdout option writes the merge result to standard output instead of replacing the current file. It shows a trace, not only a final value. The ordinary case should demonstrate “merged.txt receives the result and the three input files remain available for comparison.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Send output to a new path, inspect it, then replace deliberately if correct. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For –stdout preserves input paths, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
When the two sides change separate regions relative to the base, the algorithm can usually include both. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is assuming every edit by two people must cause a conflict. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Create changes in distant paragraphs and compare the merged result with a hand-written expectation.
For the Independent edits can merge cleanly chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming every edit by two people must cause a conflict. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file --stdout current base otherExplained result. A zero exit status and both intended edits indicate a clean textual merge, still subject to semantic review. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: project configuration. Explain the rule using merging nearby key-value edits with validation afterward. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “When the two sides change separate regions relative to the base, the algorithm can usually include both.” Apply this procedure: Create changes in distant paragraphs and compare the merged result with a hand-written expectation. The expected mechanism is: A zero exit status and both intended edits indicate a clean textual merge, still subject to semantic review. For the project configuration, add one near-miss that exposes assuming every edit by two people must cause a conflict. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: repository rehearsal. Transfer the rule using testing labels, conflict style, output mode and exit status safely. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “When the two sides change separate regions relative to the base, the algorithm can usually include both.” Apply this procedure: Create changes in distant paragraphs and compare the merged result with a hand-written expectation. The expected mechanism is: A zero exit status and both intended edits indicate a clean textual merge, still subject to semantic review. For the repository rehearsal, add one near-miss that exposes assuming every edit by two people must cause a conflict. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: homework outline. Predict the rule using combining two edits made from one shared essay plan. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “When the two sides change separate regions relative to the base, the algorithm can usually include both.” Apply this procedure: Create changes in distant paragraphs and compare the merged result with a hand-written expectation. The expected mechanism is: A zero exit status and both intended edits indicate a clean textual merge, still subject to semantic review. For the homework outline, add one near-miss that exposes assuming every edit by two people must cause a conflict. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: CCA programme. Contrast the rule using merging timetable wording changed by two organisers. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “When the two sides change separate regions relative to the base, the algorithm can usually include both.” Apply this procedure: Create changes in distant paragraphs and compare the merged result with a hand-written expectation. The expected mechanism is: A zero exit status and both intended edits indicate a clean textual merge, still subject to semantic review. For the CCA programme, add one near-miss that exposes assuming every edit by two people must cause a conflict. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers assuming every edit by two people must cause a conflict.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Create changes in distant paragraphs and compare the merged result with a hand-written expectation.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from Independent edits can merge cleanly?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming every edit by two people must cause a conflict be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny homework outline with combining two edits made from one shared essay plan. Include one ordinary case, one boundary and one deliberate failure caused by assuming every edit by two people must cause a conflict. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: When the two sides change separate regions relative to the base, the algorithm can usually include both. It shows a trace, not only a final value. The ordinary case should demonstrate “A zero exit status and both intended edits indicate a clean textual merge, still subject to semantic review.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Create changes in distant paragraphs and compare the merged result with a hand-written expectation. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Independent edits can merge cleanly, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
When both sides change the same base region incompatibly, markers preserve competing text for a person to resolve. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is choosing one side blindly because the file contains markers. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Read current, base and other around the hunk and write a resolved version that preserves intent.
For the Overlapping edits create conflict hunks chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on choosing one side blindly because the file contains markers. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file --stdout current base otherExplained result. The output contains a conflict region and the command reports conflicts through its status. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: homework outline. Transfer the rule using combining two edits made from one shared essay plan. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “When both sides change the same base region incompatibly, markers preserve competing text for a person to resolve.” Apply this procedure: Read current, base and other around the hunk and write a resolved version that preserves intent. The expected mechanism is: The output contains a conflict region and the command reports conflicts through its status. For the homework outline, add one near-miss that exposes choosing one side blindly because the file contains markers. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: CCA programme. Predict the rule using merging timetable wording changed by two organisers. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “When both sides change the same base region incompatibly, markers preserve competing text for a person to resolve.” Apply this procedure: Read current, base and other around the hunk and write a resolved version that preserves intent. The expected mechanism is: The output contains a conflict region and the command reports conflicts through its status. For the CCA programme, add one near-miss that exposes choosing one side blindly because the file contains markers. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: science report. Contrast the rule using reconciling independent edits around one baseline paragraph. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “When both sides change the same base region incompatibly, markers preserve competing text for a person to resolve.” Apply this procedure: Read current, base and other around the hunk and write a resolved version that preserves intent. The expected mechanism is: The output contains a conflict region and the command reports conflicts through its status. For the science report, add one near-miss that exposes choosing one side blindly because the file contains markers. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: revision notes. Stress-test the rule using joining additions to different sections of one topic file. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “When both sides change the same base region incompatibly, markers preserve competing text for a person to resolve.” Apply this procedure: Read current, base and other around the hunk and write a resolved version that preserves intent. The expected mechanism is: The output contains a conflict region and the command reports conflicts through its status. For the revision notes, add one near-miss that exposes choosing one side blindly because the file contains markers. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers choosing one side blindly because the file contains markers.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Read current, base and other around the hunk and write a resolved version that preserves intent.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from Overlapping edits create conflict hunks?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing choosing one side blindly because the file contains markers be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny CCA programme with merging timetable wording changed by two organisers. Include one ordinary case, one boundary and one deliberate failure caused by choosing one side blindly because the file contains markers. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: When both sides change the same base region incompatibly, markers preserve competing text for a person to resolve. It shows a trace, not only a final value. The ordinary case should demonstrate “The output contains a conflict region and the command reports conflicts through its status.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Read current, base and other around the hunk and write a resolved version that preserves intent. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Overlapping edits create conflict hunks, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
Ordinary conflict output marks the current and other sections so their competing text is visible. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is reading the top marker as automatically newer or more correct. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Map marker sections to the first and third arguments using a tiny fixture.
For the Default markers show two sides chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on reading the top marker as automatically newer or more correct. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
<<<<<<< current
our text
=======
their text
>>>>>>> otherExplained result. The upper section comes from current and the lower section comes from other. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: science report. Predict the rule using reconciling independent edits around one baseline paragraph. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Ordinary conflict output marks the current and other sections so their competing text is visible.” Apply this procedure: Map marker sections to the first and third arguments using a tiny fixture. The expected mechanism is: The upper section comes from current and the lower section comes from other. For the science report, add one near-miss that exposes reading the top marker as automatically newer or more correct. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: revision notes. Contrast the rule using joining additions to different sections of one topic file. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Ordinary conflict output marks the current and other sections so their competing text is visible.” Apply this procedure: Map marker sections to the first and third arguments using a tiny fixture. The expected mechanism is: The upper section comes from current and the lower section comes from other. For the revision notes, add one near-miss that exposes reading the top marker as automatically newer or more correct. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family checklist. Stress-test the rule using resolving overlapping changes to one shared list. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Ordinary conflict output marks the current and other sections so their competing text is visible.” Apply this procedure: Map marker sections to the first and third arguments using a tiny fixture. The expected mechanism is: The upper section comes from current and the lower section comes from other. For the family checklist, add one near-miss that exposes reading the top marker as automatically newer or more correct. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: transport guide. Explain the rule using combining station notes edited from a common draft. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Ordinary conflict output marks the current and other sections so their competing text is visible.” Apply this procedure: Map marker sections to the first and third arguments using a tiny fixture. The expected mechanism is: The upper section comes from current and the lower section comes from other. For the transport guide, add one near-miss that exposes reading the top marker as automatically newer or more correct. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers reading the top marker as automatically newer or more correct.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Map marker sections to the first and third arguments using a tiny fixture.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from Default markers show two sides?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing reading the top marker as automatically newer or more correct be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny science report with reconciling independent edits around one baseline paragraph. Include one ordinary case, one boundary and one deliberate failure caused by reading the top marker as automatically newer or more correct. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: Ordinary conflict output marks the current and other sections so their competing text is visible. It shows a trace, not only a final value. The ordinary case should demonstrate “The upper section comes from current and the lower section comes from other.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Map marker sections to the first and third arguments using a tiny fixture. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Default markers show two sides, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
The diff3 conflict style adds the common-base section, helping a learner see what each side changed. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is treating the base as a third proposal to keep rather than evidence of prior state. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compare each side with the base before composing a resolution.
For the –diff3 exposes the base chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on treating the base as a third proposal to keep rather than evidence of prior state. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file --diff3 --stdout current base otherExplained result. A conflict hunk includes current, base and other sections with three-way evidence. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family checklist. Contrast the rule using resolving overlapping changes to one shared list. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The diff3 conflict style adds the common-base section, helping a learner see what each side changed.” Apply this procedure: Compare each side with the base before composing a resolution. The expected mechanism is: A conflict hunk includes current, base and other sections with three-way evidence. For the family checklist, add one near-miss that exposes treating the base as a third proposal to keep rather than evidence of prior state. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: transport guide. Stress-test the rule using combining station notes edited from a common draft. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The diff3 conflict style adds the common-base section, helping a learner see what each side changed.” Apply this procedure: Compare each side with the base before composing a resolution. The expected mechanism is: A conflict hunk includes current, base and other sections with three-way evidence. For the transport guide, add one near-miss that exposes treating the base as a third proposal to keep rather than evidence of prior state. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: project configuration. Explain the rule using merging nearby key-value edits with validation afterward. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The diff3 conflict style adds the common-base section, helping a learner see what each side changed.” Apply this procedure: Compare each side with the base before composing a resolution. The expected mechanism is: A conflict hunk includes current, base and other sections with three-way evidence. For the project configuration, add one near-miss that exposes treating the base as a third proposal to keep rather than evidence of prior state. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: repository rehearsal. Transfer the rule using testing labels, conflict style, output mode and exit status safely. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The diff3 conflict style adds the common-base section, helping a learner see what each side changed.” Apply this procedure: Compare each side with the base before composing a resolution. The expected mechanism is: A conflict hunk includes current, base and other sections with three-way evidence. For the repository rehearsal, add one near-miss that exposes treating the base as a third proposal to keep rather than evidence of prior state. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers treating the base as a third proposal to keep rather than evidence of prior state.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Compare each side with the base before composing a resolution.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from –diff3 exposes the base?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating the base as a third proposal to keep rather than evidence of prior state be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny revision notes with joining additions to different sections of one topic file. Include one ordinary case, one boundary and one deliberate failure caused by treating the base as a third proposal to keep rather than evidence of prior state. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The diff3 conflict style adds the common-base section, helping a learner see what each side changed. It shows a trace, not only a final value. The ordinary case should demonstrate “A conflict hunk includes current, base and other sections with three-way evidence.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Compare each side with the base before composing a resolution. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For –diff3 exposes the base, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
The zdiff3 style can remove matching lines from the conflict sides and place common material outside markers, making the disagreement smaller. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is assuming a smaller hunk means less semantic risk. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Review surrounding context and validate the resolved file exactly as with a larger marker block.
For the –zdiff3 compacts shared context chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming a smaller hunk means less semantic risk. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file --zdiff3 --stdout current base otherExplained result. The conflict presentation is compact, but the underlying disagreement still requires a decision. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: project configuration. Stress-test the rule using merging nearby key-value edits with validation afterward. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The zdiff3 style can remove matching lines from the conflict sides and place common material outside markers, making the disagreement smaller.” Apply this procedure: Review surrounding context and validate the resolved file exactly as with a larger marker block. The expected mechanism is: The conflict presentation is compact, but the underlying disagreement still requires a decision. For the project configuration, add one near-miss that exposes assuming a smaller hunk means less semantic risk. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: repository rehearsal. Explain the rule using testing labels, conflict style, output mode and exit status safely. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The zdiff3 style can remove matching lines from the conflict sides and place common material outside markers, making the disagreement smaller.” Apply this procedure: Review surrounding context and validate the resolved file exactly as with a larger marker block. The expected mechanism is: The conflict presentation is compact, but the underlying disagreement still requires a decision. For the repository rehearsal, add one near-miss that exposes assuming a smaller hunk means less semantic risk. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: homework outline. Transfer the rule using combining two edits made from one shared essay plan. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The zdiff3 style can remove matching lines from the conflict sides and place common material outside markers, making the disagreement smaller.” Apply this procedure: Review surrounding context and validate the resolved file exactly as with a larger marker block. The expected mechanism is: The conflict presentation is compact, but the underlying disagreement still requires a decision. For the homework outline, add one near-miss that exposes assuming a smaller hunk means less semantic risk. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: CCA programme. Predict the rule using merging timetable wording changed by two organisers. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The zdiff3 style can remove matching lines from the conflict sides and place common material outside markers, making the disagreement smaller.” Apply this procedure: Review surrounding context and validate the resolved file exactly as with a larger marker block. The expected mechanism is: The conflict presentation is compact, but the underlying disagreement still requires a decision. For the CCA programme, add one near-miss that exposes assuming a smaller hunk means less semantic risk. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers assuming a smaller hunk means less semantic risk.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Review surrounding context and validate the resolved file exactly as with a larger marker block.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from –zdiff3 compacts shared context?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming a smaller hunk means less semantic risk be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny family checklist with resolving overlapping changes to one shared list. Include one ordinary case, one boundary and one deliberate failure caused by assuming a smaller hunk means less semantic risk. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The zdiff3 style can remove matching lines from the conflict sides and place common material outside markers, making the disagreement smaller. It shows a trace, not only a final value. The ordinary case should demonstrate “The conflict presentation is compact, but the underlying disagreement still requires a decision.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Review surrounding context and validate the resolved file exactly as with a larger marker block. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For –zdiff3 compacts shared context, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
The -L options replace default file labels in conflict markers and can clarify roles or branch names. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is supplying one label and assuming the rest are inferred as intended. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Pass three labels in current, base, other order and inspect a forced conflict.
For the Labels make markers intelligible chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on supplying one label and assuming the rest are inferred as intended. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file -L topic -L common -L teammate --diff3 current base otherExplained result. The markers identify the three semantic roles with the chosen names. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: homework outline. Explain the rule using combining two edits made from one shared essay plan. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The -L options replace default file labels in conflict markers and can clarify roles or branch names.” Apply this procedure: Pass three labels in current, base, other order and inspect a forced conflict. The expected mechanism is: The markers identify the three semantic roles with the chosen names. For the homework outline, add one near-miss that exposes supplying one label and assuming the rest are inferred as intended. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: CCA programme. Transfer the rule using merging timetable wording changed by two organisers. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The -L options replace default file labels in conflict markers and can clarify roles or branch names.” Apply this procedure: Pass three labels in current, base, other order and inspect a forced conflict. The expected mechanism is: The markers identify the three semantic roles with the chosen names. For the CCA programme, add one near-miss that exposes supplying one label and assuming the rest are inferred as intended. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: science report. Predict the rule using reconciling independent edits around one baseline paragraph. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The -L options replace default file labels in conflict markers and can clarify roles or branch names.” Apply this procedure: Pass three labels in current, base, other order and inspect a forced conflict. The expected mechanism is: The markers identify the three semantic roles with the chosen names. For the science report, add one near-miss that exposes supplying one label and assuming the rest are inferred as intended. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: revision notes. Contrast the rule using joining additions to different sections of one topic file. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The -L options replace default file labels in conflict markers and can clarify roles or branch names.” Apply this procedure: Pass three labels in current, base, other order and inspect a forced conflict. The expected mechanism is: The markers identify the three semantic roles with the chosen names. For the revision notes, add one near-miss that exposes supplying one label and assuming the rest are inferred as intended. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers supplying one label and assuming the rest are inferred as intended.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Pass three labels in current, base, other order and inspect a forced conflict.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from Labels make markers intelligible?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing supplying one label and assuming the rest are inferred as intended be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny transport guide with combining station notes edited from a common draft. Include one ordinary case, one boundary and one deliberate failure caused by supplying one label and assuming the rest are inferred as intended. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The -L options replace default file labels in conflict markers and can clarify roles or branch names. It shows a trace, not only a final value. The ordinary case should demonstrate “The markers identify the three semantic roles with the chosen names.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Pass three labels in current, base, other order and inspect a forced conflict. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Labels make markers intelligible, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
A marker-size option can make delimiter lines longer when nested examples or surrounding text might be confusing. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is changing marker size as though it improved merge accuracy. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Choose a size for readability and keep algorithmic expectations unchanged.
For the Marker size is a presentation choice chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on changing marker size as though it improved merge accuracy. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file --marker-size=12 --stdout current base otherExplained result. The delimiter width changes; the merge inputs and conflict decision do not. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: science report. Transfer the rule using reconciling independent edits around one baseline paragraph. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “A marker-size option can make delimiter lines longer when nested examples or surrounding text might be confusing.” Apply this procedure: Choose a size for readability and keep algorithmic expectations unchanged. The expected mechanism is: The delimiter width changes; the merge inputs and conflict decision do not. For the science report, add one near-miss that exposes changing marker size as though it improved merge accuracy. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: revision notes. Predict the rule using joining additions to different sections of one topic file. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “A marker-size option can make delimiter lines longer when nested examples or surrounding text might be confusing.” Apply this procedure: Choose a size for readability and keep algorithmic expectations unchanged. The expected mechanism is: The delimiter width changes; the merge inputs and conflict decision do not. For the revision notes, add one near-miss that exposes changing marker size as though it improved merge accuracy. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family checklist. Contrast the rule using resolving overlapping changes to one shared list. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “A marker-size option can make delimiter lines longer when nested examples or surrounding text might be confusing.” Apply this procedure: Choose a size for readability and keep algorithmic expectations unchanged. The expected mechanism is: The delimiter width changes; the merge inputs and conflict decision do not. For the family checklist, add one near-miss that exposes changing marker size as though it improved merge accuracy. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: transport guide. Stress-test the rule using combining station notes edited from a common draft. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “A marker-size option can make delimiter lines longer when nested examples or surrounding text might be confusing.” Apply this procedure: Choose a size for readability and keep algorithmic expectations unchanged. The expected mechanism is: The delimiter width changes; the merge inputs and conflict decision do not. For the transport guide, add one near-miss that exposes changing marker size as though it improved merge accuracy. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers changing marker size as though it improved merge accuracy.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Choose a size for readability and keep algorithmic expectations unchanged.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from Marker size is a presentation choice?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing changing marker size as though it improved merge accuracy be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny project configuration with merging nearby key-value edits with validation afterward. Include one ordinary case, one boundary and one deliberate failure caused by changing marker size as though it improved merge accuracy. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: A marker-size option can make delimiter lines longer when nested examples or surrounding text might be confusing. It shows a trace, not only a final value. The ordinary case should demonstrate “The delimiter width changes; the merge inputs and conflict decision do not.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Choose a size for readability and keep algorithmic expectations unchanged. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Marker size is a presentation choice, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
The ours option resolves conflicting regions in favour of the current file while still combining non-conflicting changes. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is using ours as a synonym for copy the whole first file or as a substitute for review. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Force one conflict plus one independent change and inspect both regions.
For the –ours favours current conflicts chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using ours as a synonym for copy the whole first file or as a substitute for review. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file --ours --stdout current base otherExplained result. The conflicting hunk uses current, while a separate non-conflicting edit from other may still appear. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family checklist. Predict the rule using resolving overlapping changes to one shared list. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The ours option resolves conflicting regions in favour of the current file while still combining non-conflicting changes.” Apply this procedure: Force one conflict plus one independent change and inspect both regions. The expected mechanism is: The conflicting hunk uses current, while a separate non-conflicting edit from other may still appear. For the family checklist, add one near-miss that exposes using ours as a synonym for copy the whole first file or as a substitute for review. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: transport guide. Contrast the rule using combining station notes edited from a common draft. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The ours option resolves conflicting regions in favour of the current file while still combining non-conflicting changes.” Apply this procedure: Force one conflict plus one independent change and inspect both regions. The expected mechanism is: The conflicting hunk uses current, while a separate non-conflicting edit from other may still appear. For the transport guide, add one near-miss that exposes using ours as a synonym for copy the whole first file or as a substitute for review. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: project configuration. Stress-test the rule using merging nearby key-value edits with validation afterward. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The ours option resolves conflicting regions in favour of the current file while still combining non-conflicting changes.” Apply this procedure: Force one conflict plus one independent change and inspect both regions. The expected mechanism is: The conflicting hunk uses current, while a separate non-conflicting edit from other may still appear. For the project configuration, add one near-miss that exposes using ours as a synonym for copy the whole first file or as a substitute for review. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: repository rehearsal. Explain the rule using testing labels, conflict style, output mode and exit status safely. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The ours option resolves conflicting regions in favour of the current file while still combining non-conflicting changes.” Apply this procedure: Force one conflict plus one independent change and inspect both regions. The expected mechanism is: The conflicting hunk uses current, while a separate non-conflicting edit from other may still appear. For the repository rehearsal, add one near-miss that exposes using ours as a synonym for copy the whole first file or as a substitute for review. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers using ours as a synonym for copy the whole first file or as a substitute for review.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Force one conflict plus one independent change and inspect both regions.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from –ours favours current conflicts?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using ours as a synonym for copy the whole first file or as a substitute for review be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny repository rehearsal with testing labels, conflict style, output mode and exit status safely. Include one ordinary case, one boundary and one deliberate failure caused by using ours as a synonym for copy the whole first file or as a substitute for review. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The ours option resolves conflicting regions in favour of the current file while still combining non-conflicting changes. It shows a trace, not only a final value. The ordinary case should demonstrate “The conflicting hunk uses current, while a separate non-conflicting edit from other may still appear.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Force one conflict plus one independent change and inspect both regions. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For –ours favours current conflicts, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
The theirs option selects the other side for conflict regions without turning the command into a whole-file replacement. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is assuming the label theirs refers to a branch in every invocation. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Tie the word to the third argument of this exact command and test a fixture.
For the –theirs favours other conflicts chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming the label theirs refers to a branch in every invocation. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file --theirs --stdout current base otherExplained result. The other side wins conflicting hunks, but the complete output remains a three-way merge. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: project configuration. Contrast the rule using merging nearby key-value edits with validation afterward. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The theirs option selects the other side for conflict regions without turning the command into a whole-file replacement.” Apply this procedure: Tie the word to the third argument of this exact command and test a fixture. The expected mechanism is: The other side wins conflicting hunks, but the complete output remains a three-way merge. For the project configuration, add one near-miss that exposes assuming the label theirs refers to a branch in every invocation. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: repository rehearsal. Stress-test the rule using testing labels, conflict style, output mode and exit status safely. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The theirs option selects the other side for conflict regions without turning the command into a whole-file replacement.” Apply this procedure: Tie the word to the third argument of this exact command and test a fixture. The expected mechanism is: The other side wins conflicting hunks, but the complete output remains a three-way merge. For the repository rehearsal, add one near-miss that exposes assuming the label theirs refers to a branch in every invocation. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: homework outline. Explain the rule using combining two edits made from one shared essay plan. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The theirs option selects the other side for conflict regions without turning the command into a whole-file replacement.” Apply this procedure: Tie the word to the third argument of this exact command and test a fixture. The expected mechanism is: The other side wins conflicting hunks, but the complete output remains a three-way merge. For the homework outline, add one near-miss that exposes assuming the label theirs refers to a branch in every invocation. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: CCA programme. Transfer the rule using merging timetable wording changed by two organisers. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The theirs option selects the other side for conflict regions without turning the command into a whole-file replacement.” Apply this procedure: Tie the word to the third argument of this exact command and test a fixture. The expected mechanism is: The other side wins conflicting hunks, but the complete output remains a three-way merge. For the CCA programme, add one near-miss that exposes assuming the label theirs refers to a branch in every invocation. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers assuming the label theirs refers to a branch in every invocation.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Tie the word to the third argument of this exact command and test a fixture.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from –theirs favours other conflicts?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming the label theirs refers to a branch in every invocation be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny homework outline with combining two edits made from one shared essay plan. Include one ordinary case, one boundary and one deliberate failure caused by assuming the label theirs refers to a branch in every invocation. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The theirs option selects the other side for conflict regions without turning the command into a whole-file replacement. It shows a trace, not only a final value. The ordinary case should demonstrate “The other side wins conflicting hunks, but the complete output remains a three-way merge.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Tie the word to the third argument of this exact command and test a fixture. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For –theirs favours other conflicts, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
The union option includes lines from both sides in conflicting regions, usually without conflict markers. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is accepting duplicated or contradictory lines because the command returned a combined result. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use union only when the file format and content make concatenation meaningful, then validate.
For the –union keeps both conflict sides chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on accepting duplicated or contradictory lines because the command returned a combined result. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file --union --stdout current base otherExplained result. Both alternatives may appear, and their order or duplication can still be wrong for the domain. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: homework outline. Stress-test the rule using combining two edits made from one shared essay plan. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The union option includes lines from both sides in conflicting regions, usually without conflict markers.” Apply this procedure: Use union only when the file format and content make concatenation meaningful, then validate. The expected mechanism is: Both alternatives may appear, and their order or duplication can still be wrong for the domain. For the homework outline, add one near-miss that exposes accepting duplicated or contradictory lines because the command returned a combined result. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: CCA programme. Explain the rule using merging timetable wording changed by two organisers. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The union option includes lines from both sides in conflicting regions, usually without conflict markers.” Apply this procedure: Use union only when the file format and content make concatenation meaningful, then validate. The expected mechanism is: Both alternatives may appear, and their order or duplication can still be wrong for the domain. For the CCA programme, add one near-miss that exposes accepting duplicated or contradictory lines because the command returned a combined result. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: science report. Transfer the rule using reconciling independent edits around one baseline paragraph. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The union option includes lines from both sides in conflicting regions, usually without conflict markers.” Apply this procedure: Use union only when the file format and content make concatenation meaningful, then validate. The expected mechanism is: Both alternatives may appear, and their order or duplication can still be wrong for the domain. For the science report, add one near-miss that exposes accepting duplicated or contradictory lines because the command returned a combined result. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: revision notes. Predict the rule using joining additions to different sections of one topic file. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The union option includes lines from both sides in conflicting regions, usually without conflict markers.” Apply this procedure: Use union only when the file format and content make concatenation meaningful, then validate. The expected mechanism is: Both alternatives may appear, and their order or duplication can still be wrong for the domain. For the revision notes, add one near-miss that exposes accepting duplicated or contradictory lines because the command returned a combined result. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers accepting duplicated or contradictory lines because the command returned a combined result.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Use union only when the file format and content make concatenation meaningful, then validate.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from –union keeps both conflict sides?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing accepting duplicated or contradictory lines because the command returned a combined result be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny CCA programme with merging timetable wording changed by two organisers. Include one ordinary case, one boundary and one deliberate failure caused by accepting duplicated or contradictory lines because the command returned a combined result. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The union option includes lines from both sides in conflicting regions, usually without conflict markers. It shows a trace, not only a final value. The ordinary case should demonstrate “Both alternatives may appear, and their order or duplication can still be wrong for the domain.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use union only when the file format and content make concatenation meaningful, then validate. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For –union keeps both conflict sides, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
A clean merge reports success, conflicts produce a positive status up to the documented cap, and trouble such as invalid input reports an error status. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is checking only whether an output file exists. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Capture the status immediately and branch the workflow before using the output.
For the Exit status carries conflict information chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on checking only whether an output file exists. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file --stdout current base other >merged; status=$?Explained result. The status distinguishes clean output, conflicted output and command failure. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: science report. Explain the rule using reconciling independent edits around one baseline paragraph. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “A clean merge reports success, conflicts produce a positive status up to the documented cap, and trouble such as invalid input reports an error status.” Apply this procedure: Capture the status immediately and branch the workflow before using the output. The expected mechanism is: The status distinguishes clean output, conflicted output and command failure. For the science report, add one near-miss that exposes checking only whether an output file exists. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: revision notes. Transfer the rule using joining additions to different sections of one topic file. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “A clean merge reports success, conflicts produce a positive status up to the documented cap, and trouble such as invalid input reports an error status.” Apply this procedure: Capture the status immediately and branch the workflow before using the output. The expected mechanism is: The status distinguishes clean output, conflicted output and command failure. For the revision notes, add one near-miss that exposes checking only whether an output file exists. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family checklist. Predict the rule using resolving overlapping changes to one shared list. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “A clean merge reports success, conflicts produce a positive status up to the documented cap, and trouble such as invalid input reports an error status.” Apply this procedure: Capture the status immediately and branch the workflow before using the output. The expected mechanism is: The status distinguishes clean output, conflicted output and command failure. For the family checklist, add one near-miss that exposes checking only whether an output file exists. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: transport guide. Contrast the rule using combining station notes edited from a common draft. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “A clean merge reports success, conflicts produce a positive status up to the documented cap, and trouble such as invalid input reports an error status.” Apply this procedure: Capture the status immediately and branch the workflow before using the output. The expected mechanism is: The status distinguishes clean output, conflicted output and command failure. For the transport guide, add one near-miss that exposes checking only whether an output file exists. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers checking only whether an output file exists.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Capture the status immediately and branch the workflow before using the output.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from Exit status carries conflict information?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing checking only whether an output file exists be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny science report with reconciling independent edits around one baseline paragraph. Include one ordinary case, one boundary and one deliberate failure caused by checking only whether an output file exists. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: A clean merge reports success, conflicts produce a positive status up to the documented cap, and trouble such as invalid input reports an error status. It shows a trace, not only a final value. The ordinary case should demonstrate “The status distinguishes clean output, conflicted output and command failure.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Capture the status immediately and branch the workflow before using the output. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Exit status carries conflict information, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 15 OF 20 . Debug and verify
15. Binary or unsuitable files need another strategy
Three-way line merging is designed for textual content and is not a general semantic merger for images, archives or generated formats. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is forcing an opaque file through a line merge because Git accepts pathnames. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Identify file type and choose a format-aware tool or one authoritative source.
For the Binary or unsuitable files need another strategy chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on forcing an opaque file through a line merge because Git accepts pathnames. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
file current.binExplained result. The diagnostic informs tool choice; it does not make binary content safely mergeable. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family checklist. Transfer the rule using resolving overlapping changes to one shared list. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Three-way line merging is designed for textual content and is not a general semantic merger for images, archives or generated formats.” Apply this procedure: Identify file type and choose a format-aware tool or one authoritative source. The expected mechanism is: The diagnostic informs tool choice; it does not make binary content safely mergeable. For the family checklist, add one near-miss that exposes forcing an opaque file through a line merge because Git accepts pathnames. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: transport guide. Predict the rule using combining station notes edited from a common draft. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Three-way line merging is designed for textual content and is not a general semantic merger for images, archives or generated formats.” Apply this procedure: Identify file type and choose a format-aware tool or one authoritative source. The expected mechanism is: The diagnostic informs tool choice; it does not make binary content safely mergeable. For the transport guide, add one near-miss that exposes forcing an opaque file through a line merge because Git accepts pathnames. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: project configuration. Contrast the rule using merging nearby key-value edits with validation afterward. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Three-way line merging is designed for textual content and is not a general semantic merger for images, archives or generated formats.” Apply this procedure: Identify file type and choose a format-aware tool or one authoritative source. The expected mechanism is: The diagnostic informs tool choice; it does not make binary content safely mergeable. For the project configuration, add one near-miss that exposes forcing an opaque file through a line merge because Git accepts pathnames. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: repository rehearsal. Stress-test the rule using testing labels, conflict style, output mode and exit status safely. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Three-way line merging is designed for textual content and is not a general semantic merger for images, archives or generated formats.” Apply this procedure: Identify file type and choose a format-aware tool or one authoritative source. The expected mechanism is: The diagnostic informs tool choice; it does not make binary content safely mergeable. For the repository rehearsal, add one near-miss that exposes forcing an opaque file through a line merge because Git accepts pathnames. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers forcing an opaque file through a line merge because Git accepts pathnames.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Identify file type and choose a format-aware tool or one authoritative source.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from Binary or unsuitable files need another strategy?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing forcing an opaque file through a line merge because Git accepts pathnames be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny revision notes with joining additions to different sections of one topic file. Include one ordinary case, one boundary and one deliberate failure caused by forcing an opaque file through a line merge because Git accepts pathnames. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: Three-way line merging is designed for textual content and is not a general semantic merger for images, archives or generated formats. It shows a trace, not only a final value. The ordinary case should demonstrate “The diagnostic informs tool choice; it does not make binary content safely mergeable.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Identify file type and choose a format-aware tool or one authoritative source. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Binary or unsuitable files need another strategy, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
The diff-algorithm option can select myers, minimal, patience or histogram while the three-way roles stay unchanged. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is changing algorithms until a conflict disappears and treating that as proof of semantic correctness. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Run the same fixture with a documented algorithm, compare outputs and still validate meaning.
For the Diff algorithm is an explicit option chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on changing algorithms until a conflict disappears and treating that as proof of semantic correctness. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file --diff-algorithm=histogram --stdout current base otherExplained result. Histogram can change how matching regions are aligned, while current, base and other retain their roles. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: project configuration. Predict the rule using merging nearby key-value edits with validation afterward. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The diff-algorithm option can select myers, minimal, patience or histogram while the three-way roles stay unchanged.” Apply this procedure: Run the same fixture with a documented algorithm, compare outputs and still validate meaning. The expected mechanism is: Histogram can change how matching regions are aligned, while current, base and other retain their roles. For the project configuration, add one near-miss that exposes changing algorithms until a conflict disappears and treating that as proof of semantic correctness. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: repository rehearsal. Contrast the rule using testing labels, conflict style, output mode and exit status safely. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The diff-algorithm option can select myers, minimal, patience or histogram while the three-way roles stay unchanged.” Apply this procedure: Run the same fixture with a documented algorithm, compare outputs and still validate meaning. The expected mechanism is: Histogram can change how matching regions are aligned, while current, base and other retain their roles. For the repository rehearsal, add one near-miss that exposes changing algorithms until a conflict disappears and treating that as proof of semantic correctness. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: homework outline. Stress-test the rule using combining two edits made from one shared essay plan. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The diff-algorithm option can select myers, minimal, patience or histogram while the three-way roles stay unchanged.” Apply this procedure: Run the same fixture with a documented algorithm, compare outputs and still validate meaning. The expected mechanism is: Histogram can change how matching regions are aligned, while current, base and other retain their roles. For the homework outline, add one near-miss that exposes changing algorithms until a conflict disappears and treating that as proof of semantic correctness. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: CCA programme. Explain the rule using merging timetable wording changed by two organisers. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The diff-algorithm option can select myers, minimal, patience or histogram while the three-way roles stay unchanged.” Apply this procedure: Run the same fixture with a documented algorithm, compare outputs and still validate meaning. The expected mechanism is: Histogram can change how matching regions are aligned, while current, base and other retain their roles. For the CCA programme, add one near-miss that exposes changing algorithms until a conflict disappears and treating that as proof of semantic correctness. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers changing algorithms until a conflict disappears and treating that as proof of semantic correctness.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Run the same fixture with a documented algorithm, compare outputs and still validate meaning.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from Diff algorithm is an explicit option?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing changing algorithms until a conflict disappears and treating that as proof of semantic correctness be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny family checklist with resolving overlapping changes to one shared list. Include one ordinary case, one boundary and one deliberate failure caused by changing algorithms until a conflict disappears and treating that as proof of semantic correctness. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The diff-algorithm option can select myers, minimal, patience or histogram while the three-way roles stay unchanged. It shows a trace, not only a final value. The ordinary case should demonstrate “Histogram can change how matching regions are aligned, while current, base and other retain their roles.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Run the same fixture with a documented algorithm, compare outputs and still validate meaning. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Diff algorithm is an explicit option, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
With –object-id, the arguments are blob object IDs and successful output names a resulting blob, which is a plumbing workflow rather than pathname editing. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is mixing pathnames and object IDs or assuming the working file was updated. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Verify tool support, hash three blobs and inspect the returned object explicitly.
For the Object mode changes inputs and output chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on mixing pathnames and object IDs or assuming the working file was updated. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git merge-file --object-id current_oid base_oid other_oidExplained result. The command works in the object database and returns an object ID rather than overwriting a pathname. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: homework outline. Contrast the rule using combining two edits made from one shared essay plan. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “With –object-id, the arguments are blob object IDs and successful output names a resulting blob, which is a plumbing workflow rather than pathname editing.” Apply this procedure: Verify tool support, hash three blobs and inspect the returned object explicitly. The expected mechanism is: The command works in the object database and returns an object ID rather than overwriting a pathname. For the homework outline, add one near-miss that exposes mixing pathnames and object IDs or assuming the working file was updated. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: CCA programme. Stress-test the rule using merging timetable wording changed by two organisers. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “With –object-id, the arguments are blob object IDs and successful output names a resulting blob, which is a plumbing workflow rather than pathname editing.” Apply this procedure: Verify tool support, hash three blobs and inspect the returned object explicitly. The expected mechanism is: The command works in the object database and returns an object ID rather than overwriting a pathname. For the CCA programme, add one near-miss that exposes mixing pathnames and object IDs or assuming the working file was updated. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: science report. Explain the rule using reconciling independent edits around one baseline paragraph. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “With –object-id, the arguments are blob object IDs and successful output names a resulting blob, which is a plumbing workflow rather than pathname editing.” Apply this procedure: Verify tool support, hash three blobs and inspect the returned object explicitly. The expected mechanism is: The command works in the object database and returns an object ID rather than overwriting a pathname. For the science report, add one near-miss that exposes mixing pathnames and object IDs or assuming the working file was updated. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: revision notes. Transfer the rule using joining additions to different sections of one topic file. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “With –object-id, the arguments are blob object IDs and successful output names a resulting blob, which is a plumbing workflow rather than pathname editing.” Apply this procedure: Verify tool support, hash three blobs and inspect the returned object explicitly. The expected mechanism is: The command works in the object database and returns an object ID rather than overwriting a pathname. For the revision notes, add one near-miss that exposes mixing pathnames and object IDs or assuming the working file was updated. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers mixing pathnames and object IDs or assuming the working file was updated.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Verify tool support, hash three blobs and inspect the returned object explicitly.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from Object mode changes inputs and output?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing mixing pathnames and object IDs or assuming the working file was updated be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny transport guide with combining station notes edited from a common draft. Include one ordinary case, one boundary and one deliberate failure caused by mixing pathnames and object IDs or assuming the working file was updated. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: With –object-id, the arguments are blob object IDs and successful output names a resulting blob, which is a plumbing workflow rather than pathname editing. It shows a trace, not only a final value. The ordinary case should demonstrate “The command works in the object database and returns an object ID rather than overwriting a pathname.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Verify tool support, hash three blobs and inspect the returned object explicitly. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Object mode changes inputs and output, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
Automatic merging detects compatible text edits, not contradictions in meaning, invalid syntax or broken project rules. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is shipping a zero-conflict result without tests or human review. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Run the file parser, tests and a domain checklist after every meaningful merge.
For the Clean text can still be wrong chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on shipping a zero-conflict result without tests or human review. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git diff --no-index expected.txt merged.txtExplained result. A clean textual merge becomes trustworthy only after its meaning and format are validated. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: science report. Stress-test the rule using reconciling independent edits around one baseline paragraph. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Automatic merging detects compatible text edits, not contradictions in meaning, invalid syntax or broken project rules.” Apply this procedure: Run the file parser, tests and a domain checklist after every meaningful merge. The expected mechanism is: A clean textual merge becomes trustworthy only after its meaning and format are validated. For the science report, add one near-miss that exposes shipping a zero-conflict result without tests or human review. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: revision notes. Explain the rule using joining additions to different sections of one topic file. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Automatic merging detects compatible text edits, not contradictions in meaning, invalid syntax or broken project rules.” Apply this procedure: Run the file parser, tests and a domain checklist after every meaningful merge. The expected mechanism is: A clean textual merge becomes trustworthy only after its meaning and format are validated. For the revision notes, add one near-miss that exposes shipping a zero-conflict result without tests or human review. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family checklist. Transfer the rule using resolving overlapping changes to one shared list. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Automatic merging detects compatible text edits, not contradictions in meaning, invalid syntax or broken project rules.” Apply this procedure: Run the file parser, tests and a domain checklist after every meaningful merge. The expected mechanism is: A clean textual merge becomes trustworthy only after its meaning and format are validated. For the family checklist, add one near-miss that exposes shipping a zero-conflict result without tests or human review. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: transport guide. Predict the rule using combining station notes edited from a common draft. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Automatic merging detects compatible text edits, not contradictions in meaning, invalid syntax or broken project rules.” Apply this procedure: Run the file parser, tests and a domain checklist after every meaningful merge. The expected mechanism is: A clean textual merge becomes trustworthy only after its meaning and format are validated. For the transport guide, add one near-miss that exposes shipping a zero-conflict result without tests or human review. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers shipping a zero-conflict result without tests or human review.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Run the file parser, tests and a domain checklist after every meaningful merge.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from Clean text can still be wrong?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing shipping a zero-conflict result without tests or human review be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny project configuration with merging nearby key-value edits with validation afterward. Include one ordinary case, one boundary and one deliberate failure caused by shipping a zero-conflict result without tests or human review. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: Automatic merging detects compatible text edits, not contradictions in meaning, invalid syntax or broken project rules. It shows a trace, not only a final value. The ordinary case should demonstrate “A clean textual merge becomes trustworthy only after its meaning and format are validated.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Run the file parser, tests and a domain checklist after every meaningful merge. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Clean text can still be wrong, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 19 OF 20 . Transfer with judgment
19. A fixture matrix builds reliable intuition
Useful tests cover clean independent edits, identical edits, one-sided edits, overlap, insertion at the same point, deletion and malformed input. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is memorising one marker example and generalising to every file. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Generate tiny named fixtures and assert output, labels and status for each case.
For the A fixture matrix builds reliable intuition chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on memorising one marker example and generalising to every file. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
for case in clean conflict delete insert; do ./check-case "$case"; doneExplained result. The matrix reveals exactly which boundary changes the merge from clean to conflicted. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family checklist. Explain the rule using resolving overlapping changes to one shared list. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Useful tests cover clean independent edits, identical edits, one-sided edits, overlap, insertion at the same point, deletion and malformed input.” Apply this procedure: Generate tiny named fixtures and assert output, labels and status for each case. The expected mechanism is: The matrix reveals exactly which boundary changes the merge from clean to conflicted. For the family checklist, add one near-miss that exposes memorising one marker example and generalising to every file. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: transport guide. Transfer the rule using combining station notes edited from a common draft. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Useful tests cover clean independent edits, identical edits, one-sided edits, overlap, insertion at the same point, deletion and malformed input.” Apply this procedure: Generate tiny named fixtures and assert output, labels and status for each case. The expected mechanism is: The matrix reveals exactly which boundary changes the merge from clean to conflicted. For the transport guide, add one near-miss that exposes memorising one marker example and generalising to every file. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: project configuration. Predict the rule using merging nearby key-value edits with validation afterward. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Useful tests cover clean independent edits, identical edits, one-sided edits, overlap, insertion at the same point, deletion and malformed input.” Apply this procedure: Generate tiny named fixtures and assert output, labels and status for each case. The expected mechanism is: The matrix reveals exactly which boundary changes the merge from clean to conflicted. For the project configuration, add one near-miss that exposes memorising one marker example and generalising to every file. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: repository rehearsal. Contrast the rule using testing labels, conflict style, output mode and exit status safely. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Useful tests cover clean independent edits, identical edits, one-sided edits, overlap, insertion at the same point, deletion and malformed input.” Apply this procedure: Generate tiny named fixtures and assert output, labels and status for each case. The expected mechanism is: The matrix reveals exactly which boundary changes the merge from clean to conflicted. For the repository rehearsal, add one near-miss that exposes memorising one marker example and generalising to every file. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers memorising one marker example and generalising to every file.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Generate tiny named fixtures and assert output, labels and status for each case.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from A fixture matrix builds reliable intuition?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing memorising one marker example and generalising to every file be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny repository rehearsal with testing labels, conflict style, output mode and exit status safely. Include one ordinary case, one boundary and one deliberate failure caused by memorising one marker example and generalising to every file. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: Useful tests cover clean independent edits, identical edits, one-sided edits, overlap, insertion at the same point, deletion and malformed input. It shows a trace, not only a final value. The ordinary case should demonstrate “The matrix reveals exactly which boundary changes the merge from clean to conflicted.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Generate tiny named fixtures and assert output, labels and status for each case. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For A fixture matrix builds reliable intuition, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 20 OF 20 . Transfer with judgment
20. Choose merge-file for a narrow three-way job
Use it when three file versions and their common base are known, textual merging is appropriate and output plus status will be reviewed safely. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is using the plumbing command when the real job is a branch merge, patch application or collaborative editor. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State roles, output destination, conflict style, validation and recovery before execution.
For the Choose merge-file for a narrow three-way job chapter on Git merge-file, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using the plumbing command when the real job is a branch merge, patch application or collaborative editor. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
plan={current:'ours',base:'ancestor',other:'peer',output:'new-file'}Explained result. A written plan makes a destructive-by-default tool controlled, reviewable and recoverable. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: project configuration. Transfer the rule using merging nearby key-value edits with validation afterward. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Use it when three file versions and their common base are known, textual merging is appropriate and output plus status will be reviewed safely.” Apply this procedure: State roles, output destination, conflict style, validation and recovery before execution. The expected mechanism is: A written plan makes a destructive-by-default tool controlled, reviewable and recoverable. For the project configuration, add one near-miss that exposes using the plumbing command when the real job is a branch merge, patch application or collaborative editor. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: repository rehearsal. Predict the rule using testing labels, conflict style, output mode and exit status safely. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Use it when three file versions and their common base are known, textual merging is appropriate and output plus status will be reviewed safely.” Apply this procedure: State roles, output destination, conflict style, validation and recovery before execution. The expected mechanism is: A written plan makes a destructive-by-default tool controlled, reviewable and recoverable. For the repository rehearsal, add one near-miss that exposes using the plumbing command when the real job is a branch merge, patch application or collaborative editor. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: homework outline. Contrast the rule using combining two edits made from one shared essay plan. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Use it when three file versions and their common base are known, textual merging is appropriate and output plus status will be reviewed safely.” Apply this procedure: State roles, output destination, conflict style, validation and recovery before execution. The expected mechanism is: A written plan makes a destructive-by-default tool controlled, reviewable and recoverable. For the homework outline, add one near-miss that exposes using the plumbing command when the real job is a branch merge, patch application or collaborative editor. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: CCA programme. Stress-test the rule using merging timetable wording changed by two organisers. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “Use it when three file versions and their common base are known, textual merging is appropriate and output plus status will be reviewed safely.” Apply this procedure: State roles, output destination, conflict style, validation and recovery before execution. The expected mechanism is: A written plan makes a destructive-by-default tool controlled, reviewable and recoverable. For the CCA programme, add one near-miss that exposes using the plumbing command when the real job is a branch merge, patch application or collaborative editor. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers using the plumbing command when the real job is a branch merge, patch application or collaborative editor.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “State roles, output destination, conflict style, validation and recovery before execution.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git merge-file syntax. For this chapter, useful prompts are: “What did you expect from Choose merge-file for a narrow three-way job?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using the plumbing command when the real job is a branch merge, patch application or collaborative editor be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny homework outline with combining two edits made from one shared essay plan. Include one ordinary case, one boundary and one deliberate failure caused by using the plumbing command when the real job is a branch merge, patch application or collaborative editor. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: Use it when three file versions and their common base are known, textual merging is appropriate and output plus status will be reviewed safely. It shows a trace, not only a final value. The ordinary case should demonstrate “A written plan makes a destructive-by-default tool controlled, reviewable and recoverable.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: State roles, output destination, conflict style, validation and recovery before execution. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Choose merge-file for a narrow three-way job, separate the documented Git merge-file mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
Parent guide: choose the next useful step
Start with evidence, not a label such as careless. Ask for one prediction and one trace. If the first transition is wrong, rebuild the model. If the model is sound but syntax fails, practise reference use. If routine cases are correct but boundaries fail, vary ties, defaults, unsupported inputs, ownership or missing paths. If explanations transfer, move to a small project.
Keep a weekly record with four lines: concept, prediction, observed difference and next test. Stop when fatigue replaces reasoning. A smaller case tomorrow is more useful than another hour of copying tonight.
Seek specialist help when cause and effect remain invisible after examples are reduced, when accessibility or data-loss implications are unclear, or when an important repository, database or application state may be at risk. Good support should make the learner’s reasoning more independent.
Capstone practice with explained routes
1. homework outline: model, boundary and recovery
Create a small homework outline using combining two edits made from one shared essay plan. Combine “Three roles define the merge” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: The arguments are current, base and other; the tool compares both sides with the base to decide what changed. Apply: Label each file with its relationship to the common ancestor before running the command. Verify: Independent changes from current and other are combined relative to base. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
2. CCA programme: model, boundary and recovery
Create a small CCA programme using merging timetable wording changed by two organisers. Combine “Independent edits can merge cleanly” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: When the two sides change separate regions relative to the base, the algorithm can usually include both. Apply: Create changes in distant paragraphs and compare the merged result with a hand-written expectation. Verify: A zero exit status and both intended edits indicate a clean textual merge, still subject to semantic review. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
3. science report: model, boundary and recovery
Create a small science report using reconciling independent edits around one baseline paragraph. Combine “–diff3 exposes the base” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: The diff3 conflict style adds the common-base section, helping a learner see what each side changed. Apply: Compare each side with the base before composing a resolution. Verify: A conflict hunk includes current, base and other sections with three-way evidence. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
4. revision notes: model, boundary and recovery
Create a small revision notes using joining additions to different sections of one topic file. Combine “Marker size is a presentation choice” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: A marker-size option can make delimiter lines longer when nested examples or surrounding text might be confusing. Apply: Choose a size for readability and keep algorithmic expectations unchanged. Verify: The delimiter width changes; the merge inputs and conflict decision do not. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
5. family checklist: model, boundary and recovery
Create a small family checklist using resolving overlapping changes to one shared list. Combine “–union keeps both conflict sides” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: The union option includes lines from both sides in conflicting regions, usually without conflict markers. Apply: Use union only when the file format and content make concatenation meaningful, then validate. Verify: Both alternatives may appear, and their order or duplication can still be wrong for the domain. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
6. transport guide: model, boundary and recovery
Create a small transport guide using combining station notes edited from a common draft. Combine “Diff algorithm is an explicit option” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: The diff-algorithm option can select myers, minimal, patience or histogram while the three-way roles stay unchanged. Apply: Run the same fixture with a documented algorithm, compare outputs and still validate meaning. Verify: Histogram can change how matching regions are aligned, while current, base and other retain their roles. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
7. project configuration: model, boundary and recovery
Create a small project configuration using merging nearby key-value edits with validation afterward. Combine “A fixture matrix builds reliable intuition” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: Useful tests cover clean independent edits, identical edits, one-sided edits, overlap, insertion at the same point, deletion and malformed input. Apply: Generate tiny named fixtures and assert output, labels and status for each case. Verify: The matrix reveals exactly which boundary changes the merge from clean to conflicted. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
8. repository rehearsal: model, boundary and recovery
Create a small repository rehearsal using testing labels, conflict style, output mode and exit status safely. Combine “The current file is overwritten by default” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: Without an output option, the merged result replaces the first pathname. Apply: Copy fixtures into a disposable directory and verify hashes before and after. Verify: ours.txt becomes the merge output, while the base and other pathnames are inputs. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
Frequently asked questions
How long should a practice session be?
Use one complete prediction–observation–explanation cycle while attention remains good. Ten to twenty focused minutes can be enough.
Should every option or function be memorised?
No. Memorise the governing distinctions and practise retrieving the official reference. Understanding means predicting and explaining, not reciting a parameter list.
What if the result is correct but the explanation is weak?
Treat it as partial success. Ask for a trace and change one boundary. A reliable model survives controlled variation.
Is the shortest solution the best?
Not automatically. Prefer the solution whose semantics, failure modes and maintenance cost are easiest to justify for the actual project.
When should official documentation be used?
Use it whenever syntax, supported types, SQL dialect behaviour or Git version details matter. Primary documentation settles the current contract.
How can a parent help without technical expertise?
Ask what was predicted, where the first difference appeared, what evidence matters and which smaller example could isolate it.
How do we test transfer?
Change the context, vocabulary and one boundary. Require the learner to identify the invariant before using a tool.
What should be saved after practice?
Keep the corrected rule, one trace, one boundary case and the next question. Avoid storing pages of unexplained output.
Can these exercises replace backups?
No. Use disposable examples and proper backups. Learning should not endanger schoolwork, repositories or personal data.
What counts as mastery?
The learner can predict, verify, diagnose, recover and justify a choice across more than one context, while knowing when to consult the current reference.
