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-base finds best common ancestor commits in the history graph. A common ancestor is better than another when the latter is an ancestor of the former, and more than one best base can exist. This graph operation underlies three-way comparisons, ancestry checks and several branch workflows, but it does not tell a story about developer intent, create a merge or guarantee that the most recent-looking date is the right base. Mastery means drawing parent edges, handling multiple or missing results, distinguishing ordinary ancestry from reflog-assisted fork-point recovery, and treating exit status and repository completeness as evidence. 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.

git merge-base works on commit parent relationships and returns a best common ancestor, not the nearest timestamp, matching message or directory snapshot. 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 looking at dates or branch names and guessing where histories split. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Draw commits as nodes with arrows to parents, mark ancestors of both tips and remove any common ancestor dominated by a better one.

For the A merge base is a graph result chapter on Git merge-base, 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 looking at dates or branch names and guessing where histories split. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git merge-base main topic

Four purposeful transfer cases

Case 1: school coding project. Predict the rule using main, report and experiment branches with ordinary divergence. 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.

Case 2: CCA website. Contrast the rule using a feature branch rebased after the remote-tracking branch moved. 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.

Case 3: group assignment. Stress-test the rule using parallel merges that produce a criss-cross ancestry pattern. 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.

Case 4: documentation repo. Explain the rule using release, translation and correction branches compared before integration. 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.

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 looking at dates or branch names and guessing where histories split.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Draw commits as nodes with arrows to parents, mark ancestors of both tips and remove any common ancestor dominated by a better one.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from A merge base is a graph result?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing looking at dates or branch names and guessing where histories split be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny revision repository with shallow clone whose missing parents change what ancestry is visible. Include one ordinary case, one boundary and one deliberate failure caused by looking at dates or branch names and guessing where histories split. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For A merge base is a graph result, separate the documented Git merge-base 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 commit is common to A and B when following zero or more parent edges from each tip can reach it. 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 equal files or identical patches as proof two commits share ancestry. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use rev-list or log graph to trace parent reachability independently of file contents.

For the Common ancestor means reachable from both tips chapter on Git merge-base, 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 equal files or identical patches as proof two commits share ancestry. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git rev-list --ancestry-path $(git merge-base main topic)..topic

Four purposeful transfer cases

Case 1: group assignment. Contrast the rule using parallel merges that produce a criss-cross ancestry pattern. 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.

Case 2: documentation repo. Stress-test the rule using release, translation and correction branches compared before integration. 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.

Case 3: robotics project. Explain the rule using several topic tips reduced to independent work lines. 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.

Case 4: revision repository. Transfer the rule using shallow clone whose missing parents change what ancestry is visible. 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.

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 equal files or identical patches as proof two commits share ancestry.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Use rev-list or log graph to trace parent reachability independently of file contents.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from Common ancestor means reachable from both tips?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating equal files or identical patches as proof two commits share ancestry be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. Include one ordinary case, one boundary and one deliberate failure caused by treating equal files or identical patches as proof two commits share ancestry. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Common ancestor means reachable from both tips, separate the documented Git merge-base 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 common ancestor is better than another when the older candidate is an ancestor of the newer candidate; a best base is undominated among common ancestors. 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 the oldest common root because it is shared by everything. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. List all common candidates in a drawn graph and cross out each candidate that is ancestor of another common candidate.

For the Best means no better common ancestor exists chapter on Git merge-base, 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 the oldest common root because it is shared by everything. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

base=$(git merge-base main topic)
git show -s --format='%H %P' "$base"

Four purposeful transfer cases

Case 1: robotics project. Stress-test the rule using several topic tips reduced to independent work lines. 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.

Case 2: revision repository. Explain the rule using shallow clone whose missing parents change what ancestry is visible. 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.

Case 3: test laboratory. Transfer the rule using ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. 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.

Case 4: design review. Predict the rule using merge-base compared with fork-point, three-dot diff and merge-tree inputs. 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.

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 the oldest common root because it is shared by everything.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “List all common candidates in a drawn graph and cross out each candidate that is ancestor of another common candidate.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from Best means no better common ancestor exists?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing choosing the oldest common root because it is shared by everything be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design review with merge-base compared with fork-point, three-dot diff and merge-tree inputs. Include one ordinary case, one boundary and one deliberate failure caused by choosing the oldest common root because it is shared by everything. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Best means no better common ancestor exists, separate the documented Git merge-base 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

If A is an ancestor of B, the best common ancestor of A and B is A itself; no separate fork commit is required. 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 expecting merge-base always to name a commit strictly before both arguments. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Create a linear three-commit history and query the first and third commits.

For the An ancestor tip can be its own merge base chapter on Git merge-base, 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 expecting merge-base always to name a commit strictly before both arguments. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git merge-base HEAD~2 HEAD

Four purposeful transfer cases

Case 1: test laboratory. Explain the rule using ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. 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.

Case 2: design review. Transfer the rule using merge-base compared with fork-point, three-dot diff and merge-tree inputs. 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.

Case 3: school coding project. Predict the rule using main, report and experiment branches with ordinary divergence. 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.

Case 4: CCA website. Contrast the rule using a feature branch rebased after the remote-tracking branch moved. 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.

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 expecting merge-base always to name a commit strictly before both arguments.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Create a linear three-commit history and query the first and third commits.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from An ancestor tip can be its own merge base?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting merge-base always to name a commit strictly before both arguments be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny school coding project with main, report and experiment branches with ordinary divergence. Include one ordinary case, one boundary and one deliberate failure caused by expecting merge-base always to name a commit strictly before both arguments. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For An ancestor tip can be its own merge base, separate the documented Git merge-base 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

In an ordinary fork where main and topic each add commits after one shared parent, that shared parent is the unique best common ancestor. 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 calling the base the last commit created before the branch command without checking later merges. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Construct the smallest diverged graph, label parent edges and verify the hash from both histories.

For the Diverged branches return their latest shared ancestry chapter on Git merge-base, 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 calling the base the last commit created before the branch command without checking later merges. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git log --graph --oneline --decorate --all
git merge-base --all main topic

Four purposeful transfer cases

Case 1: school coding project. Transfer the rule using main, report and experiment branches with ordinary divergence. 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.

Case 2: CCA website. Predict the rule using a feature branch rebased after the remote-tracking branch moved. 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.

Case 3: group assignment. Contrast the rule using parallel merges that produce a criss-cross ancestry pattern. 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.

Case 4: documentation repo. Stress-test the rule using release, translation and correction branches compared before integration. 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.

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 calling the base the last commit created before the branch command without checking later merges.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Construct the smallest diverged graph, label parent edges and verify the hash from both histories.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from Diverged branches return their latest shared ancestry?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing calling the base the last commit created before the branch command without checking later merges be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA website with a feature branch rebased after the remote-tracking branch moved. Include one ordinary case, one boundary and one deliberate failure caused by calling the base the last commit created before the branch command without checking later merges. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Diverged branches return their latest shared ancestry, separate the documented Git merge-base 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 criss-cross merging, two common ancestors can be incomparable, so neither is better and both are valid merge bases. 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 writing a script that silently accepts one arbitrary base when semantics require every best base. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use –all, count output lines and build an explicit policy for zero, one or many bases.

For the Criss-cross histories can have multiple best bases chapter on Git merge-base, 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 writing a script that silently accepts one arbitrary base when semantics require every best base. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

mapfile -t bases < <(git merge-base --all left right)
printf '%s
' "${#bases[@]}"

Four purposeful transfer cases

Case 1: group assignment. Predict the rule using parallel merges that produce a criss-cross ancestry pattern. 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.

Case 2: documentation repo. Contrast the rule using release, translation and correction branches compared before integration. 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.

Case 3: robotics project. Stress-test the rule using several topic tips reduced to independent work lines. 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.

Case 4: revision repository. Explain the rule using shallow clone whose missing parents change what ancestry is visible. 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.

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 writing a script that silently accepts one arbitrary base when semantics require every best base.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Use –all, count output lines and build an explicit policy for zero, one or many bases.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from Criss-cross histories can have multiple best bases?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing writing a script that silently accepts one arbitrary base when semantics require every best base be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny group assignment with parallel merges that produce a criss-cross ancestry pattern. Include one ordinary case, one boundary and one deliberate failure caused by writing a script that silently accepts one arbitrary base when semantics require every best base. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Criss-cross histories can have multiple best bases, separate the documented Git merge-base 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 –all, merge-base may output one best base when several exist; –all requests all merge bases. 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 believing default single-line output proves uniqueness. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Run both forms on a rehearsed criss-cross repository and compare sets, not only the first line.

For the –all preserves every best answer chapter on Git merge-base, 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 believing default single-line output proves uniqueness. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git merge-base left right
git merge-base --all left right

Four purposeful transfer cases

Case 1: robotics project. Contrast the rule using several topic tips reduced to independent work lines. 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.

Case 2: revision repository. Stress-test the rule using shallow clone whose missing parents change what ancestry is visible. 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.

Case 3: test laboratory. Explain the rule using ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. 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.

Case 4: design review. Transfer the rule using merge-base compared with fork-point, three-dot diff and merge-tree inputs. 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.

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 believing default single-line output proves uniqueness.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Run both forms on a rehearsed criss-cross repository and compare sets, not only the first line.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from –all preserves every best answer?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing believing default single-line output proves uniqueness be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny documentation repo with release, translation and correction branches compared before integration. Include one ordinary case, one boundary and one deliberate failure caused by believing default single-line output proves uniqueness. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For –all preserves every best answer, separate the documented Git merge-base 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 two commits, merge-base directly computes their best common ancestors and is the safest form for teaching ordinary divergence. 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 generalising the two-argument mental model unchanged to an arbitrary argument list. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Master two-tip graphs first, then state the documented hypothetical-merge rule before adding a third commit.

For the Two arguments are the clearest special case chapter on Git merge-base, 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 generalising the two-argument mental model unchanged to an arbitrary argument list. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git merge-base --all A B

Four purposeful transfer cases

Case 1: test laboratory. Stress-test the rule using ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. 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.

Case 2: design review. Explain the rule using merge-base compared with fork-point, three-dot diff and merge-tree inputs. 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.

Case 3: school coding project. Transfer the rule using main, report and experiment branches with ordinary divergence. 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.

Case 4: CCA website. Predict the rule using a feature branch rebased after the remote-tracking branch moved. 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.

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 generalising the two-argument mental model unchanged to an arbitrary argument list.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Master two-tip graphs first, then state the documented hypothetical-merge rule before adding a third commit.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from Two arguments are the clearest special case?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing generalising the two-argument mental model unchanged to an arbitrary argument list be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny robotics project with several topic tips reduced to independent work lines. Include one ordinary case, one boundary and one deliberate failure caused by generalising the two-argument mental model unchanged to an arbitrary argument list. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Two arguments are the clearest special case, separate the documented Git merge-base 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

In the general multi-argument form, the first commit is compared with a hypothetical merge of the remaining commits, so the result need not be contained in every remaining argument. 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 git merge-base A B C means intersection of ancestors of all three tips. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compare the general form with –octopus on a graph designed so their results differ.

For the More than two arguments use a hypothetical merge chapter on Git merge-base, 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 git merge-base A B C means intersection of ancestors of all three tips. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git merge-base A B C
git merge-base --octopus A B C

Four purposeful transfer cases

Case 1: school coding project. Explain the rule using main, report and experiment branches with ordinary divergence. 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.

Case 2: CCA website. Transfer the rule using a feature branch rebased after the remote-tracking branch moved. 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.

Case 3: group assignment. Predict the rule using parallel merges that produce a criss-cross ancestry pattern. 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.

Case 4: documentation repo. Contrast the rule using release, translation and correction branches compared before integration. 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.

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 git merge-base A B C means intersection of ancestors of all three tips.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Compare the general form with –octopus on a graph designed so their results differ.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from More than two arguments use a hypothetical merge?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming git merge-base A B C means intersection of ancestors of all three tips be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny revision repository with shallow clone whose missing parents change what ancestry is visible. Include one ordinary case, one boundary and one deliberate failure caused by assuming git merge-base A B C means intersection of ancestors of all three tips. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For More than two arguments use a hypothetical merge, separate the documented Git merge-base 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 –octopus mode computes best common ancestors of all supplied commits in preparation for an n-way merge. 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 repeated pairwise merge-base calls and assuming the order cannot affect the reduced answer. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Draw the full graph and compare one –octopus call with several pairwise reductions.

For the –octopus finds bases for an n-way merge chapter on Git merge-base, 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 repeated pairwise merge-base calls and assuming the order cannot affect the reduced answer. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git merge-base --octopus main topic-a topic-b

Four purposeful transfer cases

Case 1: group assignment. Transfer the rule using parallel merges that produce a criss-cross ancestry pattern. 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.

Case 2: documentation repo. Predict the rule using release, translation and correction branches compared before integration. 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.

Case 3: robotics project. Contrast the rule using several topic tips reduced to independent work lines. 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.

Case 4: revision repository. Stress-test the rule using shallow clone whose missing parents change what ancestry is visible. 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.

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 repeated pairwise merge-base calls and assuming the order cannot affect the reduced answer.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Draw the full graph and compare one –octopus call with several pairwise reductions.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from –octopus finds bases for an n-way merge?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using repeated pairwise merge-base calls and assuming the order cannot affect the reduced answer be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. Include one ordinary case, one boundary and one deliberate failure caused by using repeated pairwise merge-base calls and assuming the order cannot affect the reduced answer. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For –octopus finds bases for an n-way merge, separate the documented Git merge-base 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

git merge-base –is-ancestor A B exits 0 when A is an ancestor of B and 1 when it is not, normally producing no explanatory hash. 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 parsing stdout or treating every nonzero status as the ordinary false case. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Capture the exit code immediately and distinguish 1 from other errors such as an invalid revision.

For the –is-ancestor answers reachability through status chapter on Git merge-base, 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 parsing stdout or treating every nonzero status as the ordinary false case. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

if git merge-base --is-ancestor release main; then
  echo reachable
else
  status=$?; echo "status=$status"
fi

Four purposeful transfer cases

Case 1: robotics project. Predict the rule using several topic tips reduced to independent work lines. 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.

Case 2: revision repository. Contrast the rule using shallow clone whose missing parents change what ancestry is visible. 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.

Case 3: test laboratory. Stress-test the rule using ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. 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.

Case 4: design review. Explain the rule using merge-base compared with fork-point, three-dot diff and merge-tree inputs. 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.

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 parsing stdout or treating every nonzero status as the ordinary false case.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Capture the exit code immediately and distinguish 1 from other errors such as an invalid revision.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from –is-ancestor answers reachability through status?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing parsing stdout or treating every nonzero status as the ordinary false case be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design review with merge-base compared with fork-point, three-dot diff and merge-tree inputs. Include one ordinary case, one boundary and one deliberate failure caused by parsing stdout or treating every nonzero status as the ordinary false case. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For –is-ancestor answers reachability through status, separate the documented Git merge-base 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 deployment or update gate can require the current release to be an ancestor of the proposed tip before allowing a fast-forward-only move. 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 comparing commit hashes directly and rejecting legitimate descendants. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Verify both revisions exist, run –is-ancestor and perform the actual update with its own fast-forward protection.

For the Ancestor tests make safer fast-forward gates chapter on Git merge-base, 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 comparing commit hashes directly and rejecting legitimate descendants. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git merge-base --is-ancestor refs/tags/release refs/remotes/origin/main
git merge --ff-only refs/remotes/origin/main

Four purposeful transfer cases

Case 1: test laboratory. Contrast the rule using ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. 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.

Case 2: design review. Stress-test the rule using merge-base compared with fork-point, three-dot diff and merge-tree inputs. 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.

Case 3: school coding project. Explain the rule using main, report and experiment branches with ordinary divergence. 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.

Case 4: CCA website. Transfer the rule using a feature branch rebased after the remote-tracking branch moved. 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.

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 comparing commit hashes directly and rejecting legitimate descendants.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Verify both revisions exist, run –is-ancestor and perform the actual update with its own fast-forward protection.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from Ancestor tests make safer fast-forward gates?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing comparing commit hashes directly and rejecting legitimate descendants be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny school coding project with main, report and experiment branches with ordinary divergence. Include one ordinary case, one boundary and one deliberate failure caused by comparing commit hashes directly and rejecting legitimate descendants. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Ancestor tests make safer fast-forward gates, separate the documented Git merge-base 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 –independent mode prints a minimal subset of supplied commits such that each output is not reachable from another output. 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 calling the output merge bases even though the mode returns selected tips rather than common ancestors. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Label every input tip, test pairwise reachability and compare the surviving maximal tips with command output.

For the –independent removes tips reachable from other tips chapter on Git merge-base, 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 calling the output merge bases even though the mode returns selected tips rather than common ancestors. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git merge-base --independent main feature-a feature-b archived-tip

Four purposeful transfer cases

Case 1: school coding project. Stress-test the rule using main, report and experiment branches with ordinary divergence. 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.

Case 2: CCA website. Explain the rule using a feature branch rebased after the remote-tracking branch moved. 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.

Case 3: group assignment. Transfer the rule using parallel merges that produce a criss-cross ancestry pattern. 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.

Case 4: documentation repo. Predict the rule using release, translation and correction branches compared before integration. 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.

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 calling the output merge bases even though the mode returns selected tips rather than common ancestors.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Label every input tip, test pairwise reachability and compare the surviving maximal tips with command 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-base syntax. For this chapter, useful prompts are: “What did you expect from –independent removes tips reachable from other tips?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing calling the output merge bases even though the mode returns selected tips rather than common ancestors be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA website with a feature branch rebased after the remote-tracking branch moved. Include one ordinary case, one boundary and one deliberate failure caused by calling the output merge bases even though the mode returns selected tips rather than common ancestors. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For –independent removes tips reachable from other tips, separate the documented Git merge-base 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 mode uses the current commit graph, while –fork-point also consults old tips recorded in the reflog of the upstream reference to locate where a topic was based before upstream rewrites. 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 fork-point for every branch and assuming it is a more accurate synonym. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Run both modes after a controlled upstream rebase and explain which evidence each mode is allowed to use.

For the Ordinary merge-base and fork-point answer different questions chapter on Git merge-base, 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 fork-point for every branch and assuming it is a more accurate synonym. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git merge-base origin/main topic
git merge-base --fork-point origin/main topic

Four purposeful transfer cases

Case 1: group assignment. Explain the rule using parallel merges that produce a criss-cross ancestry pattern. 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.

Case 2: documentation repo. Transfer the rule using release, translation and correction branches compared before integration. 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.

Case 3: robotics project. Predict the rule using several topic tips reduced to independent work lines. 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.

Case 4: revision repository. Contrast the rule using shallow clone whose missing parents change what ancestry is visible. 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.

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 fork-point for every branch and assuming it is a more accurate synonym.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Run both modes after a controlled upstream rebase and explain which evidence each mode is allowed to use.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from Ordinary merge-base and fork-point answer different questions?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using fork-point for every branch and assuming it is a more accurate synonym be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny group assignment with parallel merges that produce a criss-cross ancestry pattern. Include one ordinary case, one boundary and one deliberate failure caused by using fork-point for every branch and assuming it is a more accurate synonym. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Ordinary merge-base and fork-point answer different questions, separate the documented Git merge-base 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

Fork-point can only use old upstream tips still present in the relevant local reflog, so clones and reflog expiration can change availability. 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 writing a deployment script that assumes another machine has the same reflog history. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Inspect the exact remote-tracking reflog and specify a safe fallback when fork-point returns no commit.

For the –fork-point depends on local reflog evidence chapter on Git merge-base, 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 writing a deployment script that assumes another machine has the same reflog history. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git reflog show --date=iso origin/main
git merge-base --fork-point origin/main topic

Four purposeful transfer cases

Case 1: robotics project. Transfer the rule using several topic tips reduced to independent work lines. 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.

Case 2: revision repository. Predict the rule using shallow clone whose missing parents change what ancestry is visible. 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.

Case 3: test laboratory. Contrast the rule using ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. 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.

Case 4: design review. Stress-test the rule using merge-base compared with fork-point, three-dot diff and merge-tree inputs. 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.

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 writing a deployment script that assumes another machine has the same reflog history.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Inspect the exact remote-tracking reflog and specify a safe fallback when fork-point returns no commit.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from –fork-point depends on local reflog evidence?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing writing a deployment script that assumes another machine has the same reflog history be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny documentation repo with release, translation and correction branches compared before integration. Include one ordinary case, one boundary and one deliberate failure caused by writing a deployment script that assumes another machine has the same reflog history. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For –fork-point depends on local reflog evidence, separate the documented Git merge-base 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 relevant former tip is not in the reflog or the topic did not fork from an upstream tip, –fork-point may produce no result, avoiding a misleading arbitrary point. 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 falling back silently to HEAD~1 or the ordinary base and presenting it as the recovered fork. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Treat empty output as an explicit branch in the workflow and ask whether current ancestry or historical intent is required.

For the Fork-point can fail rather than invent an answer chapter on Git merge-base, 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 falling back silently to HEAD~1 or the ordinary base and presenting it as the recovered fork. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

fork=$(git merge-base --fork-point origin/main topic) || {
  echo 'fork point unavailable' >&2
  exit 1
}

Four purposeful transfer cases

Case 1: test laboratory. Predict the rule using ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. 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.

Case 2: design review. Contrast the rule using merge-base compared with fork-point, three-dot diff and merge-tree inputs. 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.

Case 3: school coding project. Stress-test the rule using main, report and experiment branches with ordinary divergence. 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.

Case 4: CCA website. Explain the rule using a feature branch rebased after the remote-tracking branch moved. 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.

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 falling back silently to HEAD~1 or the ordinary base and presenting it as the recovered fork.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Treat empty output as an explicit branch in the workflow and ask whether current ancestry or historical intent is required.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from Fork-point can fail rather than invent an answer?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing falling back silently to HEAD~1 or the ordinary base and presenting it as the recovered fork be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny robotics project with several topic tips reduced to independent work lines. Include one ordinary case, one boundary and one deliberate failure caused by falling back silently to HEAD~1 or the ordinary base and presenting it as the recovered fork. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Fork-point can fail rather than invent an answer, separate the documented Git merge-base 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

Commits rooted in separate histories have no merge base unless the visible graph contains a connection between them. 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 interpreting empty output as the empty-tree object or as the first commit from one side. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Check status and output separately on a disposable repository containing two orphan roots.

For the Unrelated histories have no common ancestor chapter on Git merge-base, 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 interpreting empty output as the empty-tree object or as the first commit from one side. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

if base=$(git merge-base root-a root-b); then
  echo "$base"
else
  echo 'no merge base'
fi

Four purposeful transfer cases

Case 1: school coding project. Contrast the rule using main, report and experiment branches with ordinary divergence. 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.

Case 2: CCA website. Stress-test the rule using a feature branch rebased after the remote-tracking branch moved. 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.

Case 3: group assignment. Explain the rule using parallel merges that produce a criss-cross ancestry pattern. 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.

Case 4: documentation repo. Transfer the rule using release, translation and correction branches compared before integration. 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.

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 interpreting empty output as the empty-tree object or as the first commit from one side.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Check status and output separately on a disposable repository containing two orphan roots.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from Unrelated histories have no common ancestor?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing interpreting empty output as the empty-tree object or as the first commit from one side be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny revision repository with shallow clone whose missing parents change what ancestry is visible. Include one ordinary case, one boundary and one deliberate failure caused by interpreting empty output as the empty-tree object or as the first commit from one side. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Unrelated histories have no common ancestor, separate the documented Git merge-base 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 shallow clone intentionally omits parent history beyond recorded boundaries, so reachability and merge-base results can be absent or different until enough history is fetched. 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 diagnosing remote branch corruption from a shallow client’s incomplete graph. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Inspect .git/shallow, reproduce in a full clone and deepen only as much as the task requires.

For the Shallow history can hide the real base chapter on Git merge-base, 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 diagnosing remote branch corruption from a shallow client’s incomplete graph. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git rev-parse --is-shallow-repository
git fetch --deepen=100 origin

Four purposeful transfer cases

Case 1: group assignment. Stress-test the rule using parallel merges that produce a criss-cross ancestry pattern. 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.

Case 2: documentation repo. Explain the rule using release, translation and correction branches compared before integration. 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.

Case 3: robotics project. Transfer the rule using several topic tips reduced to independent work lines. 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.

Case 4: revision repository. Predict the rule using shallow clone whose missing parents change what ancestry is visible. 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.

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 diagnosing remote branch corruption from a shallow client’s incomplete graph.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Inspect .git/shallow, reproduce in a full clone and deepen only as much as the task requires.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from Shallow history can hide the real base?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing diagnosing remote branch corruption from a shallow client’s incomplete graph be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. Include one ordinary case, one boundary and one deliberate failure caused by diagnosing remote branch corruption from a shallow client’s incomplete graph. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Shallow history can hide the real base, separate the documented Git merge-base 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 three-dot diff such as git diff A…B compares B with a merge base of A and B, so understanding base selection is essential before interpreting the patch. 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 describing three dots as all changes on both branches or confusing diff syntax with revision-walk syntax. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compute the base explicitly, run the equivalent two-endpoint diff and handle multiple bases consciously.

For the Three-dot comparisons depend on merge-base semantics chapter on Git merge-base, 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 describing three dots as all changes on both branches or confusing diff syntax with revision-walk syntax. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

base=$(git merge-base A B)
git diff "$base" B
git diff A...B

Four purposeful transfer cases

Case 1: robotics project. Explain the rule using several topic tips reduced to independent work lines. 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.

Case 2: revision repository. Transfer the rule using shallow clone whose missing parents change what ancestry is visible. 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.

Case 3: test laboratory. Predict the rule using ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. 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.

Case 4: design review. Contrast the rule using merge-base compared with fork-point, three-dot diff and merge-tree inputs. 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.

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 describing three dots as all changes on both branches or confusing diff syntax with revision-walk syntax.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Compute the base explicitly, run the equivalent two-endpoint diff and handle multiple bases consciously.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from Three-dot comparisons depend on merge-base semantics?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing describing three dots as all changes on both branches or confusing diff syntax with revision-walk syntax be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design review with merge-base compared with fork-point, three-dot diff and merge-tree inputs. Include one ordinary case, one boundary and one deliberate failure caused by describing three dots as all changes on both branches or confusing diff syntax with revision-walk syntax. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Three-dot comparisons depend on merge-base semantics, separate the documented Git merge-base 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

Safe merge-base scripting checks revision existence, captures exit status, requests –all when uniqueness matters, and records whether it used graph ancestry or reflog-assisted intent. 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 taking the first line of command substitution and using it in a destructive rebase without validation. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Resolve commits with rev-parse, collect all bases, require the expected cardinality and preview the downstream operation.

For the Robust automation validates revisions, cardinality and intent chapter on Git merge-base, 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 taking the first line of command substitution and using it in a destructive rebase without validation. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git rev-parse --verify A^{commit} B^{commit}
mapfile -t bases < <(git merge-base --all A B)
test "${#bases[@]}" -eq 1 || exit 2

Four purposeful transfer cases

Case 1: test laboratory. Transfer the rule using ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. 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.

Case 2: design review. Predict the rule using merge-base compared with fork-point, three-dot diff and merge-tree inputs. 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.

Case 3: school coding project. Contrast the rule using main, report and experiment branches with ordinary divergence. 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.

Case 4: CCA website. Stress-test the rule using a feature branch rebased after the remote-tracking branch moved. 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.

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 taking the first line of command substitution and using it in a destructive rebase without validation.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Resolve commits with rev-parse, collect all bases, require the expected cardinality and preview the downstream operation.” 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-base syntax. For this chapter, useful prompts are: “What did you expect from Robust automation validates revisions, cardinality and intent?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing taking the first line of command substitution and using it in a destructive rebase without validation be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny school coding project with main, report and experiment branches with ordinary divergence. Include one ordinary case, one boundary and one deliberate failure caused by taking the first line of command substitution and using it in a destructive rebase without validation. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Robust automation validates revisions, cardinality and intent, separate the documented Git merge-base 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

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.

1. school coding project: model, boundary and recovery

Create a small school coding project using main, report and experiment branches with ordinary divergence. Combine “A merge base is a graph result” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

2. CCA website: model, boundary and recovery

Create a small CCA website using a feature branch rebased after the remote-tracking branch moved. Combine “An ancestor tip can be its own merge base” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

3. group assignment: model, boundary and recovery

Create a small group assignment using parallel merges that produce a criss-cross ancestry pattern. Combine “–all preserves every best answer” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

4. documentation repo: model, boundary and recovery

Create a small documentation repo using release, translation and correction branches compared before integration. Combine “–octopus finds bases for an n-way merge” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

5. robotics project: model, boundary and recovery

Create a small robotics project using several topic tips reduced to independent work lines. Combine “–independent removes tips reachable from other tips” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

6. revision repository: model, boundary and recovery

Create a small revision repository using shallow clone whose missing parents change what ancestry is visible. Combine “Fork-point can fail rather than invent an answer” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

7. test laboratory: model, boundary and recovery

Create a small test laboratory using ordinary, ancestor, unrelated, criss-cross, reflog and expired-reflog histories. Combine “Three-dot comparisons depend on merge-base semantics” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

8. design review: model, boundary and recovery

Create a small design review using merge-base compared with fork-point, three-dot diff and merge-tree inputs. Combine “Common ancestor means reachable from both tips” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

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.

Official and supporting references

• Primary technical documentation for Git merge-base
• eduKatePunggol: How Studying Works

Return to contents