How to Master Git mktag 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 mktag reads an annotated-tag object body from standard input, validates it more strictly than a plain tag hash-object write, stores the valid tag object and prints its object ID. It does not create a refs/tags name. Mastery means separating object bytes, target-object validation, the returned tag-object ID and any later ref update. 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

mktag reads a tag body from standard input
The result is an annotated tag object
No refs/tags name is created automatically
The object header names the target object

Chapters 5-8 . Use the core tools

The type header must match the target
The tag header stores the tag name inside the object
The tagger line records identity and time
A blank line separates headers from the message

Chapters 9-12 . Handle boundaries

The message participates in object identity
A signature may live in the message
mktag validates before writing
Strict validation is the default

Chapters 13-16 . Debug and verify

–no-strict deliberately relaxes strict mode
fsck message configuration can target an exception
Target-object existence is checked
Tag objects can point to several Git object types

Chapters 17-20 . Transfer with judgment

Byte-exact input makes line endings important
cat-file is the inspection surface
A ref update is a separate reviewed write
Mastery uses a disposable object database

CHAPTER 1 OF 20 . Build the model

1. mktag reads a tag body from standard input

Back to contents

The command consumes tag-object content on stdin and prints the object ID after successful creation. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is passing a tag name as a positional argument as though this were git tag. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Prepare a text file, inspect every byte and redirect it into git mktag.

For the mktag reads a tag body from standard input chapter on Git mktag, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on passing a tag name as a positional argument as though this were git tag. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git mktag <tag-body.txt

Explained result. A valid body produces one object ID on standard output. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: homework repository. Predict the rule using an annotated checkpoint for a finished coding exercise. 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 command consumes tag-object content on stdin and prints the object ID after successful creation.” Apply this procedure: Prepare a text file, inspect every byte and redirect it into git mktag. The expected mechanism is: A valid body produces one object ID on standard output. For the homework repository, add one near-miss that exposes passing a tag name as a positional argument as though this were git tag. 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: library catalogue repo. Contrast the rule using a reviewed import milestone tag. 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 command consumes tag-object content on stdin and prints the object ID after successful creation.” Apply this procedure: Prepare a text file, inspect every byte and redirect it into git mktag. The expected mechanism is: A valid body produces one object ID on standard output. For the library catalogue repo, add one near-miss that exposes passing a tag name as a positional argument as though this were git tag. 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: CCA website repo. Stress-test the rule using a release-candidate tag for a registration page. 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 command consumes tag-object content on stdin and prints the object ID after successful creation.” Apply this procedure: Prepare a text file, inspect every byte and redirect it into git mktag. The expected mechanism is: A valid body produces one object ID on standard output. For the CCA website repo, add one near-miss that exposes passing a tag name as a positional argument as though this were git tag. 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-data repo. Explain the rule using a tag object marking a verified dataset snapshot. 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 command consumes tag-object content on stdin and prints the object ID after successful creation.” Apply this procedure: Prepare a text file, inspect every byte and redirect it into git mktag. The expected mechanism is: A valid body produces one object ID on standard output. For the science-data repo, add one near-miss that exposes passing a tag name as a positional argument as though this were git tag. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers passing a tag name as a positional argument as though this were git tag.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Prepare a text file, inspect every byte and redirect it into git mktag.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from mktag reads a tag body from standard input?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing passing a tag name as a positional argument as though this were git tag be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny photo-index repo with a catalogue release with a descriptive message. Include one ordinary case, one boundary and one deliberate failure caused by passing a tag name as a positional argument as though this were git tag. 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 command consumes tag-object content on stdin and prints the object ID after successful creation. It shows a trace, not only a final value. The ordinary case should demonstrate “A valid body produces one object ID on standard output.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Prepare a text file, inspect every byte and redirect it into git mktag. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For mktag reads a tag body from standard input, separate the documented Git mktag 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 result is an annotated tag object

Back to contents

The stored object has type tag and contains headers plus an optional message; it is not a lightweight tag reference. 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 annotated and lightweight tag as interchangeable names for the same storage. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Inspect the returned ID with cat-file -t and cat-file -p.

For the The result is an annotated tag object chapter on Git mktag, 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 annotated and lightweight tag as interchangeable names for the same storage. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

oid=$(git mktag <tag-body.txt)
git cat-file -t "$oid"

Explained result. cat-file reports tag for the object type. 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: CCA website repo. Contrast the rule using a release-candidate tag for a registration page. 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 stored object has type tag and contains headers plus an optional message; it is not a lightweight tag reference.” Apply this procedure: Inspect the returned ID with cat-file -t and cat-file -p. The expected mechanism is: cat-file reports tag for the object type. For the CCA website repo, add one near-miss that exposes using annotated and lightweight tag as interchangeable names for the same storage. 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-data repo. Stress-test the rule using a tag object marking a verified dataset snapshot. 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 stored object has type tag and contains headers plus an optional message; it is not a lightweight tag reference.” Apply this procedure: Inspect the returned ID with cat-file -t and cat-file -p. The expected mechanism is: cat-file reports tag for the object type. For the science-data repo, add one near-miss that exposes using annotated and lightweight tag as interchangeable names for the same storage. 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-note repo. Explain the rule using a tagged study-guide edition. 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 stored object has type tag and contains headers plus an optional message; it is not a lightweight tag reference.” Apply this procedure: Inspect the returned ID with cat-file -t and cat-file -p. The expected mechanism is: cat-file reports tag for the object type. For the revision-note repo, add one near-miss that exposes using annotated and lightweight tag as interchangeable names for the same storage. 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: photo-index repo. Transfer the rule using a catalogue release with a descriptive message. 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 stored object has type tag and contains headers plus an optional message; it is not a lightweight tag reference.” Apply this procedure: Inspect the returned ID with cat-file -t and cat-file -p. The expected mechanism is: cat-file reports tag for the object type. For the photo-index repo, add one near-miss that exposes using annotated and lightweight tag as interchangeable names for the same storage. 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 annotated and lightweight tag as interchangeable names for the same storage.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Inspect the returned ID with cat-file -t and cat-file -p.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from The result is an annotated tag object?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using annotated and lightweight tag as interchangeable names for the same storage be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny budget-tool repo with an audited calculation milestone. Include one ordinary case, one boundary and one deliberate failure caused by using annotated and lightweight tag as interchangeable names for the same storage. 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 stored object has type tag and contains headers plus an optional message; it is not a lightweight tag reference. It shows a trace, not only a final value. The ordinary case should demonstrate “cat-file reports tag for the object type.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Inspect the returned ID with cat-file -t and cat-file -p. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For The result is an annotated tag object, separate the documented Git mktag 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. No refs/tags name is created automatically

Back to contents

Writing the object database and naming it under refs/tags are separate operations. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is assuming a successful mktag immediately appears in git tag –list. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Run show-ref before and after an explicit, reviewed ref update.

For the No refs/tags name is created automatically chapter on Git mktag, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming a successful mktag immediately appears in git tag –list. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

oid=$(git mktag <tag-body.txt)
git show-ref --tags

Explained result. The new object can exist without any tag ref pointing to it. 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-note repo. Stress-test the rule using a tagged study-guide edition. 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 “Writing the object database and naming it under refs/tags are separate operations.” Apply this procedure: Run show-ref before and after an explicit, reviewed ref update. The expected mechanism is: The new object can exist without any tag ref pointing to it. For the revision-note repo, add one near-miss that exposes assuming a successful mktag immediately appears in git tag –list. 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: photo-index repo. Explain the rule using a catalogue release with a descriptive message. 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 “Writing the object database and naming it under refs/tags are separate operations.” Apply this procedure: Run show-ref before and after an explicit, reviewed ref update. The expected mechanism is: The new object can exist without any tag ref pointing to it. For the photo-index repo, add one near-miss that exposes assuming a successful mktag immediately appears in git tag –list. 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: budget-tool repo. Transfer the rule using an audited calculation milestone. 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 “Writing the object database and naming it under refs/tags are separate operations.” Apply this procedure: Run show-ref before and after an explicit, reviewed ref update. The expected mechanism is: The new object can exist without any tag ref pointing to it. For the budget-tool repo, add one near-miss that exposes assuming a successful mktag immediately appears in git tag –list. 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: project build repo. Predict the rule using a signed release object inspected before a ref update. 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 “Writing the object database and naming it under refs/tags are separate operations.” Apply this procedure: Run show-ref before and after an explicit, reviewed ref update. The expected mechanism is: The new object can exist without any tag ref pointing to it. For the project build repo, add one near-miss that exposes assuming a successful mktag immediately appears in git tag –list. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers assuming a successful mktag immediately appears in git tag –list.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Run show-ref before and after an explicit, reviewed ref update.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from No refs/tags name is created automatically?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming a successful mktag immediately appears in git tag –list be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny project build repo with a signed release object inspected before a ref update. Include one ordinary case, one boundary and one deliberate failure caused by assuming a successful mktag immediately appears in git tag –list. 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: Writing the object database and naming it under refs/tags are separate operations. It shows a trace, not only a final value. The ordinary case should demonstrate “The new object can exist without any tag ref pointing to it.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Run show-ref before and after an explicit, reviewed ref update. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For No refs/tags name is created automatically, separate the documented Git mktag 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 object header names the target object

Back to contents

The first header is object followed by the hexadecimal object ID that the tag points to. 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 the new tag-object ID in the object header instead of the intended target. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Resolve and inspect the target before composing the body.

For the The object header names the target object chapter on Git mktag, 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 the new tag-object ID in the object header instead of the intended target. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

target=$(git rev-parse HEAD)
printf 'object %s\n' "$target"

Explained result. The header should contain the commit ID selected as the tag target. 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: budget-tool repo. Explain the rule using an audited calculation milestone. 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 first header is object followed by the hexadecimal object ID that the tag points to.” Apply this procedure: Resolve and inspect the target before composing the body. The expected mechanism is: The header should contain the commit ID selected as the tag target. For the budget-tool repo, add one near-miss that exposes placing the new tag-object ID in the object header instead of the intended target. 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: project build repo. Transfer the rule using a signed release object inspected before a ref update. 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 first header is object followed by the hexadecimal object ID that the tag points to.” Apply this procedure: Resolve and inspect the target before composing the body. The expected mechanism is: The header should contain the commit ID selected as the tag target. For the project build repo, add one near-miss that exposes placing the new tag-object ID in the object header instead of the intended target. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: homework repository. Predict the rule using an annotated checkpoint for a finished coding exercise. 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 first header is object followed by the hexadecimal object ID that the tag points to.” Apply this procedure: Resolve and inspect the target before composing the body. The expected mechanism is: The header should contain the commit ID selected as the tag target. For the homework repository, add one near-miss that exposes placing the new tag-object ID in the object header instead of the intended target. 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: library catalogue repo. Contrast the rule using a reviewed import milestone tag. 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 first header is object followed by the hexadecimal object ID that the tag points to.” Apply this procedure: Resolve and inspect the target before composing the body. The expected mechanism is: The header should contain the commit ID selected as the tag target. For the library catalogue repo, add one near-miss that exposes placing the new tag-object ID in the object header instead of the intended target. 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 the new tag-object ID in the object header instead of the intended target.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Resolve and inspect the target before composing the body.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from The object header names the target object?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing placing the new tag-object ID in the object header instead of the intended target be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework repository with an annotated checkpoint for a finished coding exercise. Include one ordinary case, one boundary and one deliberate failure caused by placing the new tag-object ID in the object header instead of the intended target. 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 first header is object followed by the hexadecimal object ID that the tag points to. It shows a trace, not only a final value. The ordinary case should demonstrate “The header should contain the commit ID selected as the tag target.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Resolve and inspect the target before composing the body. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For The object header names the target object, separate the documented Git mktag 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 type header must match the target

Back to contents

The type line names the actual object type of the target, such as commit, tree, blob or tag. 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 hard-coding type commit when the object header points to a tree. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Ask git cat-file -t for the target and use the observed type.

For the The type header must match the target chapter on Git mktag, 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 hard-coding type commit when the object header points to a tree. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

target=$(git rev-parse HEAD^{tree})
type=$(git cat-file -t "$target")
echo "$type"

Explained result. For HEAD^{tree}, the observed type is tree and the tag body must say type tree. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: homework repository. Transfer the rule using an annotated checkpoint for a finished coding exercise. 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 type line names the actual object type of the target, such as commit, tree, blob or tag.” Apply this procedure: Ask git cat-file -t for the target and use the observed type. The expected mechanism is: For HEAD^{tree}, the observed type is tree and the tag body must say type tree. For the homework repository, add one near-miss that exposes hard-coding type commit when the object header points to a tree. 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: library catalogue repo. Predict the rule using a reviewed import milestone tag. 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 type line names the actual object type of the target, such as commit, tree, blob or tag.” Apply this procedure: Ask git cat-file -t for the target and use the observed type. The expected mechanism is: For HEAD^{tree}, the observed type is tree and the tag body must say type tree. For the library catalogue repo, add one near-miss that exposes hard-coding type commit when the object header points to a tree. 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: CCA website repo. Contrast the rule using a release-candidate tag for a registration page. 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 type line names the actual object type of the target, such as commit, tree, blob or tag.” Apply this procedure: Ask git cat-file -t for the target and use the observed type. The expected mechanism is: For HEAD^{tree}, the observed type is tree and the tag body must say type tree. For the CCA website repo, add one near-miss that exposes hard-coding type commit when the object header points to a tree. 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-data repo. Stress-test the rule using a tag object marking a verified dataset snapshot. 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 type line names the actual object type of the target, such as commit, tree, blob or tag.” Apply this procedure: Ask git cat-file -t for the target and use the observed type. The expected mechanism is: For HEAD^{tree}, the observed type is tree and the tag body must say type tree. For the science-data repo, add one near-miss that exposes hard-coding type commit when the object header points to a tree. 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 hard-coding type commit when the object header points to a tree.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Ask git cat-file -t for the target and use the observed type.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from The type header must match the target?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing hard-coding type commit when the object header points to a tree be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library catalogue repo with a reviewed import milestone tag. Include one ordinary case, one boundary and one deliberate failure caused by hard-coding type commit when the object header points to a tree. 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 type line names the actual object type of the target, such as commit, tree, blob or tag. It shows a trace, not only a final value. The ordinary case should demonstrate “For HEAD^{tree}, the observed type is tree and the tag body must say type tree.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Ask git cat-file -t for the target and use the observed type. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For The type header must match the target, separate the documented Git mktag 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. The tag header stores the tag name inside the object

Back to contents

The tag line records a tag name as tag-object metadata, distinct from any ref name created later. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is assuming the internal tag value forces the external refs/tags path. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compare cat-file output with show-ref after creating a deliberately named ref.

For the The tag header stores the tag name inside the object chapter on Git mktag, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming the internal tag value forces the external refs/tags path. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

printf 'tag lesson-checkpoint\n'

Explained result. The internal name becomes part of the object bytes but does not create refs/tags/lesson-checkpoint. 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: CCA website repo. Predict the rule using a release-candidate tag for a registration page. 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 tag line records a tag name as tag-object metadata, distinct from any ref name created later.” Apply this procedure: Compare cat-file output with show-ref after creating a deliberately named ref. The expected mechanism is: The internal name becomes part of the object bytes but does not create refs/tags/lesson-checkpoint. For the CCA website repo, add one near-miss that exposes assuming the internal tag value forces the external refs/tags path. 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-data repo. Contrast the rule using a tag object marking a verified dataset snapshot. 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 tag line records a tag name as tag-object metadata, distinct from any ref name created later.” Apply this procedure: Compare cat-file output with show-ref after creating a deliberately named ref. The expected mechanism is: The internal name becomes part of the object bytes but does not create refs/tags/lesson-checkpoint. For the science-data repo, add one near-miss that exposes assuming the internal tag value forces the external refs/tags path. 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-note repo. Stress-test the rule using a tagged study-guide edition. 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 tag line records a tag name as tag-object metadata, distinct from any ref name created later.” Apply this procedure: Compare cat-file output with show-ref after creating a deliberately named ref. The expected mechanism is: The internal name becomes part of the object bytes but does not create refs/tags/lesson-checkpoint. For the revision-note repo, add one near-miss that exposes assuming the internal tag value forces the external refs/tags path. 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: photo-index repo. Explain the rule using a catalogue release with a descriptive message. 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 tag line records a tag name as tag-object metadata, distinct from any ref name created later.” Apply this procedure: Compare cat-file output with show-ref after creating a deliberately named ref. The expected mechanism is: The internal name becomes part of the object bytes but does not create refs/tags/lesson-checkpoint. For the photo-index repo, add one near-miss that exposes assuming the internal tag value forces the external refs/tags path. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers assuming the internal tag value forces the external refs/tags path.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Compare cat-file output with show-ref after creating a deliberately named ref.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from The tag header stores the tag name inside the object?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming the internal tag value forces the external refs/tags path be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA website repo with a release-candidate tag for a registration page. Include one ordinary case, one boundary and one deliberate failure caused by assuming the internal tag value forces the external refs/tags path. 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 tag line records a tag name as tag-object metadata, distinct from any ref name created later. It shows a trace, not only a final value. The ordinary case should demonstrate “The internal name becomes part of the object bytes but does not create refs/tags/lesson-checkpoint.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Compare cat-file output with show-ref after creating a deliberately named ref. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For The tag header stores the tag name inside the object, separate the documented Git mktag 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 tagger line records identity and time

Back to contents

A normal tagger line contains name, email, Unix timestamp and numeric timezone offset in the expected format. 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 inventing a free-form sentence after tagger and receiving validation failure. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use a fixed test identity and timestamp in a disposable repository, then inspect the stored line.

For the The tagger line records identity and time chapter on Git mktag, 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 inventing a free-form sentence after tagger and receiving validation failure. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

printf 'tagger Learner <learner@example.test> 1700000000 +0800\n'

Explained result. The line supplies structured identity and time metadata suitable for the tag format. 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-note repo. Contrast the rule using a tagged study-guide edition. 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 normal tagger line contains name, email, Unix timestamp and numeric timezone offset in the expected format.” Apply this procedure: Use a fixed test identity and timestamp in a disposable repository, then inspect the stored line. The expected mechanism is: The line supplies structured identity and time metadata suitable for the tag format. For the revision-note repo, add one near-miss that exposes inventing a free-form sentence after tagger and receiving validation failure. 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: photo-index repo. Stress-test the rule using a catalogue release with a descriptive message. 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 normal tagger line contains name, email, Unix timestamp and numeric timezone offset in the expected format.” Apply this procedure: Use a fixed test identity and timestamp in a disposable repository, then inspect the stored line. The expected mechanism is: The line supplies structured identity and time metadata suitable for the tag format. For the photo-index repo, add one near-miss that exposes inventing a free-form sentence after tagger and receiving validation failure. 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: budget-tool repo. Explain the rule using an audited calculation milestone. 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 normal tagger line contains name, email, Unix timestamp and numeric timezone offset in the expected format.” Apply this procedure: Use a fixed test identity and timestamp in a disposable repository, then inspect the stored line. The expected mechanism is: The line supplies structured identity and time metadata suitable for the tag format. For the budget-tool repo, add one near-miss that exposes inventing a free-form sentence after tagger and receiving validation failure. 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: project build repo. Transfer the rule using a signed release object inspected before a ref update. 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 normal tagger line contains name, email, Unix timestamp and numeric timezone offset in the expected format.” Apply this procedure: Use a fixed test identity and timestamp in a disposable repository, then inspect the stored line. The expected mechanism is: The line supplies structured identity and time metadata suitable for the tag format. For the project build repo, add one near-miss that exposes inventing a free-form sentence after tagger and receiving validation failure. 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 inventing a free-form sentence after tagger and receiving validation failure.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Use a fixed test identity and timestamp in a disposable repository, then inspect the stored line.” and record the first changed observation.
Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git mktag syntax. For this chapter, useful prompts are: “What did you expect from The tagger line records identity and time?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing inventing a free-form sentence after tagger and receiving validation failure be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science-data repo with a tag object marking a verified dataset snapshot. Include one ordinary case, one boundary and one deliberate failure caused by inventing a free-form sentence after tagger and receiving validation failure. 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 normal tagger line contains name, email, Unix timestamp and numeric timezone offset in the expected format. It shows a trace, not only a final value. The ordinary case should demonstrate “The line supplies structured identity and time metadata suitable for the tag format.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use a fixed test identity and timestamp in a disposable repository, then inspect the stored line. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For The tagger line records identity and time, separate the documented Git mktag 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. A blank line separates headers from the message

Back to contents

After the fixed header lines, an empty line marks the beginning of the optional free-form message. 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 the message directly after tagger and turning it into an invalid header. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Show line numbers and invisible line endings before submission.

For the A blank line separates headers from the message chapter on Git mktag, 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 the message directly after tagger and turning it into an invalid header. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

printf '\nVerified practice snapshot.\n'

Explained result. The leading blank line ends the header section and the following text is the message. 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: budget-tool repo. Stress-test the rule using an audited calculation milestone. 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 “After the fixed header lines, an empty line marks the beginning of the optional free-form message.” Apply this procedure: Show line numbers and invisible line endings before submission. The expected mechanism is: The leading blank line ends the header section and the following text is the message. For the budget-tool repo, add one near-miss that exposes placing the message directly after tagger and turning it into an invalid header. 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: project build repo. Explain the rule using a signed release object inspected before a ref update. 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 “After the fixed header lines, an empty line marks the beginning of the optional free-form message.” Apply this procedure: Show line numbers and invisible line endings before submission. The expected mechanism is: The leading blank line ends the header section and the following text is the message. For the project build repo, add one near-miss that exposes placing the message directly after tagger and turning it into an invalid header. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: homework repository. Transfer the rule using an annotated checkpoint for a finished coding exercise. 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 “After the fixed header lines, an empty line marks the beginning of the optional free-form message.” Apply this procedure: Show line numbers and invisible line endings before submission. The expected mechanism is: The leading blank line ends the header section and the following text is the message. For the homework repository, add one near-miss that exposes placing the message directly after tagger and turning it into an invalid header. 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: library catalogue repo. Predict the rule using a reviewed import milestone tag. 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 “After the fixed header lines, an empty line marks the beginning of the optional free-form message.” Apply this procedure: Show line numbers and invisible line endings before submission. The expected mechanism is: The leading blank line ends the header section and the following text is the message. For the library catalogue repo, add one near-miss that exposes placing the message directly after tagger and turning it into an invalid header. 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 the message directly after tagger and turning it into an invalid header.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Show line numbers and invisible line endings before submission.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from A blank line separates headers from the message?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing placing the message directly after tagger and turning it into an invalid header be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny revision-note repo with a tagged study-guide edition. Include one ordinary case, one boundary and one deliberate failure caused by placing the message directly after tagger and turning it into an invalid header. 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: After the fixed header lines, an empty line marks the beginning of the optional free-form message. It shows a trace, not only a final value. The ordinary case should demonstrate “The leading blank line ends the header section and the following text is the message.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Show line numbers and invisible line endings before submission. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For A blank line separates headers from the message, separate the documented Git mktag 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. The message participates in object identity

Back to contents

Changing punctuation, whitespace or the final newline changes the byte sequence and therefore usually the object ID. 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 editing the message after recording the ID and expecting identity to remain stable. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Hash two nearly identical bodies and compare IDs before writing a ref.

For the The message participates in object identity chapter on Git mktag, 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 editing the message after recording the ID and expecting identity to remain stable. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git hash-object -t tag --stdin <tag-body.txt

Explained result. The calculated ID is content-addressed from the exact canonical object bytes. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: homework repository. Explain the rule using an annotated checkpoint for a finished coding exercise. 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 “Changing punctuation, whitespace or the final newline changes the byte sequence and therefore usually the object ID.” Apply this procedure: Hash two nearly identical bodies and compare IDs before writing a ref. The expected mechanism is: The calculated ID is content-addressed from the exact canonical object bytes. For the homework repository, add one near-miss that exposes editing the message after recording the ID and expecting identity to remain stable. 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: library catalogue repo. Transfer the rule using a reviewed import milestone tag. 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 “Changing punctuation, whitespace or the final newline changes the byte sequence and therefore usually the object ID.” Apply this procedure: Hash two nearly identical bodies and compare IDs before writing a ref. The expected mechanism is: The calculated ID is content-addressed from the exact canonical object bytes. For the library catalogue repo, add one near-miss that exposes editing the message after recording the ID and expecting identity to remain stable. 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: CCA website repo. Predict the rule using a release-candidate tag for a registration page. 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 “Changing punctuation, whitespace or the final newline changes the byte sequence and therefore usually the object ID.” Apply this procedure: Hash two nearly identical bodies and compare IDs before writing a ref. The expected mechanism is: The calculated ID is content-addressed from the exact canonical object bytes. For the CCA website repo, add one near-miss that exposes editing the message after recording the ID and expecting identity to remain stable. 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-data repo. Contrast the rule using a tag object marking a verified dataset snapshot. 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 “Changing punctuation, whitespace or the final newline changes the byte sequence and therefore usually the object ID.” Apply this procedure: Hash two nearly identical bodies and compare IDs before writing a ref. The expected mechanism is: The calculated ID is content-addressed from the exact canonical object bytes. For the science-data repo, add one near-miss that exposes editing the message after recording the ID and expecting identity to remain stable. 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 editing the message after recording the ID and expecting identity to remain stable.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Hash two nearly identical bodies and compare IDs before writing a ref.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from The message participates in object identity?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing editing the message after recording the ID and expecting identity to remain stable be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny photo-index repo with a catalogue release with a descriptive message. Include one ordinary case, one boundary and one deliberate failure caused by editing the message after recording the ID and expecting identity to remain stable. 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: Changing punctuation, whitespace or the final newline changes the byte sequence and therefore usually the object ID. It shows a trace, not only a final value. The ordinary case should demonstrate “The calculated ID is content-addressed from the exact canonical object bytes.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Hash two nearly identical bodies and compare IDs before writing a ref. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For The message participates in object identity, separate the documented Git mktag 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. A signature may live in the message

Back to contents

The message can contain a cryptographic signature, but mktag itself does not treat that message as proof or run GPG verification. 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 equating the presence of signature text with a verified signer. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use the appropriate Git verification command and trust configuration as a separate step.

For the A signature may live in the message chapter on Git mktag, 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 equating the presence of signature text with a verified signer. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git verify-tag refs/tags/release-checkpoint

Explained result. Verification is an explicit operation after a ref points to a signed tag object; mktag creation alone is not authentication. 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: CCA website repo. Transfer the rule using a release-candidate tag for a registration page. 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 message can contain a cryptographic signature, but mktag itself does not treat that message as proof or run GPG verification.” Apply this procedure: Use the appropriate Git verification command and trust configuration as a separate step. The expected mechanism is: Verification is an explicit operation after a ref points to a signed tag object; mktag creation alone is not authentication. For the CCA website repo, add one near-miss that exposes equating the presence of signature text with a verified signer. 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-data repo. Predict the rule using a tag object marking a verified dataset snapshot. 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 message can contain a cryptographic signature, but mktag itself does not treat that message as proof or run GPG verification.” Apply this procedure: Use the appropriate Git verification command and trust configuration as a separate step. The expected mechanism is: Verification is an explicit operation after a ref points to a signed tag object; mktag creation alone is not authentication. For the science-data repo, add one near-miss that exposes equating the presence of signature text with a verified signer. 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-note repo. Contrast the rule using a tagged study-guide edition. 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 message can contain a cryptographic signature, but mktag itself does not treat that message as proof or run GPG verification.” Apply this procedure: Use the appropriate Git verification command and trust configuration as a separate step. The expected mechanism is: Verification is an explicit operation after a ref points to a signed tag object; mktag creation alone is not authentication. For the revision-note repo, add one near-miss that exposes equating the presence of signature text with a verified signer. 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: photo-index repo. Stress-test the rule using a catalogue release with a descriptive message. 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 message can contain a cryptographic signature, but mktag itself does not treat that message as proof or run GPG verification.” Apply this procedure: Use the appropriate Git verification command and trust configuration as a separate step. The expected mechanism is: Verification is an explicit operation after a ref points to a signed tag object; mktag creation alone is not authentication. For the photo-index repo, add one near-miss that exposes equating the presence of signature text with a verified signer. 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 equating the presence of signature text with a verified signer.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Use the appropriate Git verification command and trust configuration as a separate step.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from A signature may live in the message?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing equating the presence of signature text with a verified signer be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny budget-tool repo with an audited calculation milestone. Include one ordinary case, one boundary and one deliberate failure caused by equating the presence of signature text with a verified signer. 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 message can contain a cryptographic signature, but mktag itself does not treat that message as proof or run GPG verification. It shows a trace, not only a final value. The ordinary case should demonstrate “Verification is an explicit operation after a ref points to a signed tag object; mktag creation alone is not authentication.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use the appropriate Git verification command and trust configuration as a separate step. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For A signature may live in the message, separate the documented Git mktag 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. mktag validates before writing

Back to contents

Unlike a raw tag hash-object write, mktag runs fsck-style checks and dies before writing when the candidate fails. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is assuming the command is only a shorter spelling for hash-object -t tag -w. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Submit one valid and one malformed body in a disposable object database and check object existence.

For the mktag validates before writing chapter on Git mktag, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming the command is only a shorter spelling for hash-object -t tag -w. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git mktag <malformed-tag.txt

Explained result. A validation error prevents the malformed candidate from being written by mktag. 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-note repo. Predict the rule using a tagged study-guide edition. 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 “Unlike a raw tag hash-object write, mktag runs fsck-style checks and dies before writing when the candidate fails.” Apply this procedure: Submit one valid and one malformed body in a disposable object database and check object existence. The expected mechanism is: A validation error prevents the malformed candidate from being written by mktag. For the revision-note repo, add one near-miss that exposes assuming the command is only a shorter spelling for hash-object -t tag -w. 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: photo-index repo. Contrast the rule using a catalogue release with a descriptive message. 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 “Unlike a raw tag hash-object write, mktag runs fsck-style checks and dies before writing when the candidate fails.” Apply this procedure: Submit one valid and one malformed body in a disposable object database and check object existence. The expected mechanism is: A validation error prevents the malformed candidate from being written by mktag. For the photo-index repo, add one near-miss that exposes assuming the command is only a shorter spelling for hash-object -t tag -w. 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: budget-tool repo. Stress-test the rule using an audited calculation milestone. 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 “Unlike a raw tag hash-object write, mktag runs fsck-style checks and dies before writing when the candidate fails.” Apply this procedure: Submit one valid and one malformed body in a disposable object database and check object existence. The expected mechanism is: A validation error prevents the malformed candidate from being written by mktag. For the budget-tool repo, add one near-miss that exposes assuming the command is only a shorter spelling for hash-object -t tag -w. 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: project build repo. Explain the rule using a signed release object inspected before a ref update. 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 “Unlike a raw tag hash-object write, mktag runs fsck-style checks and dies before writing when the candidate fails.” Apply this procedure: Submit one valid and one malformed body in a disposable object database and check object existence. The expected mechanism is: A validation error prevents the malformed candidate from being written by mktag. For the project build repo, add one near-miss that exposes assuming the command is only a shorter spelling for hash-object -t tag -w. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers assuming the command is only a shorter spelling for hash-object -t tag -w.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Submit one valid and one malformed body in a disposable object database and check object existence.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from mktag validates before writing?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming the command is only a shorter spelling for hash-object -t tag -w be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny project build repo with a signed release object inspected before a ref update. Include one ordinary case, one boundary and one deliberate failure caused by assuming the command is only a shorter spelling for hash-object -t tag -w. 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: Unlike a raw tag hash-object write, mktag runs fsck-style checks and dies before writing when the candidate fails. It shows a trace, not only a final value. The ordinary case should demonstrate “A validation error prevents the malformed candidate from being written by mktag.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Submit one valid and one malformed body in a disposable object database and check object existence. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For mktag validates before writing, separate the documented Git mktag 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. Strict validation is the default

Back to contents

mktag enables the equivalent of fsck strict mode by default, promoting all fsck message classes to errors. 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 warnings accepted by ordinary fsck defaults to pass mktag. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Record Git version and exact diagnostic, then repair the object instead of weakening checks reflexively.

For the Strict validation is the default chapter on Git mktag, 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 warnings accepted by ordinary fsck defaults to pass mktag. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git mktag <tag-body.txt

Explained result. The default path applies the stricter validation policy documented for mktag. 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: budget-tool repo. Contrast the rule using an audited calculation milestone. 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 “mktag enables the equivalent of fsck strict mode by default, promoting all fsck message classes to errors.” Apply this procedure: Record Git version and exact diagnostic, then repair the object instead of weakening checks reflexively. The expected mechanism is: The default path applies the stricter validation policy documented for mktag. For the budget-tool repo, add one near-miss that exposes expecting warnings accepted by ordinary fsck defaults to pass mktag. 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: project build repo. Stress-test the rule using a signed release object inspected before a ref update. 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 “mktag enables the equivalent of fsck strict mode by default, promoting all fsck message classes to errors.” Apply this procedure: Record Git version and exact diagnostic, then repair the object instead of weakening checks reflexively. The expected mechanism is: The default path applies the stricter validation policy documented for mktag. For the project build repo, add one near-miss that exposes expecting warnings accepted by ordinary fsck defaults to pass mktag. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: homework repository. Explain the rule using an annotated checkpoint for a finished coding exercise. 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 “mktag enables the equivalent of fsck strict mode by default, promoting all fsck message classes to errors.” Apply this procedure: Record Git version and exact diagnostic, then repair the object instead of weakening checks reflexively. The expected mechanism is: The default path applies the stricter validation policy documented for mktag. For the homework repository, add one near-miss that exposes expecting warnings accepted by ordinary fsck defaults to pass mktag. 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: library catalogue repo. Transfer the rule using a reviewed import milestone tag. 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 “mktag enables the equivalent of fsck strict mode by default, promoting all fsck message classes to errors.” Apply this procedure: Record Git version and exact diagnostic, then repair the object instead of weakening checks reflexively. The expected mechanism is: The default path applies the stricter validation policy documented for mktag. For the library catalogue repo, add one near-miss that exposes expecting warnings accepted by ordinary fsck defaults to pass mktag. 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 warnings accepted by ordinary fsck defaults to pass mktag.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Record Git version and exact diagnostic, then repair the object instead of weakening checks reflexively.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from Strict validation is the default?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting warnings accepted by ordinary fsck defaults to pass mktag be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework repository with an annotated checkpoint for a finished coding exercise. Include one ordinary case, one boundary and one deliberate failure caused by expecting warnings accepted by ordinary fsck defaults to pass mktag. 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: mktag enables the equivalent of fsck strict mode by default, promoting all fsck message classes to errors. It shows a trace, not only a final value. The ordinary case should demonstrate “The default path applies the stricter validation policy documented for mktag.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Record Git version and exact diagnostic, then repair the object instead of weakening checks reflexively. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Strict validation is the default, separate the documented Git mktag 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. –no-strict deliberately relaxes strict mode

Back to contents

The –no-strict option disables the default strict setting but does not turn malformed input into a good design. 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 –no-strict as the first response to a validation failure. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Classify the diagnostic, preserve the original candidate and justify any policy exception.

For the –no-strict deliberately relaxes strict mode chapter on Git mktag, 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 –no-strict as the first response to a validation failure. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git mktag --no-strict <legacy-tag-body.txt

Explained result. The command uses less strict fsck treatment, while core tag-format requirements still matter. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: homework repository. Stress-test the rule using an annotated checkpoint for a finished coding exercise. 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 –no-strict option disables the default strict setting but does not turn malformed input into a good design.” Apply this procedure: Classify the diagnostic, preserve the original candidate and justify any policy exception. The expected mechanism is: The command uses less strict fsck treatment, while core tag-format requirements still matter. For the homework repository, add one near-miss that exposes using –no-strict as the first response to a validation failure. 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: library catalogue repo. Explain the rule using a reviewed import milestone tag. 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 –no-strict option disables the default strict setting but does not turn malformed input into a good design.” Apply this procedure: Classify the diagnostic, preserve the original candidate and justify any policy exception. The expected mechanism is: The command uses less strict fsck treatment, while core tag-format requirements still matter. For the library catalogue repo, add one near-miss that exposes using –no-strict as the first response to a validation failure. 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: CCA website repo. Transfer the rule using a release-candidate tag for a registration page. 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 –no-strict option disables the default strict setting but does not turn malformed input into a good design.” Apply this procedure: Classify the diagnostic, preserve the original candidate and justify any policy exception. The expected mechanism is: The command uses less strict fsck treatment, while core tag-format requirements still matter. For the CCA website repo, add one near-miss that exposes using –no-strict as the first response to a validation failure. 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-data repo. Predict the rule using a tag object marking a verified dataset snapshot. 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 –no-strict option disables the default strict setting but does not turn malformed input into a good design.” Apply this procedure: Classify the diagnostic, preserve the original candidate and justify any policy exception. The expected mechanism is: The command uses less strict fsck treatment, while core tag-format requirements still matter. For the science-data repo, add one near-miss that exposes using –no-strict as the first response to a validation failure. 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 –no-strict as the first response to a validation failure.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Classify the diagnostic, preserve the original candidate and justify any policy exception.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from –no-strict deliberately relaxes strict mode?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using –no-strict as the first response to a validation failure be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library catalogue repo with a reviewed import milestone tag. Include one ordinary case, one boundary and one deliberate failure caused by using –no-strict as the first response to a validation failure. 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 –no-strict option disables the default strict setting but does not turn malformed input into a good design. It shows a trace, not only a final value. The ordinary case should demonstrate “The command uses less strict fsck treatment, while core tag-format requirements still matter.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Classify the diagnostic, preserve the original candidate and justify any policy exception. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For –no-strict deliberately relaxes strict mode, separate the documented Git mktag 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. fsck message configuration can target an exception

Back to contents

A specific fsck message ID can be configured, such as ignoring an extra header entry, instead of disabling every strict check. 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 copying a global fsck relaxation into all repositories for one legacy object. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use a one-command -c override in a disposable test and document the exact message ID.

For the fsck message configuration can target an exception chapter on Git mktag, 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 copying a global fsck relaxation into all repositories for one legacy object. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git -c fsck.extraHeaderEntry=ignore mktag <legacy-extra-header.txt

Explained result. Only the named diagnostic policy is adjusted for that invocation. 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: CCA website repo. Explain the rule using a release-candidate tag for a registration page. 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 specific fsck message ID can be configured, such as ignoring an extra header entry, instead of disabling every strict check.” Apply this procedure: Use a one-command -c override in a disposable test and document the exact message ID. The expected mechanism is: Only the named diagnostic policy is adjusted for that invocation. For the CCA website repo, add one near-miss that exposes copying a global fsck relaxation into all repositories for one legacy object. 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-data repo. Transfer the rule using a tag object marking a verified dataset snapshot. 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 specific fsck message ID can be configured, such as ignoring an extra header entry, instead of disabling every strict check.” Apply this procedure: Use a one-command -c override in a disposable test and document the exact message ID. The expected mechanism is: Only the named diagnostic policy is adjusted for that invocation. For the science-data repo, add one near-miss that exposes copying a global fsck relaxation into all repositories for one legacy object. 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-note repo. Predict the rule using a tagged study-guide edition. 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 specific fsck message ID can be configured, such as ignoring an extra header entry, instead of disabling every strict check.” Apply this procedure: Use a one-command -c override in a disposable test and document the exact message ID. The expected mechanism is: Only the named diagnostic policy is adjusted for that invocation. For the revision-note repo, add one near-miss that exposes copying a global fsck relaxation into all repositories for one legacy object. 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: photo-index repo. Contrast the rule using a catalogue release with a descriptive message. 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 specific fsck message ID can be configured, such as ignoring an extra header entry, instead of disabling every strict check.” Apply this procedure: Use a one-command -c override in a disposable test and document the exact message ID. The expected mechanism is: Only the named diagnostic policy is adjusted for that invocation. For the photo-index repo, add one near-miss that exposes copying a global fsck relaxation into all repositories for one legacy object. 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 copying a global fsck relaxation into all repositories for one legacy object.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Use a one-command -c override in a disposable test and document the exact message ID.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from fsck message configuration can target an exception?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing copying a global fsck relaxation into all repositories for one legacy object be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA website repo with a release-candidate tag for a registration page. Include one ordinary case, one boundary and one deliberate failure caused by copying a global fsck relaxation into all repositories for one legacy object. 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 specific fsck message ID can be configured, such as ignoring an extra header entry, instead of disabling every strict check. It shows a trace, not only a final value. The ordinary case should demonstrate “Only the named diagnostic policy is adjusted for that invocation.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use a one-command -c override in a disposable test and document the exact message ID. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For fsck message configuration can target an exception, separate the documented Git mktag 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. Target-object existence is checked

Back to contents

The object header normally needs to identify an existing object whose type can be validated. 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 a random hexadecimal string that looks like an object ID. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Run cat-file -e and cat-file -t before assembling the tag body.

For the Target-object existence is checked chapter on Git mktag, 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 a random hexadecimal string that looks like an object ID. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git cat-file -e "$target^{object}" && git cat-file -t "$target"

Explained result. Success establishes that the target exists and reveals the type to place in the body. 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-note repo. Transfer the rule using a tagged study-guide edition. 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 object header normally needs to identify an existing object whose type can be validated.” Apply this procedure: Run cat-file -e and cat-file -t before assembling the tag body. The expected mechanism is: Success establishes that the target exists and reveals the type to place in the body. For the revision-note repo, add one near-miss that exposes using a random hexadecimal string that looks like an object ID. 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: photo-index repo. Predict the rule using a catalogue release with a descriptive message. 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 object header normally needs to identify an existing object whose type can be validated.” Apply this procedure: Run cat-file -e and cat-file -t before assembling the tag body. The expected mechanism is: Success establishes that the target exists and reveals the type to place in the body. For the photo-index repo, add one near-miss that exposes using a random hexadecimal string that looks like an object ID. 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: budget-tool repo. Contrast the rule using an audited calculation milestone. 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 object header normally needs to identify an existing object whose type can be validated.” Apply this procedure: Run cat-file -e and cat-file -t before assembling the tag body. The expected mechanism is: Success establishes that the target exists and reveals the type to place in the body. For the budget-tool repo, add one near-miss that exposes using a random hexadecimal string that looks like an object ID. 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: project build repo. Stress-test the rule using a signed release object inspected before a ref update. 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 object header normally needs to identify an existing object whose type can be validated.” Apply this procedure: Run cat-file -e and cat-file -t before assembling the tag body. The expected mechanism is: Success establishes that the target exists and reveals the type to place in the body. For the project build repo, add one near-miss that exposes using a random hexadecimal string that looks like an object ID. 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 a random hexadecimal string that looks like an object ID.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Run cat-file -e and cat-file -t before assembling the tag body.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from Target-object existence is checked?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using a random hexadecimal string that looks like an object ID be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science-data repo with a tag object marking a verified dataset snapshot. Include one ordinary case, one boundary and one deliberate failure caused by using a random hexadecimal string that looks like an object ID. 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 object header normally needs to identify an existing object whose type can be validated. It shows a trace, not only a final value. The ordinary case should demonstrate “Success establishes that the target exists and reveals the type to place in the body.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Run cat-file -e and cat-file -t before assembling the tag body. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Target-object existence is checked, separate the documented Git mktag 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. Tag objects can point to several Git object types

Back to contents

An annotated tag may target a commit, tree, blob or another tag when the type line matches. 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 teaching annotated tags as structurally limited to commits even though the object format is broader. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Create disposable examples for two types and inspect peeled versus direct object IDs.

For the Tag objects can point to several Git object types chapter on Git mktag, 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 teaching annotated tags as structurally limited to commits even though the object format is broader. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

tree=$(git rev-parse HEAD^{tree})
git cat-file -t "$tree"

Explained result. The tree target can be named in a valid tag body with type tree. 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: budget-tool repo. Predict the rule using an audited calculation milestone. 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 “An annotated tag may target a commit, tree, blob or another tag when the type line matches.” Apply this procedure: Create disposable examples for two types and inspect peeled versus direct object IDs. The expected mechanism is: The tree target can be named in a valid tag body with type tree. For the budget-tool repo, add one near-miss that exposes teaching annotated tags as structurally limited to commits even though the object format is broader. 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: project build repo. Contrast the rule using a signed release object inspected before a ref update. 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 “An annotated tag may target a commit, tree, blob or another tag when the type line matches.” Apply this procedure: Create disposable examples for two types and inspect peeled versus direct object IDs. The expected mechanism is: The tree target can be named in a valid tag body with type tree. For the project build repo, add one near-miss that exposes teaching annotated tags as structurally limited to commits even though the object format is broader. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: homework repository. Stress-test the rule using an annotated checkpoint for a finished coding exercise. 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 “An annotated tag may target a commit, tree, blob or another tag when the type line matches.” Apply this procedure: Create disposable examples for two types and inspect peeled versus direct object IDs. The expected mechanism is: The tree target can be named in a valid tag body with type tree. For the homework repository, add one near-miss that exposes teaching annotated tags as structurally limited to commits even though the object format is broader. 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: library catalogue repo. Explain the rule using a reviewed import milestone tag. 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 “An annotated tag may target a commit, tree, blob or another tag when the type line matches.” Apply this procedure: Create disposable examples for two types and inspect peeled versus direct object IDs. The expected mechanism is: The tree target can be named in a valid tag body with type tree. For the library catalogue repo, add one near-miss that exposes teaching annotated tags as structurally limited to commits even though the object format is broader. 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 teaching annotated tags as structurally limited to commits even though the object format is broader.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Create disposable examples for two types and inspect peeled versus direct object IDs.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from Tag objects can point to several Git object types?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing teaching annotated tags as structurally limited to commits even though the object format is broader be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny revision-note repo with a tagged study-guide edition. Include one ordinary case, one boundary and one deliberate failure caused by teaching annotated tags as structurally limited to commits even though the object format is broader. 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: An annotated tag may target a commit, tree, blob or another tag when the type line matches. It shows a trace, not only a final value. The ordinary case should demonstrate “The tree target can be named in a valid tag body with type tree.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Create disposable examples for two types and inspect peeled versus direct object IDs. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Tag objects can point to several Git object types, separate the documented Git mktag 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. Byte-exact input makes line endings important

Back to contents

Standard input bytes determine parsing and identity, so CRLF conversion or missing separators can alter validation and the resulting ID. 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 building the body in a text editor that silently rewrites line endings. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use a script or printf, inspect with a byte-aware tool and keep fixtures under controlled attributes.

For the Byte-exact input makes line endings important chapter on Git mktag, 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 building the body in a text editor that silently rewrites line endings. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

od -An -tx1 -c tag-body.txt | head

Explained result. The byte view exposes carriage returns, blank lines and the final newline that ordinary display can hide. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: homework repository. Contrast the rule using an annotated checkpoint for a finished coding exercise. 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 “Standard input bytes determine parsing and identity, so CRLF conversion or missing separators can alter validation and the resulting ID.” Apply this procedure: Use a script or printf, inspect with a byte-aware tool and keep fixtures under controlled attributes. The expected mechanism is: The byte view exposes carriage returns, blank lines and the final newline that ordinary display can hide. For the homework repository, add one near-miss that exposes building the body in a text editor that silently rewrites line endings. 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: library catalogue repo. Stress-test the rule using a reviewed import milestone tag. 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 “Standard input bytes determine parsing and identity, so CRLF conversion or missing separators can alter validation and the resulting ID.” Apply this procedure: Use a script or printf, inspect with a byte-aware tool and keep fixtures under controlled attributes. The expected mechanism is: The byte view exposes carriage returns, blank lines and the final newline that ordinary display can hide. For the library catalogue repo, add one near-miss that exposes building the body in a text editor that silently rewrites line endings. 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: CCA website repo. Explain the rule using a release-candidate tag for a registration page. 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 “Standard input bytes determine parsing and identity, so CRLF conversion or missing separators can alter validation and the resulting ID.” Apply this procedure: Use a script or printf, inspect with a byte-aware tool and keep fixtures under controlled attributes. The expected mechanism is: The byte view exposes carriage returns, blank lines and the final newline that ordinary display can hide. For the CCA website repo, add one near-miss that exposes building the body in a text editor that silently rewrites line endings. 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-data repo. Transfer the rule using a tag object marking a verified dataset snapshot. 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 “Standard input bytes determine parsing and identity, so CRLF conversion or missing separators can alter validation and the resulting ID.” Apply this procedure: Use a script or printf, inspect with a byte-aware tool and keep fixtures under controlled attributes. The expected mechanism is: The byte view exposes carriage returns, blank lines and the final newline that ordinary display can hide. For the science-data repo, add one near-miss that exposes building the body in a text editor that silently rewrites line endings. 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 building the body in a text editor that silently rewrites line endings.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Use a script or printf, inspect with a byte-aware tool and keep fixtures under controlled attributes.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from Byte-exact input makes line endings important?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing building the body in a text editor that silently rewrites line endings be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny photo-index repo with a catalogue release with a descriptive message. Include one ordinary case, one boundary and one deliberate failure caused by building the body in a text editor that silently rewrites line endings. 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: Standard input bytes determine parsing and identity, so CRLF conversion or missing separators can alter validation and the resulting ID. It shows a trace, not only a final value. The ordinary case should demonstrate “The byte view exposes carriage returns, blank lines and the final newline that ordinary display can hide.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use a script or printf, inspect with a byte-aware tool and keep fixtures under controlled attributes. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Byte-exact input makes line endings important, separate the documented Git mktag 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. cat-file is the inspection surface

Back to contents

git cat-file -t checks object type and git cat-file -p renders the stored tag body for review. 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 trusting only the ID printed by mktag without examining what it names. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Inspect type, pretty content and target object before creating any ref.

For the cat-file is the inspection surface chapter on Git mktag, 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 trusting only the ID printed by mktag without examining what it names. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git cat-file -t "$oid"
git cat-file -p "$oid"

Explained result. The commands confirm a tag object and display its target, type, internal name, tagger and message. 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: CCA website repo. Stress-test the rule using a release-candidate tag for a registration page. 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 cat-file -t checks object type and git cat-file -p renders the stored tag body for review.” Apply this procedure: Inspect type, pretty content and target object before creating any ref. The expected mechanism is: The commands confirm a tag object and display its target, type, internal name, tagger and message. For the CCA website repo, add one near-miss that exposes trusting only the ID printed by mktag without examining what it names. 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-data repo. Explain the rule using a tag object marking a verified dataset snapshot. 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 cat-file -t checks object type and git cat-file -p renders the stored tag body for review.” Apply this procedure: Inspect type, pretty content and target object before creating any ref. The expected mechanism is: The commands confirm a tag object and display its target, type, internal name, tagger and message. For the science-data repo, add one near-miss that exposes trusting only the ID printed by mktag without examining what it names. 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-note repo. Transfer the rule using a tagged study-guide edition. 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 cat-file -t checks object type and git cat-file -p renders the stored tag body for review.” Apply this procedure: Inspect type, pretty content and target object before creating any ref. The expected mechanism is: The commands confirm a tag object and display its target, type, internal name, tagger and message. For the revision-note repo, add one near-miss that exposes trusting only the ID printed by mktag without examining what it names. 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: photo-index repo. Predict the rule using a catalogue release with a descriptive message. 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 cat-file -t checks object type and git cat-file -p renders the stored tag body for review.” Apply this procedure: Inspect type, pretty content and target object before creating any ref. The expected mechanism is: The commands confirm a tag object and display its target, type, internal name, tagger and message. For the photo-index repo, add one near-miss that exposes trusting only the ID printed by mktag without examining what it names. 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 trusting only the ID printed by mktag without examining what it names.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Inspect type, pretty content and target object before creating any ref.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from cat-file is the inspection surface?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing trusting only the ID printed by mktag without examining what it names be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny budget-tool repo with an audited calculation milestone. Include one ordinary case, one boundary and one deliberate failure caused by trusting only the ID printed by mktag without examining what it names. 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 cat-file -t checks object type and git cat-file -p renders the stored tag body for review. It shows a trace, not only a final value. The ordinary case should demonstrate “The commands confirm a tag object and display its target, type, internal name, tagger and message.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Inspect type, pretty content and target object before creating any ref. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

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

Previous chapter . Contents . Next chapter

CHAPTER 19 OF 20 . Transfer with judgment

19. A ref update is a separate reviewed write

Back to contents

After inspection, update-ref can create refs/tags/name pointing to the tag-object ID with an expected-old guard. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is writing a public-looking tag ref before checking the object or overwriting an existing ref blindly. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Verify the ref is absent, then use update-ref with the all-zero expected old value.

For the A ref update is a separate reviewed write chapter on Git mktag, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on writing a public-looking tag ref before checking the object or overwriting an existing ref blindly. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git update-ref refs/tags/lesson-checkpoint "$oid" 0000000000000000000000000000000000000000

Explained result. The guarded update creates the ref only if it did not already exist in a SHA-1 repository; use the repository’s correct zero-ID width for its object format. 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-note repo. Explain the rule using a tagged study-guide edition. 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 “After inspection, update-ref can create refs/tags/name pointing to the tag-object ID with an expected-old guard.” Apply this procedure: Verify the ref is absent, then use update-ref with the all-zero expected old value. The expected mechanism is: The guarded update creates the ref only if it did not already exist in a SHA-1 repository; use the repository’s correct zero-ID width for its object format. For the revision-note repo, add one near-miss that exposes writing a public-looking tag ref before checking the object or overwriting an existing ref blindly. 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: photo-index repo. Transfer the rule using a catalogue release with a descriptive message. 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 “After inspection, update-ref can create refs/tags/name pointing to the tag-object ID with an expected-old guard.” Apply this procedure: Verify the ref is absent, then use update-ref with the all-zero expected old value. The expected mechanism is: The guarded update creates the ref only if it did not already exist in a SHA-1 repository; use the repository’s correct zero-ID width for its object format. For the photo-index repo, add one near-miss that exposes writing a public-looking tag ref before checking the object or overwriting an existing ref blindly. 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: budget-tool repo. Predict the rule using an audited calculation milestone. 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 “After inspection, update-ref can create refs/tags/name pointing to the tag-object ID with an expected-old guard.” Apply this procedure: Verify the ref is absent, then use update-ref with the all-zero expected old value. The expected mechanism is: The guarded update creates the ref only if it did not already exist in a SHA-1 repository; use the repository’s correct zero-ID width for its object format. For the budget-tool repo, add one near-miss that exposes writing a public-looking tag ref before checking the object or overwriting an existing ref blindly. 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: project build repo. Contrast the rule using a signed release object inspected before a ref update. 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 “After inspection, update-ref can create refs/tags/name pointing to the tag-object ID with an expected-old guard.” Apply this procedure: Verify the ref is absent, then use update-ref with the all-zero expected old value. The expected mechanism is: The guarded update creates the ref only if it did not already exist in a SHA-1 repository; use the repository’s correct zero-ID width for its object format. For the project build repo, add one near-miss that exposes writing a public-looking tag ref before checking the object or overwriting an existing ref blindly. 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 a public-looking tag ref before checking the object or overwriting an existing ref blindly.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Verify the ref is absent, then use update-ref with the all-zero expected old value.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from A ref update is a separate reviewed write?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing writing a public-looking tag ref before checking the object or overwriting an existing ref blindly be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny project build repo with a signed release object inspected before a ref update. Include one ordinary case, one boundary and one deliberate failure caused by writing a public-looking tag ref before checking the object or overwriting an existing ref blindly. 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: After inspection, update-ref can create refs/tags/name pointing to the tag-object ID with an expected-old guard. It shows a trace, not only a final value. The ordinary case should demonstrate “The guarded update creates the ref only if it did not already exist in a SHA-1 repository; use the repository’s correct zero-ID width for its object format.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Verify the ref is absent, then use update-ref with the all-zero expected old value. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For A ref update is a separate reviewed write, separate the documented Git mktag 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. Mastery uses a disposable object database

Back to contents

Plumbing commands can create unreachable objects and refs, so practice should be isolated, inspectable and easy to remove. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is experimenting in an important repository and confusing object creation with history changes. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Initialise a temporary repo, make one commit, build a tag body, validate, inspect, update a test ref and then remove the directory.

For the Mastery uses a disposable object database chapter on Git mktag, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on experimenting in an important repository and confusing object creation with history changes. 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

Explained result. The disposable repository makes object and ref effects visible without risking schoolwork or a real project. 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: budget-tool repo. Transfer the rule using an audited calculation milestone. 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 “Plumbing commands can create unreachable objects and refs, so practice should be isolated, inspectable and easy to remove.” Apply this procedure: Initialise a temporary repo, make one commit, build a tag body, validate, inspect, update a test ref and then remove the directory. The expected mechanism is: The disposable repository makes object and ref effects visible without risking schoolwork or a real project. For the budget-tool repo, add one near-miss that exposes experimenting in an important repository and confusing object creation with history changes. 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: project build repo. Predict the rule using a signed release object inspected before a ref update. 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 “Plumbing commands can create unreachable objects and refs, so practice should be isolated, inspectable and easy to remove.” Apply this procedure: Initialise a temporary repo, make one commit, build a tag body, validate, inspect, update a test ref and then remove the directory. The expected mechanism is: The disposable repository makes object and ref effects visible without risking schoolwork or a real project. For the project build repo, add one near-miss that exposes experimenting in an important repository and confusing object creation with history changes. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: homework repository. Contrast the rule using an annotated checkpoint for a finished coding exercise. 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 “Plumbing commands can create unreachable objects and refs, so practice should be isolated, inspectable and easy to remove.” Apply this procedure: Initialise a temporary repo, make one commit, build a tag body, validate, inspect, update a test ref and then remove the directory. The expected mechanism is: The disposable repository makes object and ref effects visible without risking schoolwork or a real project. For the homework repository, add one near-miss that exposes experimenting in an important repository and confusing object creation with history changes. 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: library catalogue repo. Stress-test the rule using a reviewed import milestone tag. 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 “Plumbing commands can create unreachable objects and refs, so practice should be isolated, inspectable and easy to remove.” Apply this procedure: Initialise a temporary repo, make one commit, build a tag body, validate, inspect, update a test ref and then remove the directory. The expected mechanism is: The disposable repository makes object and ref effects visible without risking schoolwork or a real project. For the library catalogue repo, add one near-miss that exposes experimenting in an important repository and confusing object creation with history changes. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers experimenting in an important repository and confusing object creation with history changes.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Initialise a temporary repo, make one commit, build a tag body, validate, inspect, update a test ref and then remove the directory.” 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 mktag syntax. For this chapter, useful prompts are: “What did you expect from Mastery uses a disposable object database?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing experimenting in an important repository and confusing object creation with history changes be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework repository with an annotated checkpoint for a finished coding exercise. Include one ordinary case, one boundary and one deliberate failure caused by experimenting in an important repository and confusing object creation with history changes. 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: Plumbing commands can create unreachable objects and refs, so practice should be isolated, inspectable and easy to remove. It shows a trace, not only a final value. The ordinary case should demonstrate “The disposable repository makes object and ref effects visible without risking schoolwork or a real project.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Initialise a temporary repo, make one commit, build a tag body, validate, inspect, update a test ref and then remove the directory. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

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

Previous chapter . Contents . Next chapter

Parent guide: choose the next useful step

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

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

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

Capstone practice with explained routes

1. homework repository: model, boundary and recovery

Create a small homework repository using an annotated checkpoint for a finished coding exercise. Combine “mktag reads a tag body from standard input” 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 command consumes tag-object content on stdin and prints the object ID after successful creation. Apply: Prepare a text file, inspect every byte and redirect it into git mktag. Verify: A valid body produces one object ID on standard output. 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. library catalogue repo: model, boundary and recovery

Create a small library catalogue repo using a reviewed import milestone tag. Combine “The object header names the target object” 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 first header is object followed by the hexadecimal object ID that the tag points to. Apply: Resolve and inspect the target before composing the body. Verify: The header should contain the commit ID selected as the tag target. 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. CCA website repo: model, boundary and recovery

Create a small CCA website repo using a release-candidate tag for a registration page. Combine “The tagger line records identity and time” 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 normal tagger line contains name, email, Unix timestamp and numeric timezone offset in the expected format. Apply: Use a fixed test identity and timestamp in a disposable repository, then inspect the stored line. Verify: The line supplies structured identity and time metadata suitable for the tag format. 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-data repo: model, boundary and recovery

Create a small science-data repo using a tag object marking a verified dataset snapshot. Combine “A signature may live in the message” 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 message can contain a cryptographic signature, but mktag itself does not treat that message as proof or run GPG verification. Apply: Use the appropriate Git verification command and trust configuration as a separate step. Verify: Verification is an explicit operation after a ref points to a signed tag object; mktag creation alone is not authentication. 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-note repo: model, boundary and recovery

Create a small revision-note repo using a tagged study-guide edition. Combine “–no-strict deliberately relaxes strict mode” 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 –no-strict option disables the default strict setting but does not turn malformed input into a good design. Apply: Classify the diagnostic, preserve the original candidate and justify any policy exception. Verify: The command uses less strict fsck treatment, while core tag-format requirements still matter. 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. photo-index repo: model, boundary and recovery

Create a small photo-index repo using a catalogue release with a descriptive message. Combine “Tag objects can point to several Git object types” 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: An annotated tag may target a commit, tree, blob or another tag when the type line matches. Apply: Create disposable examples for two types and inspect peeled versus direct object IDs. Verify: The tree target can be named in a valid tag body with type tree. 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. budget-tool repo: model, boundary and recovery

Create a small budget-tool repo using an audited calculation milestone. Combine “A ref update is a separate reviewed write” 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: After inspection, update-ref can create refs/tags/name pointing to the tag-object ID with an expected-old guard. Apply: Verify the ref is absent, then use update-ref with the all-zero expected old value. Verify: The guarded update creates the ref only if it did not already exist in a SHA-1 repository; use the repository’s correct zero-ID width for its object format. 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. project build repo: model, boundary and recovery

Create a small project build repo using a signed release object inspected before a ref update. Combine “The result is an annotated tag object” 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 stored object has type tag and contains headers plus an optional message; it is not a lightweight tag reference. Apply: Inspect the returned ID with cat-file -t and cat-file -p. Verify: cat-file reports tag for the object type. 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 mktag 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. mktag reads a tag body from standard input

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

2. The result is an annotated tag object

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

3. No refs/tags name is created automatically

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

4. The object header names the target object

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

5. The type header must match the target

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

6. The tag header stores the tag name inside the object

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

7. The tagger line records identity and time

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

8. A blank line separates headers from the message

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

9. The message participates in object identity

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

10. A signature may live in the message

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

11. mktag validates before writing

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

12. Strict validation is the default

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer