How to Master Git .mailmap in Punggol Tuition

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 mailmap maps historical author and committer names or email addresses to canonical display identities without rewriting commit objects. Mastery means selecting the narrowest documented mapping form, verifying it with check-mailmap and mailmap-aware views, distinguishing author from committer data, sharing the policy deliberately and remembering that original identities remain in repository history. This guide begins with that mechanism, then develops it through worked traces, deliberate mistakes, explained practice and transfer decisions.

The aim is independent reasoning. A learner should be able to predict behaviour, locate the earliest wrong assumption, use a safe diagnostic procedure and defend a design choice in a new project.

Punggol families can use the guide in short sessions around homework, CCAs and rest. The activities are proposed learning exercises, not claims about a physical branch, timetable, class size, fee, school relationship or guaranteed result.

Use disposable data and repositories, preserve backups, and check version-sensitive details against the official source. Current documentation settles a technical contract; observation and explanation turn that contract into usable knowledge.

Find your next learning step

Choose the route that matches the present difficulty. Use the complete index for a systematic course.

Build the model

Chapters 1-4 . Begin here, then continue after the learner can predict, verify and explain.

Use the core tools

Chapters 5-8 . Begin here, then continue after the learner can predict, verify and explain.

Handle boundaries

Chapters 9-12 . Begin here, then continue after the learner can predict, verify and explain.

Debug and verify

Chapters 13-16 . Begin here, then continue after the learner can predict, verify and explain.

Transfer with judgment

Chapters 17-20 . Begin here, then continue after the learner can predict, verify and explain.

Open the full chapter index . Jump to capstone practice . Use the How Studying Works hub . Read the official documentation

Complete chapter index

Chapters 1-4 . Build the model

Mailmap changes display, not history
The conventional file is top-level .mailmap
Comments and blank lines document policy
The simple form replaces a name

Chapters 5-8 . Use the core tools

The email-only form replaces an email
Name plus email can map by old email
The four-field form disambiguates shared addresses
Matching names and emails is case-insensitive

Chapters 9-12 . Handle boundaries

check-mailmap is the direct diagnostic
Log placeholders expose raw and mapped identities
Log can opt into mailmap-aware display
Shortlog is a core mailmap use case

Chapters 13-16 . Debug and verify

Blame can display mapped identities
Authors and committers are separate roles
Version-controlled policy needs review
mailmap.file selects another file

Chapters 17-20 . Transfer with judgment

mailmap.blob supports repository objects
Multiple sources need an observed precedence model
Mailmap is not a privacy eraser
A disposable history lab proves the policy

CHAPTER 1 OF 20 . Build the model

1. Mailmap changes display, not history

Back to contents

A mailmap supplies canonical names and emails to supporting Git commands while original commit object bytes and IDs remain unchanged. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is calling mailmap a history rewrite or privacy eraser. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Record commit IDs and raw author headers before and after adding .mailmap.

For the Mailmap changes display, not history chapter on Git mailmap, 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 mailmap a history rewrite or privacy eraser. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git cat-file -p HEAD | sed -n '1,5p'
git check-mailmap 'Old Name <old@example.test>'

Explained result. The mapped display can change while the original author header and commit ID stay intact. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: coding assignment. Predict the rule using old and current student email addresses. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A mailmap supplies canonical names and emails to supporting Git commands while original commit object bytes and IDs remain unchanged.” Apply this procedure: Record commit IDs and raw author headers before and after adding .mailmap. The expected mechanism is: The mapped display can change while the original author header and commit ID stay intact. For the coding assignment, add one near-miss that exposes calling mailmap a history rewrite or privacy eraser. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: group project. Contrast the rule using name variants from several laptops. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A mailmap supplies canonical names and emails to supporting Git commands while original commit object bytes and IDs remain unchanged.” Apply this procedure: Record commit IDs and raw author headers before and after adding .mailmap. The expected mechanism is: The mapped display can change while the original author header and commit ID stay intact. For the group project, add one near-miss that exposes calling mailmap a history rewrite or privacy eraser. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: website repository. Stress-test the rule using a bot and a person sharing a legacy address. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A mailmap supplies canonical names and emails to supporting Git commands while original commit object bytes and IDs remain unchanged.” Apply this procedure: Record commit IDs and raw author headers before and after adding .mailmap. The expected mechanism is: The mapped display can change while the original author header and commit ID stay intact. For the website repository, add one near-miss that exposes calling mailmap a history rewrite or privacy eraser. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: science scripts. Explain the rule using institutional and personal email variants. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A mailmap supplies canonical names and emails to supporting Git commands while original commit object bytes and IDs remain unchanged.” Apply this procedure: Record commit IDs and raw author headers before and after adding .mailmap. The expected mechanism is: The mapped display can change while the original author header and commit ID stay intact. For the science scripts, add one near-miss that exposes calling mailmap a history rewrite or privacy eraser. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers calling mailmap a history rewrite or privacy eraser.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Record commit IDs and raw author headers before and after adding .mailmap.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from Mailmap changes display, not history?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing calling mailmap a history rewrite or privacy eraser be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family coding project with several machines with inconsistent Git config. Include one ordinary case, one boundary and one deliberate failure caused by calling mailmap a history rewrite or privacy eraser. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: A mailmap supplies canonical names and emails to supporting Git commands while original commit object bytes and IDs remain unchanged. It shows a trace, not only a final value. The ordinary case should demonstrate “The mapped display can change while the original author header and commit ID stay intact.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Record commit IDs and raw author headers before and after adding .mailmap. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Mailmap changes display, not history, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 2 OF 20 . Build the model

2. The conventional file is top-level .mailmap

Back to contents

Git reads .mailmap at the repository top level, with configuration alternatives available for other storage choices. 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 placing .mailmap in a subdirectory beside source files. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Resolve the repository root and verify the effective mapping with check-mailmap.

For the The conventional file is top-level .mailmap chapter on Git mailmap, 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 placing .mailmap in a subdirectory beside source files. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

root=$(git rev-parse --show-toplevel)
printf '%s
' "$root/.mailmap"

Explained result. The conventional project file belongs at the worktree root and can be version-controlled. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: website repository. Contrast the rule using a bot and a person sharing a legacy address. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Git reads .mailmap at the repository top level, with configuration alternatives available for other storage choices.” Apply this procedure: Resolve the repository root and verify the effective mapping with check-mailmap. The expected mechanism is: The conventional project file belongs at the worktree root and can be version-controlled. For the website repository, add one near-miss that exposes placing .mailmap in a subdirectory beside source files. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: science scripts. Stress-test the rule using institutional and personal email variants. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Git reads .mailmap at the repository top level, with configuration alternatives available for other storage choices.” Apply this procedure: Resolve the repository root and verify the effective mapping with check-mailmap. The expected mechanism is: The conventional project file belongs at the worktree root and can be version-controlled. For the science scripts, add one near-miss that exposes placing .mailmap in a subdirectory beside source files. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: revision repository. Explain the rule using misspelled author names in earlier commits. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Git reads .mailmap at the repository top level, with configuration alternatives available for other storage choices.” Apply this procedure: Resolve the repository root and verify the effective mapping with check-mailmap. The expected mechanism is: The conventional project file belongs at the worktree root and can be version-controlled. For the revision repository, add one near-miss that exposes placing .mailmap in a subdirectory beside source files. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: family coding project. Transfer the rule using several machines with inconsistent Git config. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Git reads .mailmap at the repository top level, with configuration alternatives available for other storage choices.” Apply this procedure: Resolve the repository root and verify the effective mapping with check-mailmap. The expected mechanism is: The conventional project file belongs at the worktree root and can be version-controlled. For the family coding project, add one near-miss that exposes placing .mailmap in a subdirectory beside source files. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers placing .mailmap in a subdirectory beside source files.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Resolve the repository root and verify the effective mapping with check-mailmap.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from The conventional file is top-level .mailmap?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing placing .mailmap in a subdirectory beside source files be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny public contribution lab with canonical display names with preserved history. Include one ordinary case, one boundary and one deliberate failure caused by placing .mailmap in a subdirectory beside source files. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: Git reads .mailmap at the repository top level, with configuration alternatives available for other storage choices. It shows a trace, not only a final value. The ordinary case should demonstrate “The conventional project file belongs at the worktree root and can be version-controlled.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Resolve the repository root and verify the effective mapping with check-mailmap. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For The conventional file is top-level .mailmap, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 3 OF 20 . Build the model

3. Comments and blank lines document policy

Back to contents

A # starts a comment through the end of a .mailmap line, and blank lines are ignored. 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 putting unescaped explanatory text after a mapping without a comment marker. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Keep one mapping per line and explain non-obvious aliases with comments.

For the Comments and blank lines document policy chapter on Git mailmap, 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 putting unescaped explanatory text after a mapping without a comment marker. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

# Canonical identity after school email change
Student Lee <old@example.test>

Explained result. Git ignores the comment and parses the mapping line. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: revision repository. Stress-test the rule using misspelled author names in earlier commits. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A # starts a comment through the end of a .mailmap line, and blank lines are ignored.” Apply this procedure: Keep one mapping per line and explain non-obvious aliases with comments. The expected mechanism is: Git ignores the comment and parses the mapping line. For the revision repository, add one near-miss that exposes putting unescaped explanatory text after a mapping without a comment marker. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: family coding project. Explain the rule using several machines with inconsistent Git config. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A # starts a comment through the end of a .mailmap line, and blank lines are ignored.” Apply this procedure: Keep one mapping per line and explain non-obvious aliases with comments. The expected mechanism is: Git ignores the comment and parses the mapping line. For the family coding project, add one near-miss that exposes putting unescaped explanatory text after a mapping without a comment marker. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: public contribution lab. Transfer the rule using canonical display names with preserved history. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A # starts a comment through the end of a .mailmap line, and blank lines are ignored.” Apply this procedure: Keep one mapping per line and explain non-obvious aliases with comments. The expected mechanism is: Git ignores the comment and parses the mapping line. For the public contribution lab, add one near-miss that exposes putting unescaped explanatory text after a mapping without a comment marker. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: disposable Git laboratory. Predict the rule using controlled commits, four mapping forms and exact assertions. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A # starts a comment through the end of a .mailmap line, and blank lines are ignored.” Apply this procedure: Keep one mapping per line and explain non-obvious aliases with comments. The expected mechanism is: Git ignores the comment and parses the mapping line. For the disposable Git laboratory, add one near-miss that exposes putting unescaped explanatory text after a mapping without a comment marker. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers putting unescaped explanatory text after a mapping without a comment marker.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Keep one mapping per line and explain non-obvious aliases with comments.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from Comments and blank lines document policy?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing putting unescaped explanatory text after a mapping without a comment marker be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny disposable Git laboratory with controlled commits, four mapping forms and exact assertions. Include one ordinary case, one boundary and one deliberate failure caused by putting unescaped explanatory text after a mapping without a comment marker. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: A # starts a comment through the end of a .mailmap line, and blank lines are ignored. It shows a trace, not only a final value. The ordinary case should demonstrate “Git ignores the comment and parses the mapping line.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Keep one mapping per line and explain non-obvious aliases with comments. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Comments and blank lines document policy, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 4 OF 20 . Build the model

4. The simple form replaces a name

Back to contents

Canonical Name maps commits with that email to the canonical name while retaining the historical email. 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 the one-address form to replace the email too. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Run check-mailmap and compare both output fields.

For the The simple form replaces a name chapter on Git mailmap, 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 the one-address form to replace the email too. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

Student Lee <old@example.test>

Explained result. An input using old@example.test displays Student Lee but keeps old@example.test as its email. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: public contribution lab. Explain the rule using canonical display names with preserved history. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Canonical Name maps commits with that email to the canonical name while retaining the historical email.” Apply this procedure: Run check-mailmap and compare both output fields. The expected mechanism is: An input using old@example.test displays Student Lee but keeps old@example.test as its email. For the public contribution lab, add one near-miss that exposes expecting the one-address form to replace the email too. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: disposable Git laboratory. Transfer the rule using controlled commits, four mapping forms and exact assertions. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Canonical Name maps commits with that email to the canonical name while retaining the historical email.” Apply this procedure: Run check-mailmap and compare both output fields. The expected mechanism is: An input using old@example.test displays Student Lee but keeps old@example.test as its email. For the disposable Git laboratory, add one near-miss that exposes expecting the one-address form to replace the email too. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: coding assignment. Predict the rule using old and current student email addresses. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Canonical Name maps commits with that email to the canonical name while retaining the historical email.” Apply this procedure: Run check-mailmap and compare both output fields. The expected mechanism is: An input using old@example.test displays Student Lee but keeps old@example.test as its email. For the coding assignment, add one near-miss that exposes expecting the one-address form to replace the email too. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: group project. Contrast the rule using name variants from several laptops. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Canonical Name maps commits with that email to the canonical name while retaining the historical email.” Apply this procedure: Run check-mailmap and compare both output fields. The expected mechanism is: An input using old@example.test displays Student Lee but keeps old@example.test as its email. For the group project, add one near-miss that exposes expecting the one-address form to replace the email too. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers expecting the one-address form to replace the email too.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Run check-mailmap and compare both output fields.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from The simple form replaces a name?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting the one-address form to replace the email too be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny coding assignment with old and current student email addresses. Include one ordinary case, one boundary and one deliberate failure caused by expecting the one-address form to replace the email too. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: Canonical Name maps commits with that email to the canonical name while retaining the historical email. It shows a trace, not only a final value. The ordinary case should demonstrate “An input using old@example.test displays Student Lee but keeps old@example.test as its email.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Run check-mailmap and compare both output fields. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For The simple form replaces a name, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 5 OF 20 . Use the core tools

5. The email-only form replaces an email

Back to contents

replaces the historical email while keeping the historical name. 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 adding a name mentally even though neither side specifies one. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test two different names that use the same old email.

For the The email-only form replaces an email chapter on Git mailmap, 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 adding a name mentally even though neither side specifies one. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

<current@example.test> <old@example.test>

Explained result. Each matching identity keeps its input name and displays current@example.test as the email. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: coding assignment. Transfer the rule using old and current student email addresses. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “ replaces the historical email while keeping the historical name.” Apply this procedure: Test two different names that use the same old email. The expected mechanism is: Each matching identity keeps its input name and displays current@example.test as the email. For the coding assignment, add one near-miss that exposes adding a name mentally even though neither side specifies one. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: group project. Predict the rule using name variants from several laptops. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “ replaces the historical email while keeping the historical name.” Apply this procedure: Test two different names that use the same old email. The expected mechanism is: Each matching identity keeps its input name and displays current@example.test as the email. For the group project, add one near-miss that exposes adding a name mentally even though neither side specifies one. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: website repository. Contrast the rule using a bot and a person sharing a legacy address. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “ replaces the historical email while keeping the historical name.” Apply this procedure: Test two different names that use the same old email. The expected mechanism is: Each matching identity keeps its input name and displays current@example.test as the email. For the website repository, add one near-miss that exposes adding a name mentally even though neither side specifies one. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: science scripts. Stress-test the rule using institutional and personal email variants. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “ replaces the historical email while keeping the historical name.” Apply this procedure: Test two different names that use the same old email. The expected mechanism is: Each matching identity keeps its input name and displays current@example.test as the email. For the science scripts, add one near-miss that exposes adding a name mentally even though neither side specifies one. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers adding a name mentally even though neither side specifies one.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Test two different names that use the same old email.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from The email-only form replaces an email?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing adding a name mentally even though neither side specifies one be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny group project with name variants from several laptops. Include one ordinary case, one boundary and one deliberate failure caused by adding a name mentally even though neither side specifies one. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: replaces the historical email while keeping the historical name. It shows a trace, not only a final value. The ordinary case should demonstrate “Each matching identity keeps its input name and displays current@example.test as the email.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Test two different names that use the same old email. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For The email-only form replaces an email, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 6 OF 20 . Use the core tools

6. Name plus email can map by old email

Back to contents

Canonical Name replaces both displayed fields for any identity matching the old email. 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 this broad form when one old address was shared by two people. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Audit every historical name attached to the old address before choosing the broad rule.

For the Name plus email can map by old email chapter on Git mailmap, 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 this broad form when one old address was shared by two people. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

Student Lee <current@example.test> <old@example.test>

Explained result. Any commit identity with old@example.test maps to the two canonical fields. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: website repository. Predict the rule using a bot and a person sharing a legacy address. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Canonical Name replaces both displayed fields for any identity matching the old email.” Apply this procedure: Audit every historical name attached to the old address before choosing the broad rule. The expected mechanism is: Any commit identity with old@example.test maps to the two canonical fields. For the website repository, add one near-miss that exposes using this broad form when one old address was shared by two people. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: science scripts. Contrast the rule using institutional and personal email variants. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Canonical Name replaces both displayed fields for any identity matching the old email.” Apply this procedure: Audit every historical name attached to the old address before choosing the broad rule. The expected mechanism is: Any commit identity with old@example.test maps to the two canonical fields. For the science scripts, add one near-miss that exposes using this broad form when one old address was shared by two people. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: revision repository. Stress-test the rule using misspelled author names in earlier commits. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Canonical Name replaces both displayed fields for any identity matching the old email.” Apply this procedure: Audit every historical name attached to the old address before choosing the broad rule. The expected mechanism is: Any commit identity with old@example.test maps to the two canonical fields. For the revision repository, add one near-miss that exposes using this broad form when one old address was shared by two people. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: family coding project. Explain the rule using several machines with inconsistent Git config. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Canonical Name replaces both displayed fields for any identity matching the old email.” Apply this procedure: Audit every historical name attached to the old address before choosing the broad rule. The expected mechanism is: Any commit identity with old@example.test maps to the two canonical fields. For the family coding project, add one near-miss that exposes using this broad form when one old address was shared by two people. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers using this broad form when one old address was shared by two people.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Audit every historical name attached to the old address before choosing the broad rule.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from Name plus email can map by old email?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using this broad form when one old address was shared by two people be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny website repository with a bot and a person sharing a legacy address. Include one ordinary case, one boundary and one deliberate failure caused by using this broad form when one old address was shared by two people. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: Canonical Name replaces both displayed fields for any identity matching the old email. It shows a trace, not only a final value. The ordinary case should demonstrate “Any commit identity with old@example.test maps to the two canonical fields.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Audit every historical name attached to the old address before choosing the broad rule. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Name plus email can map by old email, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 7 OF 20 . Use the core tools

7. The four-field form disambiguates shared addresses

Back to contents

Canonical Name Commit Name requires both historical name and email to match. 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 mapping a shared bot address broadly and merging two people in reports. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use exact historical pairs when an address was shared.

For the The four-field form disambiguates shared addresses chapter on Git mailmap, 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 mapping a shared bot address broadly and merging two people in reports. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

Lee Student <lee@example.test> Lee <bugs@example.test>

Explained result. Only the Lee identity at the shared bugs address receives this canonical mapping. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: revision repository. Contrast the rule using misspelled author names in earlier commits. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Canonical Name Commit Name requires both historical name and email to match.” Apply this procedure: Use exact historical pairs when an address was shared. The expected mechanism is: Only the Lee identity at the shared bugs address receives this canonical mapping. For the revision repository, add one near-miss that exposes mapping a shared bot address broadly and merging two people in reports. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: family coding project. Stress-test the rule using several machines with inconsistent Git config. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Canonical Name Commit Name requires both historical name and email to match.” Apply this procedure: Use exact historical pairs when an address was shared. The expected mechanism is: Only the Lee identity at the shared bugs address receives this canonical mapping. For the family coding project, add one near-miss that exposes mapping a shared bot address broadly and merging two people in reports. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: public contribution lab. Explain the rule using canonical display names with preserved history. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Canonical Name Commit Name requires both historical name and email to match.” Apply this procedure: Use exact historical pairs when an address was shared. The expected mechanism is: Only the Lee identity at the shared bugs address receives this canonical mapping. For the public contribution lab, add one near-miss that exposes mapping a shared bot address broadly and merging two people in reports. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: disposable Git laboratory. Transfer the rule using controlled commits, four mapping forms and exact assertions. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Canonical Name Commit Name requires both historical name and email to match.” Apply this procedure: Use exact historical pairs when an address was shared. The expected mechanism is: Only the Lee identity at the shared bugs address receives this canonical mapping. For the disposable Git laboratory, add one near-miss that exposes mapping a shared bot address broadly and merging two people in reports. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers mapping a shared bot address broadly and merging two people in reports.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Use exact historical pairs when an address was shared.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from The four-field form disambiguates shared addresses?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing mapping a shared bot address broadly and merging two people in reports be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science scripts with institutional and personal email variants. Include one ordinary case, one boundary and one deliberate failure caused by mapping a shared bot address broadly and merging two people in reports. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: Canonical Name Commit Name requires both historical name and email to match. It shows a trace, not only a final value. The ordinary case should demonstrate “Only the Lee identity at the shared bugs address receives this canonical mapping.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use exact historical pairs when an address was shared. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For The four-field form disambiguates shared addresses, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 8 OF 20 . Use the core tools

8. Matching names and emails is case-insensitive

Back to contents

The documented name and email comparisons ignore case. 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 creating duplicate rules solely for upper- and lower-case spellings. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Verify one mixed-case input with check-mailmap.

For the Matching names and emails is case-insensitive chapter on Git mailmap, 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 creating duplicate rules solely for upper- and lower-case spellings. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

Lee Student <lee@example.test> lEe <BuGs@example.test>

Explained result. The rule can match case variants of the historical name and email. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: public contribution lab. Stress-test the rule using canonical display names with preserved history. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “The documented name and email comparisons ignore case.” Apply this procedure: Verify one mixed-case input with check-mailmap. The expected mechanism is: The rule can match case variants of the historical name and email. For the public contribution lab, add one near-miss that exposes creating duplicate rules solely for upper- and lower-case spellings. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: disposable Git laboratory. Explain the rule using controlled commits, four mapping forms and exact assertions. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “The documented name and email comparisons ignore case.” Apply this procedure: Verify one mixed-case input with check-mailmap. The expected mechanism is: The rule can match case variants of the historical name and email. For the disposable Git laboratory, add one near-miss that exposes creating duplicate rules solely for upper- and lower-case spellings. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: coding assignment. Transfer the rule using old and current student email addresses. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “The documented name and email comparisons ignore case.” Apply this procedure: Verify one mixed-case input with check-mailmap. The expected mechanism is: The rule can match case variants of the historical name and email. For the coding assignment, add one near-miss that exposes creating duplicate rules solely for upper- and lower-case spellings. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: group project. Predict the rule using name variants from several laptops. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “The documented name and email comparisons ignore case.” Apply this procedure: Verify one mixed-case input with check-mailmap. The expected mechanism is: The rule can match case variants of the historical name and email. For the group project, add one near-miss that exposes creating duplicate rules solely for upper- and lower-case spellings. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers creating duplicate rules solely for upper- and lower-case spellings.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Verify one mixed-case input with check-mailmap.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from Matching names and emails is case-insensitive?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing creating duplicate rules solely for upper- and lower-case spellings 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 misspelled author names in earlier commits. Include one ordinary case, one boundary and one deliberate failure caused by creating duplicate rules solely for upper- and lower-case spellings. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: The documented name and email comparisons ignore case. It shows a trace, not only a final value. The ordinary case should demonstrate “The rule can match case variants of the historical name and email.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Verify one mixed-case input with check-mailmap. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Matching names and emails is case-insensitive, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 9 OF 20 . Handle boundaries

9. check-mailmap is the direct diagnostic

Back to contents

git check-mailmap resolves contact strings through the current mailmap and can read contacts from standard input. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is judging a rule only by scanning a long git log. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test every intended alias and one near-miss before committing the policy.

For the check-mailmap is the direct diagnostic chapter on Git mailmap, 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 judging a rule only by scanning a long git log. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

printf '%s
' 'Old Name <old@example.test>' | git check-mailmap --stdin

Explained result. The command prints the canonicalised contact according to the effective mailmap. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: coding assignment. Explain the rule using old and current student email addresses. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git check-mailmap resolves contact strings through the current mailmap and can read contacts from standard input.” Apply this procedure: Test every intended alias and one near-miss before committing the policy. The expected mechanism is: The command prints the canonicalised contact according to the effective mailmap. For the coding assignment, add one near-miss that exposes judging a rule only by scanning a long git log. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: group project. Transfer the rule using name variants from several laptops. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git check-mailmap resolves contact strings through the current mailmap and can read contacts from standard input.” Apply this procedure: Test every intended alias and one near-miss before committing the policy. The expected mechanism is: The command prints the canonicalised contact according to the effective mailmap. For the group project, add one near-miss that exposes judging a rule only by scanning a long git log. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: website repository. Predict the rule using a bot and a person sharing a legacy address. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git check-mailmap resolves contact strings through the current mailmap and can read contacts from standard input.” Apply this procedure: Test every intended alias and one near-miss before committing the policy. The expected mechanism is: The command prints the canonicalised contact according to the effective mailmap. For the website repository, add one near-miss that exposes judging a rule only by scanning a long git log. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: science scripts. Contrast the rule using institutional and personal email variants. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git check-mailmap resolves contact strings through the current mailmap and can read contacts from standard input.” Apply this procedure: Test every intended alias and one near-miss before committing the policy. The expected mechanism is: The command prints the canonicalised contact according to the effective mailmap. For the science scripts, add one near-miss that exposes judging a rule only by scanning a long git log. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers judging a rule only by scanning a long git log.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Test every intended alias and one near-miss before committing the policy.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from check-mailmap is the direct diagnostic?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing judging a rule only by scanning a long git log be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family coding project with several machines with inconsistent Git config. Include one ordinary case, one boundary and one deliberate failure caused by judging a rule only by scanning a long git log. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: git check-mailmap resolves contact strings through the current mailmap and can read contacts from standard input. It shows a trace, not only a final value. The ordinary case should demonstrate “The command prints the canonicalised contact according to the effective mailmap.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Test every intended alias and one near-miss before committing the policy. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For check-mailmap is the direct diagnostic, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 10 OF 20 . Handle boundaries

10. Log placeholders expose raw and mapped identities

Back to contents

Pretty formats provide lowercase raw author placeholders and uppercase mailmap-aware forms, with corresponding committer forms. 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 %an and claiming the displayed name proves mailmap worked. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Print raw and canonical fields side by side.

For the Log placeholders expose raw and mapped identities chapter on Git mailmap, 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 %an and claiming the displayed name proves mailmap worked. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git log -1 --format='%an <%ae> | %aN <%aE>'

Explained result. The left side shows stored author data; the right side shows mailmap-resolved author data. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: website repository. Transfer the rule using a bot and a person sharing a legacy address. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Pretty formats provide lowercase raw author placeholders and uppercase mailmap-aware forms, with corresponding committer forms.” Apply this procedure: Print raw and canonical fields side by side. The expected mechanism is: The left side shows stored author data; the right side shows mailmap-resolved author data. For the website repository, add one near-miss that exposes using %an and claiming the displayed name proves mailmap worked. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: science scripts. Predict the rule using institutional and personal email variants. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Pretty formats provide lowercase raw author placeholders and uppercase mailmap-aware forms, with corresponding committer forms.” Apply this procedure: Print raw and canonical fields side by side. The expected mechanism is: The left side shows stored author data; the right side shows mailmap-resolved author data. For the science scripts, add one near-miss that exposes using %an and claiming the displayed name proves mailmap worked. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: revision repository. Contrast the rule using misspelled author names in earlier commits. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Pretty formats provide lowercase raw author placeholders and uppercase mailmap-aware forms, with corresponding committer forms.” Apply this procedure: Print raw and canonical fields side by side. The expected mechanism is: The left side shows stored author data; the right side shows mailmap-resolved author data. For the revision repository, add one near-miss that exposes using %an and claiming the displayed name proves mailmap worked. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: family coding project. Stress-test the rule using several machines with inconsistent Git config. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Pretty formats provide lowercase raw author placeholders and uppercase mailmap-aware forms, with corresponding committer forms.” Apply this procedure: Print raw and canonical fields side by side. The expected mechanism is: The left side shows stored author data; the right side shows mailmap-resolved author data. For the family coding project, add one near-miss that exposes using %an and claiming the displayed name proves mailmap worked. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers using %an and claiming the displayed name proves mailmap worked.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Print raw and canonical fields side by side.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from Log placeholders expose raw and mapped identities?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using %an and claiming the displayed name proves mailmap worked be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny public contribution lab with canonical display names with preserved history. Include one ordinary case, one boundary and one deliberate failure caused by using %an and claiming the displayed name proves mailmap worked. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: Pretty formats provide lowercase raw author placeholders and uppercase mailmap-aware forms, with corresponding committer forms. It shows a trace, not only a final value. The ordinary case should demonstrate “The left side shows stored author data; the right side shows mailmap-resolved author data.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Print raw and canonical fields side by side. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Log placeholders expose raw and mapped identities, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 11 OF 20 . Handle boundaries

11. Log can opt into mailmap-aware display

Back to contents

git log supports mailmap-aware author and committer display, while exact formatting choices should be explicit in scripts. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is assuming every log format automatically applies mailmap. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use –use-mailmap or uppercase pretty placeholders and test the output.

For the Log can opt into mailmap-aware display chapter on Git mailmap, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming every log format automatically applies mailmap. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git log --use-mailmap --format='%h %aN <%aE>'

Explained result. The displayed author identity is canonicalised without changing the commit. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: revision repository. Predict the rule using misspelled author names in earlier commits. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git log supports mailmap-aware author and committer display, while exact formatting choices should be explicit in scripts.” Apply this procedure: Use –use-mailmap or uppercase pretty placeholders and test the output. The expected mechanism is: The displayed author identity is canonicalised without changing the commit. For the revision repository, add one near-miss that exposes assuming every log format automatically applies mailmap. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: family coding project. Contrast the rule using several machines with inconsistent Git config. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git log supports mailmap-aware author and committer display, while exact formatting choices should be explicit in scripts.” Apply this procedure: Use –use-mailmap or uppercase pretty placeholders and test the output. The expected mechanism is: The displayed author identity is canonicalised without changing the commit. For the family coding project, add one near-miss that exposes assuming every log format automatically applies mailmap. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: public contribution lab. Stress-test the rule using canonical display names with preserved history. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git log supports mailmap-aware author and committer display, while exact formatting choices should be explicit in scripts.” Apply this procedure: Use –use-mailmap or uppercase pretty placeholders and test the output. The expected mechanism is: The displayed author identity is canonicalised without changing the commit. For the public contribution lab, add one near-miss that exposes assuming every log format automatically applies mailmap. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: disposable Git laboratory. Explain the rule using controlled commits, four mapping forms and exact assertions. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git log supports mailmap-aware author and committer display, while exact formatting choices should be explicit in scripts.” Apply this procedure: Use –use-mailmap or uppercase pretty placeholders and test the output. The expected mechanism is: The displayed author identity is canonicalised without changing the commit. For the disposable Git laboratory, add one near-miss that exposes assuming every log format automatically applies mailmap. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers assuming every log format automatically applies mailmap.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Use –use-mailmap or uppercase pretty placeholders and test the output.” and record the first changed observation.
Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git mailmap syntax. For this chapter, useful prompts are: “What did you expect from Log can opt into mailmap-aware display?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming every log format automatically applies mailmap be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny disposable Git laboratory with controlled commits, four mapping forms and exact assertions. Include one ordinary case, one boundary and one deliberate failure caused by assuming every log format automatically applies mailmap. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: git log supports mailmap-aware author and committer display, while exact formatting choices should be explicit in scripts. It shows a trace, not only a final value. The ordinary case should demonstrate “The displayed author identity is canonicalised without changing the commit.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use –use-mailmap or uppercase pretty placeholders and test the output. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Log can opt into mailmap-aware display, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 12 OF 20 . Handle boundaries

12. Shortlog is a core mailmap use case

Back to contents

git shortlog groups contributions using mailmap-aware canonical identities, reducing accidental split counts from aliases. 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 grouped counts as proof of legal identity or ownership. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Verify the alias policy and explain that shortlog is a repository summary.

For the Shortlog is a core mailmap use case chapter on Git mailmap, 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 grouped counts as proof of legal identity or ownership. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git shortlog -sne --all

Explained result. Aliases covered by mailmap are grouped under the chosen canonical display identity. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: public contribution lab. Contrast the rule using canonical display names with preserved history. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git shortlog groups contributions using mailmap-aware canonical identities, reducing accidental split counts from aliases.” Apply this procedure: Verify the alias policy and explain that shortlog is a repository summary. The expected mechanism is: Aliases covered by mailmap are grouped under the chosen canonical display identity. For the public contribution lab, add one near-miss that exposes treating grouped counts as proof of legal identity or ownership. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: disposable Git laboratory. Stress-test the rule using controlled commits, four mapping forms and exact assertions. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git shortlog groups contributions using mailmap-aware canonical identities, reducing accidental split counts from aliases.” Apply this procedure: Verify the alias policy and explain that shortlog is a repository summary. The expected mechanism is: Aliases covered by mailmap are grouped under the chosen canonical display identity. For the disposable Git laboratory, add one near-miss that exposes treating grouped counts as proof of legal identity or ownership. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: coding assignment. Explain the rule using old and current student email addresses. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git shortlog groups contributions using mailmap-aware canonical identities, reducing accidental split counts from aliases.” Apply this procedure: Verify the alias policy and explain that shortlog is a repository summary. The expected mechanism is: Aliases covered by mailmap are grouped under the chosen canonical display identity. For the coding assignment, add one near-miss that exposes treating grouped counts as proof of legal identity or ownership. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: group project. Transfer the rule using name variants from several laptops. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git shortlog groups contributions using mailmap-aware canonical identities, reducing accidental split counts from aliases.” Apply this procedure: Verify the alias policy and explain that shortlog is a repository summary. The expected mechanism is: Aliases covered by mailmap are grouped under the chosen canonical display identity. For the group project, add one near-miss that exposes treating grouped counts as proof of legal identity or ownership. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers treating grouped counts as proof of legal identity or ownership.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Verify the alias policy and explain that shortlog is a repository summary.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from Shortlog is a core mailmap use case?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating grouped counts as proof of legal identity or ownership be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny coding assignment with old and current student email addresses. Include one ordinary case, one boundary and one deliberate failure caused by treating grouped counts as proof of legal identity or ownership. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: git shortlog groups contributions using mailmap-aware canonical identities, reducing accidental split counts from aliases. It shows a trace, not only a final value. The ordinary case should demonstrate “Aliases covered by mailmap are grouped under the chosen canonical display identity.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Verify the alias policy and explain that shortlog is a repository summary. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Shortlog is a core mailmap use case, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 13 OF 20 . Debug and verify

13. Blame can display mapped identities

Back to contents

git blame can use mailmap-aware identity display, but the blamed commit and stored metadata remain unchanged. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is reading a canonicalised label as evidence the original commit header was replaced. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compare blame output with git cat-file for the same commit.

For the Blame can display mapped identities chapter on Git mailmap, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on reading a canonicalised label as evidence the original commit header was replaced. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git blame --mailmap README.md

Explained result. The line attribution can show canonical names while raw commit data remains available. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: coding assignment. Stress-test the rule using old and current student email addresses. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git blame can use mailmap-aware identity display, but the blamed commit and stored metadata remain unchanged.” Apply this procedure: Compare blame output with git cat-file for the same commit. The expected mechanism is: The line attribution can show canonical names while raw commit data remains available. For the coding assignment, add one near-miss that exposes reading a canonicalised label as evidence the original commit header was replaced. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: group project. Explain the rule using name variants from several laptops. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git blame can use mailmap-aware identity display, but the blamed commit and stored metadata remain unchanged.” Apply this procedure: Compare blame output with git cat-file for the same commit. The expected mechanism is: The line attribution can show canonical names while raw commit data remains available. For the group project, add one near-miss that exposes reading a canonicalised label as evidence the original commit header was replaced. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: website repository. Transfer the rule using a bot and a person sharing a legacy address. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git blame can use mailmap-aware identity display, but the blamed commit and stored metadata remain unchanged.” Apply this procedure: Compare blame output with git cat-file for the same commit. The expected mechanism is: The line attribution can show canonical names while raw commit data remains available. For the website repository, add one near-miss that exposes reading a canonicalised label as evidence the original commit header was replaced. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: science scripts. Predict the rule using institutional and personal email variants. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “git blame can use mailmap-aware identity display, but the blamed commit and stored metadata remain unchanged.” Apply this procedure: Compare blame output with git cat-file for the same commit. The expected mechanism is: The line attribution can show canonical names while raw commit data remains available. For the science scripts, add one near-miss that exposes reading a canonicalised label as evidence the original commit header was replaced. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers reading a canonicalised label as evidence the original commit header was replaced.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Compare blame output with git cat-file for the same 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from Blame can display mapped identities?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing reading a canonicalised label as evidence the original commit header was replaced be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny group project with name variants from several laptops. Include one ordinary case, one boundary and one deliberate failure caused by reading a canonicalised label as evidence the original commit header was replaced. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: git blame can use mailmap-aware identity display, but the blamed commit and stored metadata remain unchanged. It shows a trace, not only a final value. The ordinary case should demonstrate “The line attribution can show canonical names while raw commit data remains available.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Compare blame output with git cat-file for the same commit. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Blame can display mapped identities, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 14 OF 20 . Debug and verify

14. Authors and committers are separate roles

Back to contents

A commit stores both author and committer identities, and mailmap can canonicalise either when a command presents 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 repairing author aliases and forgetting automation or migration committer aliases. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Inspect %an/%ae/%cn/%ce beside their uppercase mapped forms.

For the Authors and committers are separate roles chapter on Git mailmap, 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 repairing author aliases and forgetting automation or migration committer aliases. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git log -1 --format='%an <%ae> / %cn <%ce> | %aN <%aE> / %cN <%cE>'

Explained result. The trace distinguishes who authored the change from who created the commit object. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: website repository. Explain the rule using a bot and a person sharing a legacy address. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A commit stores both author and committer identities, and mailmap can canonicalise either when a command presents them.” Apply this procedure: Inspect %an/%ae/%cn/%ce beside their uppercase mapped forms. The expected mechanism is: The trace distinguishes who authored the change from who created the commit object. For the website repository, add one near-miss that exposes repairing author aliases and forgetting automation or migration committer aliases. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: science scripts. Transfer the rule using institutional and personal email variants. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A commit stores both author and committer identities, and mailmap can canonicalise either when a command presents them.” Apply this procedure: Inspect %an/%ae/%cn/%ce beside their uppercase mapped forms. The expected mechanism is: The trace distinguishes who authored the change from who created the commit object. For the science scripts, add one near-miss that exposes repairing author aliases and forgetting automation or migration committer aliases. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: revision repository. Predict the rule using misspelled author names in earlier commits. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A commit stores both author and committer identities, and mailmap can canonicalise either when a command presents them.” Apply this procedure: Inspect %an/%ae/%cn/%ce beside their uppercase mapped forms. The expected mechanism is: The trace distinguishes who authored the change from who created the commit object. For the revision repository, add one near-miss that exposes repairing author aliases and forgetting automation or migration committer aliases. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: family coding project. Contrast the rule using several machines with inconsistent Git config. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A commit stores both author and committer identities, and mailmap can canonicalise either when a command presents them.” Apply this procedure: Inspect %an/%ae/%cn/%ce beside their uppercase mapped forms. The expected mechanism is: The trace distinguishes who authored the change from who created the commit object. For the family coding project, add one near-miss that exposes repairing author aliases and forgetting automation or migration committer aliases. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers repairing author aliases and forgetting automation or migration committer aliases.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Inspect %an/%ae/%cn/%ce beside their uppercase mapped forms.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from Authors and committers are separate roles?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing repairing author aliases and forgetting automation or migration committer aliases be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny website repository with a bot and a person sharing a legacy address. Include one ordinary case, one boundary and one deliberate failure caused by repairing author aliases and forgetting automation or migration committer aliases. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: A commit stores both author and committer identities, and mailmap can canonicalise either when a command presents them. It shows a trace, not only a final value. The ordinary case should demonstrate “The trace distinguishes who authored the change from who created the commit object.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Inspect %an/%ae/%cn/%ce beside their uppercase mapped forms. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Authors and committers are separate roles, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 15 OF 20 . Debug and verify

15. Version-controlled policy needs review

Back to contents

A committed .mailmap makes canonicalisation shareable, but changing it changes future displays and reports. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is accepting identity merges as harmless formatting without consent or evidence. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Review additions like code, document the reason and test near-misses.

For the Version-controlled policy needs review chapter on Git mailmap, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on accepting identity merges as harmless formatting without consent or evidence. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git add .mailmap && git diff --cached -- .mailmap

Explained result. The staged review exposes exactly which canonical identity rules the project will share. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: revision repository. Transfer the rule using misspelled author names in earlier commits. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A committed .mailmap makes canonicalisation shareable, but changing it changes future displays and reports.” Apply this procedure: Review additions like code, document the reason and test near-misses. The expected mechanism is: The staged review exposes exactly which canonical identity rules the project will share. For the revision repository, add one near-miss that exposes accepting identity merges as harmless formatting without consent or evidence. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: family coding project. Predict the rule using several machines with inconsistent Git config. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A committed .mailmap makes canonicalisation shareable, but changing it changes future displays and reports.” Apply this procedure: Review additions like code, document the reason and test near-misses. The expected mechanism is: The staged review exposes exactly which canonical identity rules the project will share. For the family coding project, add one near-miss that exposes accepting identity merges as harmless formatting without consent or evidence. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: public contribution lab. Contrast the rule using canonical display names with preserved history. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A committed .mailmap makes canonicalisation shareable, but changing it changes future displays and reports.” Apply this procedure: Review additions like code, document the reason and test near-misses. The expected mechanism is: The staged review exposes exactly which canonical identity rules the project will share. For the public contribution lab, add one near-miss that exposes accepting identity merges as harmless formatting without consent or evidence. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: disposable Git laboratory. Stress-test the rule using controlled commits, four mapping forms and exact assertions. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A committed .mailmap makes canonicalisation shareable, but changing it changes future displays and reports.” Apply this procedure: Review additions like code, document the reason and test near-misses. The expected mechanism is: The staged review exposes exactly which canonical identity rules the project will share. For the disposable Git laboratory, add one near-miss that exposes accepting identity merges as harmless formatting without consent or evidence. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers accepting identity merges as harmless formatting without consent or evidence.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Review additions like code, document the reason and test near-misses.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from Version-controlled policy needs review?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing accepting identity merges as harmless formatting without consent or evidence be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science scripts with institutional and personal email variants. Include one ordinary case, one boundary and one deliberate failure caused by accepting identity merges as harmless formatting without consent or evidence. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: A committed .mailmap makes canonicalisation shareable, but changing it changes future displays and reports. It shows a trace, not only a final value. The ordinary case should demonstrate “The staged review exposes exactly which canonical identity rules the project will share.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Review additions like code, document the reason and test near-misses. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Version-controlled policy needs review, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 16 OF 20 . Debug and verify

16. mailmap.file selects another file

Back to contents

The mailmap.file configuration can point to an additional or alternative file according to Git configuration scope and path rules. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is setting a global file and forgetting it silently affects several repositories. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Inspect value and origin, then test inside the intended repository.

For the mailmap.file selects another file chapter on Git mailmap, 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 setting a global file and forgetting it silently affects several repositories. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git config --show-origin --get mailmap.file

Explained result. The output reveals which configuration file selected the mailmap path. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: public contribution lab. Predict the rule using canonical display names with preserved history. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “The mailmap.file configuration can point to an additional or alternative file according to Git configuration scope and path rules.” Apply this procedure: Inspect value and origin, then test inside the intended repository. The expected mechanism is: The output reveals which configuration file selected the mailmap path. For the public contribution lab, add one near-miss that exposes setting a global file and forgetting it silently affects several repositories. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: disposable Git laboratory. Contrast the rule using controlled commits, four mapping forms and exact assertions. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “The mailmap.file configuration can point to an additional or alternative file according to Git configuration scope and path rules.” Apply this procedure: Inspect value and origin, then test inside the intended repository. The expected mechanism is: The output reveals which configuration file selected the mailmap path. For the disposable Git laboratory, add one near-miss that exposes setting a global file and forgetting it silently affects several repositories. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: coding assignment. Stress-test the rule using old and current student email addresses. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “The mailmap.file configuration can point to an additional or alternative file according to Git configuration scope and path rules.” Apply this procedure: Inspect value and origin, then test inside the intended repository. The expected mechanism is: The output reveals which configuration file selected the mailmap path. For the coding assignment, add one near-miss that exposes setting a global file and forgetting it silently affects several repositories. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: group project. Explain the rule using name variants from several laptops. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “The mailmap.file configuration can point to an additional or alternative file according to Git configuration scope and path rules.” Apply this procedure: Inspect value and origin, then test inside the intended repository. The expected mechanism is: The output reveals which configuration file selected the mailmap path. For the group project, add one near-miss that exposes setting a global file and forgetting it silently affects several repositories. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers setting a global file and forgetting it silently affects several repositories.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Inspect value and origin, then test inside the intended repository.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from mailmap.file selects another file?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing setting a global file and forgetting it silently affects several repositories 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 misspelled author names in earlier commits. Include one ordinary case, one boundary and one deliberate failure caused by setting a global file and forgetting it silently affects several repositories. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: The mailmap.file configuration can point to an additional or alternative file according to Git configuration scope and path rules. It shows a trace, not only a final value. The ordinary case should demonstrate “The output reveals which configuration file selected the mailmap path.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Inspect value and origin, then test inside the intended repository. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For mailmap.file selects another file, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 17 OF 20 . Transfer with judgment

17. mailmap.blob supports repository objects

Back to contents

mailmap.blob can select mailmap data from a blob, useful where no checked-out top-level file is available, including bare-repository workflows. 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 an unverified object name into configuration and assuming it will remain meaningful. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Resolve the blob, inspect its content and test with check-mailmap.

For the mailmap.blob supports repository objects chapter on Git mailmap, 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 an unverified object name into configuration and assuming it will remain meaningful. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git config mailmap.blob main:.mailmap
git show main:.mailmap

Explained result. The configured revision expression supplies mailmap contents from repository data. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: coding assignment. Contrast the rule using old and current student email addresses. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “mailmap.blob can select mailmap data from a blob, useful where no checked-out top-level file is available, including bare-repository workflows.” Apply this procedure: Resolve the blob, inspect its content and test with check-mailmap. The expected mechanism is: The configured revision expression supplies mailmap contents from repository data. For the coding assignment, add one near-miss that exposes writing an unverified object name into configuration and assuming it will remain meaningful. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: group project. Stress-test the rule using name variants from several laptops. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “mailmap.blob can select mailmap data from a blob, useful where no checked-out top-level file is available, including bare-repository workflows.” Apply this procedure: Resolve the blob, inspect its content and test with check-mailmap. The expected mechanism is: The configured revision expression supplies mailmap contents from repository data. For the group project, add one near-miss that exposes writing an unverified object name into configuration and assuming it will remain meaningful. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: website repository. Explain the rule using a bot and a person sharing a legacy address. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “mailmap.blob can select mailmap data from a blob, useful where no checked-out top-level file is available, including bare-repository workflows.” Apply this procedure: Resolve the blob, inspect its content and test with check-mailmap. The expected mechanism is: The configured revision expression supplies mailmap contents from repository data. For the website repository, add one near-miss that exposes writing an unverified object name into configuration and assuming it will remain meaningful. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: science scripts. Transfer the rule using institutional and personal email variants. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “mailmap.blob can select mailmap data from a blob, useful where no checked-out top-level file is available, including bare-repository workflows.” Apply this procedure: Resolve the blob, inspect its content and test with check-mailmap. The expected mechanism is: The configured revision expression supplies mailmap contents from repository data. For the science scripts, add one near-miss that exposes writing an unverified object name into configuration and assuming it will remain meaningful. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers writing an unverified object name into configuration and assuming it will remain meaningful.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Resolve the blob, inspect its content and test with check-mailmap.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from mailmap.blob supports repository objects?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing writing an unverified object name into configuration and assuming it will remain meaningful be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family coding project with several machines with inconsistent Git config. Include one ordinary case, one boundary and one deliberate failure caused by writing an unverified object name into configuration and assuming it will remain meaningful. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: mailmap.blob can select mailmap data from a blob, useful where no checked-out top-level file is available, including bare-repository workflows. It shows a trace, not only a final value. The ordinary case should demonstrate “The configured revision expression supplies mailmap contents from repository data.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Resolve the blob, inspect its content and test with check-mailmap. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For mailmap.blob supports repository objects, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 18 OF 20 . Transfer with judgment

18. Multiple sources need an observed precedence model

Back to contents

When repository and configured sources coexist, the effective result should be verified against current Git documentation and check-mailmap rather than inferred from filenames. 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 adding conflicting aliases across sources and trusting an accidental winner. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use git config –show-origin, inspect every source and eliminate conflicts.

For the Multiple sources need an observed precedence model chapter on Git mailmap, 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 adding conflicting aliases across sources and trusting an accidental winner. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git config --show-origin --get-all mailmap.file
git check-mailmap 'Old <old@example.test>'

Explained result. The diagnostic identifies configured sources and the final canonicalised identity. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: website repository. Stress-test the rule using a bot and a person sharing a legacy address. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “When repository and configured sources coexist, the effective result should be verified against current Git documentation and check-mailmap rather than inferred from filenames.” Apply this procedure: Use git config –show-origin, inspect every source and eliminate conflicts. The expected mechanism is: The diagnostic identifies configured sources and the final canonicalised identity. For the website repository, add one near-miss that exposes adding conflicting aliases across sources and trusting an accidental winner. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: science scripts. Explain the rule using institutional and personal email variants. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “When repository and configured sources coexist, the effective result should be verified against current Git documentation and check-mailmap rather than inferred from filenames.” Apply this procedure: Use git config –show-origin, inspect every source and eliminate conflicts. The expected mechanism is: The diagnostic identifies configured sources and the final canonicalised identity. For the science scripts, add one near-miss that exposes adding conflicting aliases across sources and trusting an accidental winner. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: revision repository. Transfer the rule using misspelled author names in earlier commits. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “When repository and configured sources coexist, the effective result should be verified against current Git documentation and check-mailmap rather than inferred from filenames.” Apply this procedure: Use git config –show-origin, inspect every source and eliminate conflicts. The expected mechanism is: The diagnostic identifies configured sources and the final canonicalised identity. For the revision repository, add one near-miss that exposes adding conflicting aliases across sources and trusting an accidental winner. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: family coding project. Predict the rule using several machines with inconsistent Git config. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “When repository and configured sources coexist, the effective result should be verified against current Git documentation and check-mailmap rather than inferred from filenames.” Apply this procedure: Use git config –show-origin, inspect every source and eliminate conflicts. The expected mechanism is: The diagnostic identifies configured sources and the final canonicalised identity. For the family coding project, add one near-miss that exposes adding conflicting aliases across sources and trusting an accidental winner. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers adding conflicting aliases across sources and trusting an accidental winner.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Use git config –show-origin, inspect every source and eliminate conflicts.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from Multiple sources need an observed precedence model?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing adding conflicting aliases across sources and trusting an accidental winner be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny public contribution lab with canonical display names with preserved history. Include one ordinary case, one boundary and one deliberate failure caused by adding conflicting aliases across sources and trusting an accidental winner. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: When repository and configured sources coexist, the effective result should be verified against current Git documentation and check-mailmap rather than inferred from filenames. It shows a trace, not only a final value. The ordinary case should demonstrate “The diagnostic identifies configured sources and the final canonicalised identity.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use git config –show-origin, inspect every source and eliminate conflicts. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Multiple sources need an observed precedence model, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 19 OF 20 . Transfer with judgment

19. Mailmap is not a privacy eraser

Back to contents

Original names and emails remain in commit objects and reachable history even when common views show canonical forms. 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 adding a redacted display and claiming sensitive data has been removed. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Treat exposure as a history-remediation and hosting-policy issue, with backups and specialist review.

For the Mailmap is not a privacy eraser chapter on Git mailmap, 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 adding a redacted display and claiming sensitive data has been removed. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git cat-file -p HEAD | grep -E '^(author|committer) '

Explained result. The raw headers demonstrate why mailmap alone cannot remove historical personal data. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: revision repository. Explain the rule using misspelled author names in earlier commits. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Original names and emails remain in commit objects and reachable history even when common views show canonical forms.” Apply this procedure: Treat exposure as a history-remediation and hosting-policy issue, with backups and specialist review. The expected mechanism is: The raw headers demonstrate why mailmap alone cannot remove historical personal data. For the revision repository, add one near-miss that exposes adding a redacted display and claiming sensitive data has been removed. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: family coding project. Transfer the rule using several machines with inconsistent Git config. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Original names and emails remain in commit objects and reachable history even when common views show canonical forms.” Apply this procedure: Treat exposure as a history-remediation and hosting-policy issue, with backups and specialist review. The expected mechanism is: The raw headers demonstrate why mailmap alone cannot remove historical personal data. For the family coding project, add one near-miss that exposes adding a redacted display and claiming sensitive data has been removed. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: public contribution lab. Predict the rule using canonical display names with preserved history. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Original names and emails remain in commit objects and reachable history even when common views show canonical forms.” Apply this procedure: Treat exposure as a history-remediation and hosting-policy issue, with backups and specialist review. The expected mechanism is: The raw headers demonstrate why mailmap alone cannot remove historical personal data. For the public contribution lab, add one near-miss that exposes adding a redacted display and claiming sensitive data has been removed. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: disposable Git laboratory. Contrast the rule using controlled commits, four mapping forms and exact assertions. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “Original names and emails remain in commit objects and reachable history even when common views show canonical forms.” Apply this procedure: Treat exposure as a history-remediation and hosting-policy issue, with backups and specialist review. The expected mechanism is: The raw headers demonstrate why mailmap alone cannot remove historical personal data. For the disposable Git laboratory, add one near-miss that exposes adding a redacted display and claiming sensitive data has been removed. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers adding a redacted display and claiming sensitive data has been removed.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Treat exposure as a history-remediation and hosting-policy issue, with backups and specialist review.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from Mailmap is not a privacy eraser?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing adding a redacted display and claiming sensitive data has been removed be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny disposable Git laboratory with controlled commits, four mapping forms and exact assertions. Include one ordinary case, one boundary and one deliberate failure caused by adding a redacted display and claiming sensitive data has been removed. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: Original names and emails remain in commit objects and reachable history even when common views show canonical forms. It shows a trace, not only a final value. The ordinary case should demonstrate “The raw headers demonstrate why mailmap alone cannot remove historical personal data.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Treat exposure as a history-remediation and hosting-policy issue, with backups and specialist review. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Mailmap is not a privacy eraser, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 20 OF 20 . Transfer with judgment

20. A disposable history lab proves the policy

Back to contents

A complete lab creates commits under controlled aliases, adds each mapping form, tests raw and mapped placeholders, shortlog, blame and unchanged object IDs. 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 testing only one happy-path log line in an important repository. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use a temporary repository and assert canonical outputs plus deliberate non-matches.

For the A disposable history lab proves the policy chapter on Git mailmap, 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 testing only one happy-path log line in an important repository. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

tmp=$(mktemp -d)
git -C "$tmp" init
printf 'lab
' > "$tmp/README.md"

Explained result. The disposable repository makes identity experiments repeatable without altering school or production history. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: public contribution lab. Transfer the rule using canonical display names with preserved history. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A complete lab creates commits under controlled aliases, adds each mapping form, tests raw and mapped placeholders, shortlog, blame and unchanged object IDs.” Apply this procedure: Use a temporary repository and assert canonical outputs plus deliberate non-matches. The expected mechanism is: The disposable repository makes identity experiments repeatable without altering school or production history. For the public contribution lab, add one near-miss that exposes testing only one happy-path log line in an important repository. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: disposable Git laboratory. Predict the rule using controlled commits, four mapping forms and exact assertions. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A complete lab creates commits under controlled aliases, adds each mapping form, tests raw and mapped placeholders, shortlog, blame and unchanged object IDs.” Apply this procedure: Use a temporary repository and assert canonical outputs plus deliberate non-matches. The expected mechanism is: The disposable repository makes identity experiments repeatable without altering school or production history. For the disposable Git laboratory, add one near-miss that exposes testing only one happy-path log line in an important repository. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: coding assignment. Contrast the rule using old and current student email addresses. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A complete lab creates commits under controlled aliases, adds each mapping form, tests raw and mapped placeholders, shortlog, blame and unchanged object IDs.” Apply this procedure: Use a temporary repository and assert canonical outputs plus deliberate non-matches. The expected mechanism is: The disposable repository makes identity experiments repeatable without altering school or production history. For the coding assignment, add one near-miss that exposes testing only one happy-path log line in an important repository. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: group project. Stress-test the rule using name variants from several laptops. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “A complete lab creates commits under controlled aliases, adds each mapping form, tests raw and mapped placeholders, shortlog, blame and unchanged object IDs.” Apply this procedure: Use a temporary repository and assert canonical outputs plus deliberate non-matches. The expected mechanism is: The disposable repository makes identity experiments repeatable without altering school or production history. For the group project, add one near-miss that exposes testing only one happy-path log line in an important repository. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers testing only one happy-path log line in an important repository.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Use a temporary repository and assert canonical outputs plus deliberate non-matches.” 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 mailmap syntax. For this chapter, useful prompts are: “What did you expect from A disposable history lab proves the policy?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing testing only one happy-path log line in an important repository be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny coding assignment with old and current student email addresses. Include one ordinary case, one boundary and one deliberate failure caused by testing only one happy-path log line in an important repository. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: A complete lab creates commits under controlled aliases, adds each mapping form, tests raw and mapped placeholders, shortlog, blame and unchanged object IDs. It shows a trace, not only a final value. The ordinary case should demonstrate “The disposable repository makes identity experiments repeatable without altering school or production history.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use a temporary repository and assert canonical outputs plus deliberate non-matches. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For A disposable history lab proves the policy, separate the documented Git mailmap mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Parent guide: choose the next useful step

Start with evidence, not a label such as careless. Ask for one prediction and one trace. If the first transition is wrong, rebuild the model. If the model is sound but syntax fails, practise reference use. If routine cases are correct but boundaries fail, vary ties, defaults, unsupported inputs, ownership or missing paths. If explanations transfer, move to a small project.

Keep a weekly record with four lines: concept, prediction, observed difference and next test. Stop when fatigue replaces reasoning. A smaller case tomorrow is more useful than another hour of copying tonight.

Seek specialist help when cause and effect remain invisible after examples are reduced, when accessibility or data-loss implications are unclear, or when an important repository, database or application state may be at risk. Good support should make the learner’s reasoning more independent.

Capstone practice with explained routes

1. coding assignment: model, boundary and recovery

Create a small coding assignment using old and current student email addresses. Combine “Mailmap changes display, not history” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Explained route. Start with: A mailmap supplies canonical names and emails to supporting Git commands while original commit object bytes and IDs remain unchanged. Apply: Record commit IDs and raw author headers before and after adding .mailmap. Verify: The mapped display can change while the original author header and commit ID stay intact. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.

2. group project: model, boundary and recovery

Create a small group project using name variants from several laptops. Combine “The simple form replaces a name” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Explained route. Start with: Canonical Name maps commits with that email to the canonical name while retaining the historical email. Apply: Run check-mailmap and compare both output fields. Verify: An input using old@example.test displays Student Lee but keeps old@example.test as its email. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.

3. website repository: model, boundary and recovery

Create a small website repository using a bot and a person sharing a legacy address. Combine “The four-field form disambiguates shared addresses” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Explained route. Start with: Canonical Name Commit Name requires both historical name and email to match. Apply: Use exact historical pairs when an address was shared. Verify: Only the Lee identity at the shared bugs address receives this canonical mapping. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.

4. science scripts: model, boundary and recovery

Create a small science scripts using institutional and personal email variants. Combine “Log placeholders expose raw and mapped identities” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Explained route. Start with: Pretty formats provide lowercase raw author placeholders and uppercase mailmap-aware forms, with corresponding committer forms. Apply: Print raw and canonical fields side by side. Verify: The left side shows stored author data; the right side shows mailmap-resolved author data. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.

5. revision repository: model, boundary and recovery

Create a small revision repository using misspelled author names in earlier commits. Combine “Blame can display mapped identities” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Explained route. Start with: git blame can use mailmap-aware identity display, but the blamed commit and stored metadata remain unchanged. Apply: Compare blame output with git cat-file for the same commit. Verify: The line attribution can show canonical names while raw commit data remains available. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.

6. family coding project: model, boundary and recovery

Create a small family coding project using several machines with inconsistent Git config. Combine “mailmap.file selects another file” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Explained route. Start with: The mailmap.file configuration can point to an additional or alternative file according to Git configuration scope and path rules. Apply: Inspect value and origin, then test inside the intended repository. Verify: The output reveals which configuration file selected the mailmap path. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.

7. public contribution lab: model, boundary and recovery

Create a small public contribution lab using canonical display names with preserved history. Combine “Mailmap is not a privacy eraser” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Explained route. Start with: Original names and emails remain in commit objects and reachable history even when common views show canonical forms. Apply: Treat exposure as a history-remediation and hosting-policy issue, with backups and specialist review. Verify: The raw headers demonstrate why mailmap alone cannot remove historical personal data. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.

8. disposable Git laboratory: model, boundary and recovery

Create a small disposable Git laboratory using controlled commits, four mapping forms and exact assertions. Combine “The conventional file is top-level .mailmap” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Explained route. Start with: Git reads .mailmap at the repository top level, with configuration alternatives available for other storage choices. Apply: Resolve the repository root and verify the effective mapping with check-mailmap. Verify: The conventional project file belongs at the worktree root and can be version-controlled. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.

Frequently asked questions

How long should a practice session be?

Use one complete prediction–observation–explanation cycle while attention remains good. Ten to twenty focused minutes can be enough.

Should every option or function be memorised?

No. Memorise the governing distinctions and practise retrieving the official reference. Understanding means predicting and explaining, not reciting a parameter list.

What if the result is correct but the explanation is weak?

Treat it as partial success. Ask for a trace and change one boundary. A reliable model survives controlled variation.

Is the shortest solution the best?

Not automatically. Prefer the solution whose semantics, failure modes and maintenance cost are easiest to justify for the actual project.

When should official documentation be used?

Use it whenever syntax, supported types, SQL dialect behaviour or Git version details matter. Primary documentation settles the current contract.

How can a parent help without technical expertise?

Ask what was predicted, where the first difference appeared, what evidence matters and which smaller example could isolate it.

How do we test transfer?

Change the context, vocabulary and one boundary. Require the learner to identify the invariant before using a tool.

What should be saved after practice?

Keep the corrected rule, one trace, one boundary case and the next question. Avoid storing pages of unexplained output.

Can these exercises replace backups?

No. Use disposable examples and proper backups. Learning should not endanger schoolwork, repositories or personal data.

What counts as mastery?

The learner can predict, verify, diagnose, recover and justify a choice across more than one context, while knowing when to consult the current reference.

Official and supporting references

Return to contents

eduKate Punggol

Build the model

Use the core tools

Handle boundaries

Debug and verify

Transfer with judgment

eduKate Punggol

Contact

Menu

Email Us

感谢您的回复。 ✨

Small Group Tutorials

How to Master Git .mailmap in Punggol Tuition

Find your next learning step

Build the model

Use the core tools

Handle boundaries

Debug and verify

Transfer with judgment

Complete chapter index

1. Mailmap changes display, not history

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

2. The conventional file is top-level .mailmap

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

3. Comments and blank lines document policy

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

4. The simple form replaces a name

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

5. The email-only form replaces an email

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

6. Name plus email can map by old email

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

7. The four-field form disambiguates shared addresses

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

8. Matching names and emails is case-insensitive

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

9. check-mailmap is the direct diagnostic

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

10. Log placeholders expose raw and mapped identities

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

11. Log can opt into mailmap-aware display

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

12. Shortlog is a core mailmap use case

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer