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 verify-pack validates a packed-object archive through its .idx index and, with verbose output, reports the objects stored in that pack plus delta-chain statistics. It is a plumbing diagnostic for one pack/index pair, not a repair command or a complete repository health verdict. Mastery means selecting the right index safely, reading object type, size and offset fields, distinguishing ordinary and deltified records, understanding the delta-depth histogram, checking exit status, respecting object-format context, and choosing git fsck, cat-file, count-objects or repack when the question is broader than one pack. This guide begins with that mechanism, then develops it through worked traces, deliberate mistakes, explained practice and transfer decisions.

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

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

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

git verify-pack takes a pack index path, uses it to locate the corresponding pack and verifies that packed archive. 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 running the command at a repository root with no index argument and expecting every object to be checked. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Resolve one exact .idx file, copy important repositories first and record command status.

For the verify-pack checks one indexed pack chapter on Git verify-pack, 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 running the command at a repository root with no index argument and expecting every object to be checked. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

idx=$(find .git/objects/pack -name '*.idx' -print -quit)
git verify-pack "$idx"

Four purposeful transfer cases

Case 1: homework repository. Predict the rule using many revisions compacted into one disposable pack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading-notes repository. Contrast the rule using similar text files that form delta chains after repacking. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science dataset. Stress-test the rule using binary and text objects inspected without changing working files. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA website. Explain the rule using a clone whose object database must be diagnosed read-only. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers running the command at a repository root with no index argument and expecting every object to be checked.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Resolve one exact .idx file, copy important repositories first and record command status.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from verify-pack checks one indexed pack?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing running the command at a repository root with no index argument and expecting every object to be checked be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library catalogue with pack statistics recorded across two safe repack experiments. Include one ordinary case, one boundary and one deliberate failure caused by running the command at a repository root with no index argument and expecting every object to be checked. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

The documented argument is the pack index file, and Git derives the associated .pack file from the matching basename. 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 an arbitrary object directory or a .git directory as if Git will choose a pack. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. List pack/index pairs and confirm matching basenames before invoking the command.

For the The input is normally the .idx path chapter on Git verify-pack, 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 an arbitrary object directory or a .git directory as if Git will choose a pack. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

find .git/objects/pack -maxdepth 1 -type f ( -name '*.idx' -o -name '*.pack' ) -print

Four purposeful transfer cases

Case 1: science dataset. Contrast the rule using binary and text objects inspected without changing working files. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA website. Stress-test the rule using a clone whose object database must be diagnosed read-only. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family archive. Explain the rule using a copied repository checked before any cleanup or repair. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library catalogue. Transfer the rule using pack statistics recorded across two safe repack experiments. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers passing an arbitrary object directory or a .git directory as if Git will choose a pack.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “List pack/index pairs and confirm matching basenames before invoking the command.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git verify-pack syntax. For this chapter, useful prompts are: “What did you expect from The input is normally the .idx path?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing passing an arbitrary object directory or a .git directory as if Git will choose a pack be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. Include one ordinary case, one boundary and one deliberate failure caused by passing an arbitrary object directory or a .git directory as if Git will choose a pack. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

Without verbose options, a valid pack can produce no ordinary output, so exit status is the authoritative success signal. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is treating an empty terminal as evidence that the command did not run. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use a shell conditional or capture the subprocess return code before interpreting standard output.

For the Silence can mean success chapter on Git verify-pack, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on treating an empty terminal as evidence that the command did not run. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

if git verify-pack "$idx"; then
  echo 'selected pack verified'
else
  echo 'verification failed' >&2
fi

Four purposeful transfer cases

Case 1: family archive. Stress-test the rule using a copied repository checked before any cleanup or repair. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library catalogue. Explain the rule using pack statistics recorded across two safe repack experiments. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Transfer the rule using valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Predict the rule using verify-pack compared with fsck, cat-file, count-objects, show-index and repack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers treating an empty terminal as evidence that the command did not run.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Use a shell conditional or capture the subprocess return code before interpreting standard output.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Silence can mean success?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating an empty terminal as evidence that the command did not run be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design decision with verify-pack compared with fsck, cat-file, count-objects, show-index and repack. Include one ordinary case, one boundary and one deliberate failure caused by treating an empty terminal as evidence that the command did not run. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Silence can mean success, separate the documented Git verify-pack 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

-v or –verbose verifies the pack, prints an object list and finishes with delta-chain statistics. 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 verbose output as though it were a porcelain table with a permanent column schema for every record. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Save raw output, identify record shapes and parse only fields documented or verified for the deployed Git version.

For the Verbose mode lists objects and a histogram chapter on Git verify-pack, 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 verbose output as though it were a porcelain table with a permanent column schema for every record. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git verify-pack -v "$idx" | less

Four purposeful transfer cases

Case 1: test laboratory. Explain the rule using valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Transfer the rule using verify-pack compared with fsck, cat-file, count-objects, show-index and repack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework repository. Predict the rule using many revisions compacted into one disposable pack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading-notes repository. Contrast the rule using similar text files that form delta chains after repacking. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers using verbose output as though it were a porcelain table with a permanent column schema for every record.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Save raw output, identify record shapes and parse only fields documented or verified for the deployed Git version.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Verbose mode lists objects and a histogram?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using verbose output as though it were a porcelain table with a permanent column schema for every record 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 many revisions compacted into one disposable pack. Include one ordinary case, one boundary and one deliberate failure caused by using verbose output as though it were a porcelain table with a permanent column schema for every record. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Verbose mode lists objects and a histogram, separate the documented Git verify-pack mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

A non-delta verbose record identifies an object ID, object type, uncompressed size, packed size and offset within the pack. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is reading the two sizes as working-tree file length and repository total size. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Create known blobs and commits, then compare record fields with cat-file and the pack file itself.

For the Ordinary records expose storage facts chapter on Git verify-pack, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on reading the two sizes as working-tree file length and repository total size. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git verify-pack -v "$idx" | head

Four purposeful transfer cases

Case 1: homework repository. Transfer the rule using many revisions compacted into one disposable pack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading-notes repository. Predict the rule using similar text files that form delta chains after repacking. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science dataset. Contrast the rule using binary and text objects inspected without changing working files. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA website. Stress-test the rule using a clone whose object database must be diagnosed read-only. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers reading the two sizes as working-tree file length and repository total size.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Create known blobs and commits, then compare record fields with cat-file and the pack file itself.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Ordinary records expose storage facts?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing reading the two sizes as working-tree file length and repository total size be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny reading-notes repository with similar text files that form delta chains after repacking. Include one ordinary case, one boundary and one deliberate failure caused by reading the two sizes as working-tree file length and repository total size. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Ordinary records expose storage facts, separate the documented Git verify-pack 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

Pack objects use Git object types such as commit, tree, blob and tag; a blob record does not reveal its original pathname. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is searching the verbose list for README.md and concluding the file is absent. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Map an object ID back through trees or revisions with separate Git plumbing.

For the Object type is not file extension chapter on Git verify-pack, 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 searching the verbose list for README.md and concluding the file is absent. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

oid=$(git rev-parse HEAD:README.md)
git cat-file -t "$oid"

Four purposeful transfer cases

Case 1: science dataset. Predict the rule using binary and text objects inspected without changing working files. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA website. Contrast the rule using a clone whose object database must be diagnosed read-only. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family archive. Stress-test the rule using a copied repository checked before any cleanup or repair. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library catalogue. Explain the rule using pack statistics recorded across two safe repack experiments. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers searching the verbose list for README.md and concluding the file is absent.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Map an object ID back through trees or revisions with separate Git plumbing.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Object type is not file extension?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing searching the verbose list for README.md and concluding the file is absent be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science dataset with binary and text objects inspected without changing working files. Include one ordinary case, one boundary and one deliberate failure caused by searching the verbose list for README.md and concluding the file is absent. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Object type is not file extension, separate the documented Git verify-pack 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

Verbose size fields distinguish logical object data size from bytes occupied by its packed representation. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is calling a high compression ratio proof that a file is redundant or safe to delete. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compare like object types and content, and remember that delta storage and compression are implementation details.

For the Uncompressed and packed sizes answer different questions chapter on Git verify-pack, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on calling a high compression ratio proof that a file is redundant or safe to delete. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git cat-file -s "$oid"
git verify-pack -v "$idx" | grep "^$oid "

Four purposeful transfer cases

Case 1: family archive. Contrast the rule using a copied repository checked before any cleanup or repair. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library catalogue. Stress-test the rule using pack statistics recorded across two safe repack experiments. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Explain the rule using valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Transfer the rule using verify-pack compared with fsck, cat-file, count-objects, show-index and repack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers calling a high compression ratio proof that a file is redundant or safe to delete.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Compare like object types and content, and remember that delta storage and compression are implementation details.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Uncompressed and packed sizes answer different questions?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing calling a high compression ratio proof that a file is redundant or safe to delete be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA website with a clone whose object database must be diagnosed read-only. Include one ordinary case, one boundary and one deliberate failure caused by calling a high compression ratio proof that a file is redundant or safe to delete. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Uncompressed and packed sizes answer different questions, separate the documented Git verify-pack mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The offset field gives the position of the object entry within the pack stream and supports low-level inspection or cross-checking. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is treating offsets as stable identifiers that survive repacking. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Record pack identity with every offset and expect a new repack to change storage layout.

For the Offsets locate records inside the pack chapter on Git verify-pack, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on treating offsets as stable identifiers that survive repacking. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git verify-pack -v "$idx" | sort -k5,5n | head

Four purposeful transfer cases

Case 1: test laboratory. Stress-test the rule using valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Explain the rule using verify-pack compared with fsck, cat-file, count-objects, show-index and repack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework repository. Transfer the rule using many revisions compacted into one disposable pack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading-notes repository. Predict the rule using similar text files that form delta chains after repacking. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers treating offsets as stable identifiers that survive repacking.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Record pack identity with every offset and expect a new repack to change storage layout.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Offsets locate records inside the pack?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating offsets as stable identifiers that survive repacking be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family archive with a copied repository checked before any cleanup or repair. Include one ordinary case, one boundary and one deliberate failure caused by treating offsets as stable identifiers that survive repacking. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Offsets locate records inside the pack, separate the documented Git verify-pack mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

A delta record includes chain depth and base information in addition to its core storage fields, showing that reconstruction depends on other object data. 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 deltified object is incomplete or corrupted because its full bytes are not stored independently. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use the verbose record and cat-file to compare storage representation with the reconstructed object.

For the Deltified records name a base and depth chapter on Git verify-pack, 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 deltified object is incomplete or corrupted because its full bytes are not stored independently. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git verify-pack -v "$idx" | awk 'NF >= 7 {print; exit}'

Four purposeful transfer cases

Case 1: homework repository. Explain the rule using many revisions compacted into one disposable pack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading-notes repository. Transfer the rule using similar text files that form delta chains after repacking. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science dataset. Predict the rule using binary and text objects inspected without changing working files. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA website. Contrast the rule using a clone whose object database must be diagnosed read-only. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers assuming a deltified object is incomplete or corrupted because its full bytes are not stored independently.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Use the verbose record and cat-file to compare storage representation with the reconstructed object.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Deltified records name a base and depth?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming a deltified object is incomplete or corrupted because its full bytes are not stored independently be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library catalogue with pack statistics recorded across two safe repack experiments. Include one ordinary case, one boundary and one deliberate failure caused by assuming a deltified object is incomplete or corrupted because its full bytes are not stored independently. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Deltified records name a base and depth, separate the documented Git verify-pack 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

Depth counts how many delta applications lie between an object and a non-delta base, while the histogram summarizes counts by depth. 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 a deeper chain directly with repository damage or user-visible slowness. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compare depth distributions before and after a controlled repack and measure real operations separately.

For the Delta depth measures reconstruction links chapter on Git verify-pack, 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 a deeper chain directly with repository damage or user-visible slowness. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git verify-pack -v "$idx" | tail -n 12

Four purposeful transfer cases

Case 1: science dataset. Transfer the rule using binary and text objects inspected without changing working files. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA website. Predict the rule using a clone whose object database must be diagnosed read-only. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family archive. Contrast the rule using a copied repository checked before any cleanup or repair. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library catalogue. Stress-test the rule using pack statistics recorded across two safe repack experiments. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers equating a deeper chain directly with repository damage or user-visible slowness.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Compare depth distributions before and after a controlled repack and measure real operations separately.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Delta depth measures reconstruction links?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing equating a deeper chain directly with repository damage or user-visible slowness be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. Include one ordinary case, one boundary and one deliberate failure caused by equating a deeper chain directly with repository damage or user-visible slowness. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Delta depth measures reconstruction links, separate the documented Git verify-pack mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

A repository can contain several .idx/.pack pairs, and verifying one pair leaves the others unexamined. 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 find -print -quit in a final audit and claiming the entire packed store was checked. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Enumerate every current index with NUL-safe shell handling and retain a per-pack status.

For the Multiple packs require multiple checks chapter on Git verify-pack, 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 find -print -quit in a final audit and claiming the entire packed store was checked. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

find .git/objects/pack -name '*.idx' -print0 |
while IFS= read -r -d '' idx; do git verify-pack "$idx" || exit; done

Four purposeful transfer cases

Case 1: family archive. Predict the rule using a copied repository checked before any cleanup or repair. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library catalogue. Contrast the rule using pack statistics recorded across two safe repack experiments. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Stress-test the rule using valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Explain the rule using verify-pack compared with fsck, cat-file, count-objects, show-index and repack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers using find -print -quit in a final audit and claiming the entire packed store was checked.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Enumerate every current index with NUL-safe shell handling and retain a per-pack status.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Multiple packs require multiple checks?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using find -print -quit in a final audit and claiming the entire packed store was checked be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design decision with verify-pack compared with fsck, cat-file, count-objects, show-index and repack. Include one ordinary case, one boundary and one deliberate failure caused by using find -print -quit in a final audit and claiming the entire packed store was checked. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Multiple packs require multiple checks, separate the documented Git verify-pack 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

-s or –stat-only reports the delta-chain histogram but the manual states that it does not verify pack contents. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is using the faster statistical mode as a corruption check. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Choose stat-only only when chain distribution is the question and label the result accordingly.

For the stat-only deliberately skips content verification chapter on Git verify-pack, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using the faster statistical mode as a corruption check. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git verify-pack --stat-only "$idx"

Four purposeful transfer cases

Case 1: test laboratory. Contrast the rule using valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Stress-test the rule using verify-pack compared with fsck, cat-file, count-objects, show-index and repack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework repository. Explain the rule using many revisions compacted into one disposable pack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading-notes repository. Transfer the rule using similar text files that form delta chains after repacking. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers using the faster statistical mode as a corruption check.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Choose stat-only only when chain distribution is the question and label the result accordingly.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from stat-only deliberately skips content verification?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using the faster statistical mode as a corruption check 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 many revisions compacted into one disposable pack. Include one ordinary case, one boundary and one deliberate failure caused by using the faster statistical mode as a corruption check. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For stat-only deliberately skips content verification, separate the documented Git verify-pack mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

With –stat-only and –verbose, the object list is also shown even though the operation remains the statistical mode described by the manual. 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 verbose always restores full content verification regardless of other options. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Record the complete option set and avoid shortening it to verbose check in notes.

For the Combining stat-only and verbose changes output chapter on Git verify-pack, 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 verbose always restores full content verification regardless of other options. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git verify-pack --stat-only --verbose "$idx"

Four purposeful transfer cases

Case 1: homework repository. Stress-test the rule using many revisions compacted into one disposable pack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading-notes repository. Explain the rule using similar text files that form delta chains after repacking. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science dataset. Transfer the rule using binary and text objects inspected without changing working files. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA website. Predict the rule using a clone whose object database must be diagnosed read-only. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers assuming verbose always restores full content verification regardless of other options.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Record the complete option set and avoid shortening it to verbose check in notes.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Combining stat-only and verbose changes output?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming verbose always restores full content verification regardless of other options be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny reading-notes repository with similar text files that form delta chains after repacking. Include one ordinary case, one boundary and one deliberate failure caused by assuming verbose always restores full content verification regardless of other options. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Combining stat-only and verbose changes output, separate the documented Git verify-pack 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

–object-format selects the hash algorithm used to interpret the pack; current Git documents sha1 and sha256 values. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is forcing sha256 on a SHA-1 repository because longer object names seem safer. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Read the repository object format first and pass an option only when a controlled diagnostic requires it.

For the Object format must match interpretation chapter on Git verify-pack, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on forcing sha256 on a SHA-1 repository because longer object names seem safer. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

fmt=$(git rev-parse --show-object-format)
git verify-pack --object-format="$fmt" "$idx"

Four purposeful transfer cases

Case 1: science dataset. Explain the rule using binary and text objects inspected without changing working files. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA website. Transfer the rule using a clone whose object database must be diagnosed read-only. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family archive. Predict the rule using a copied repository checked before any cleanup or repair. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library catalogue. Contrast the rule using pack statistics recorded across two safe repack experiments. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers forcing sha256 on a SHA-1 repository because longer object names seem safer.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Read the repository object format first and pass an option only when a controlled diagnostic requires it.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Object format must match interpretation?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing forcing sha256 on a SHA-1 repository because longer object names seem safer be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science dataset with binary and text objects inspected without changing working files. Include one ordinary case, one boundary and one deliberate failure caused by forcing sha256 on a SHA-1 repository because longer object names seem safer. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Object format must match interpretation, separate the documented Git verify-pack 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

— tells Git to treat later arguments as paths even when a filename begins with a hyphen. 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 concatenating an untrusted filename after options and allowing it to be parsed as another flag. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use exact resolved paths, quote them and place — before path operands.

For the Double dash ends option parsing chapter on Git verify-pack, 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 concatenating an untrusted filename after options and allowing it to be parsed as another flag. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git verify-pack -v -- "$idx"

Four purposeful transfer cases

Case 1: family archive. Transfer the rule using a copied repository checked before any cleanup or repair. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library catalogue. Predict the rule using pack statistics recorded across two safe repack experiments. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Contrast the rule using valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Stress-test the rule using verify-pack compared with fsck, cat-file, count-objects, show-index and repack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers concatenating an untrusted filename after options and allowing it to be parsed as another flag.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Use exact resolved paths, quote them and place — before path operands.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Double dash ends option parsing?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing concatenating an untrusted filename after options and allowing it to be parsed as another flag be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA website with a clone whose object database must be diagnosed read-only. Include one ordinary case, one boundary and one deliberate failure caused by concatenating an untrusted filename after options and allowing it to be parsed as another flag. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Double dash ends option parsing, separate the documented Git verify-pack 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

Maintenance, fetch, gc or repack can replace pack files while a diagnostic script is discovering them. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is listing indexes and later assuming every listed pair still exists unchanged. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Avoid concurrent maintenance, work on a safe copied repository when possible and resolve each pair immediately before checking.

For the Run against a stable object-store snapshot chapter on Git verify-pack, 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 listing indexes and later assuming every listed pair still exists unchanged. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

cp -a repo repo-diagnostic
git -C repo-diagnostic verify-pack repo-diagnostic/.git/objects/pack/pack-example.idx

Four purposeful transfer cases

Case 1: test laboratory. Predict the rule using valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Contrast the rule using verify-pack compared with fsck, cat-file, count-objects, show-index and repack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework repository. Stress-test the rule using many revisions compacted into one disposable pack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading-notes repository. Explain the rule using similar text files that form delta chains after repacking. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers listing indexes and later assuming every listed pair still exists unchanged.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Avoid concurrent maintenance, work on a safe copied repository when possible and resolve each pair immediately before checking.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Run against a stable object-store snapshot?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing listing indexes and later assuming every listed pair still exists unchanged be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family archive with a copied repository checked before any cleanup or repair. Include one ordinary case, one boundary and one deliberate failure caused by listing indexes and later assuming every listed pair still exists unchanged. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Run against a stable object-store snapshot, separate the documented Git verify-pack 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

Truncating or editing a pack should be practised only on a disposable copy so learners can observe non-zero status and diagnostics without harming history. 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 corrupting the only repository to see what verify-pack says. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Copy one pack and index into a laboratory object store, preserve originals and alter only the copied pack.

For the A damaged copy is a safe failure exercise chapter on Git verify-pack, 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 corrupting the only repository to see what verify-pack says. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

cp "$pack" lab.pack
cp "$idx" lab.idx
truncate -s -1 lab.pack
git verify-pack lab.idx

Four purposeful transfer cases

Case 1: homework repository. Contrast the rule using many revisions compacted into one disposable pack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading-notes repository. Stress-test the rule using similar text files that form delta chains after repacking. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science dataset. Explain the rule using binary and text objects inspected without changing working files. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA website. Transfer the rule using a clone whose object database must be diagnosed read-only. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers corrupting the only repository to see what verify-pack says.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Copy one pack and index into a laboratory object store, preserve originals and alter only the copied pack.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from A damaged copy is a safe failure exercise?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing corrupting the only repository to see what verify-pack says be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library catalogue with pack statistics recorded across two safe repack experiments. Include one ordinary case, one boundary and one deliberate failure caused by corrupting the only repository to see what verify-pack says. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For A damaged copy is a safe failure exercise, separate the documented Git verify-pack 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

verify-pack describes storage in one pack, while cat-file reads reconstructed object type, size or content through the object database. 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 verify-pack output as a substitute for validating an object the application actually needs. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Select one ID from the verbose report and query it with cat-file inside the matching repository.

For the Cross-check objects with cat-file chapter on Git verify-pack, 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 verify-pack output as a substitute for validating an object the application actually needs. 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 -s "$oid"

Four purposeful transfer cases

Case 1: science dataset. Stress-test the rule using binary and text objects inspected without changing working files. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA website. Explain the rule using a clone whose object database must be diagnosed read-only. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family archive. Transfer the rule using a copied repository checked before any cleanup or repair. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library catalogue. Predict the rule using pack statistics recorded across two safe repack experiments. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers using verify-pack output as a substitute for validating an object the application actually needs.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Select one ID from the verbose report and query it with cat-file inside the matching repository.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Cross-check objects with cat-file?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using verify-pack output as a substitute for validating an object the application actually needs be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. Include one ordinary case, one boundary and one deliberate failure caused by using verify-pack output as a substitute for validating an object the application actually needs. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

git fsck checks object connectivity and validity more broadly, count-objects summarizes storage, and verify-pack focuses on an indexed pack. 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 reporting one verified pack as proof that references, loose objects and reachability are all sound. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Write the diagnostic question first and combine read-only tools whose contracts cover it.

For the Choose broader diagnostics when the question is broader chapter on Git verify-pack, 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 reporting one verified pack as proof that references, loose objects and reachability are all sound. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git fsck --full
git count-objects -v
git verify-pack "$idx"

Four purposeful transfer cases

Case 1: family archive. Explain the rule using a copied repository checked before any cleanup or repair. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library catalogue. Transfer the rule using pack statistics recorded across two safe repack experiments. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Predict the rule using valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Contrast the rule using verify-pack compared with fsck, cat-file, count-objects, show-index and repack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers reporting one verified pack as proof that references, loose objects and reachability are all sound.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Write the diagnostic question first and combine read-only tools whose contracts cover it.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Choose broader diagnostics when the question is broader?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing reporting one verified pack as proof that references, loose objects and reachability are all sound be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design decision with verify-pack compared with fsck, cat-file, count-objects, show-index and repack. Include one ordinary case, one boundary and one deliberate failure caused by reporting one verified pack as proof that references, loose objects and reachability are all sound. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Choose broader diagnostics when the question is broader, separate the documented Git verify-pack 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

verify-pack does not fix corruption, shorten delta chains or delete redundant packs; repair decisions require backups, provenance and a recovery plan. 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 running gc, prune or repack immediately after any surprising statistic. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Preserve a copy, verify all relevant stores, identify the affected objects and choose a recovery source before mutation.

For the Verify first, repair only with evidence chapter on Git verify-pack, 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 running gc, prune or repack immediately after any surprising statistic. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git verify-pack "$idx" || {
  echo 'stop and preserve evidence' >&2
  exit 1
}

Four purposeful transfer cases

Case 1: test laboratory. Transfer the rule using valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Predict the rule using verify-pack compared with fsck, cat-file, count-objects, show-index and repack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework repository. Contrast the rule using many revisions compacted into one disposable pack. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading-notes repository. Stress-test the rule using similar text files that form delta chains after repacking. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers running gc, prune or repack immediately after any surprising statistic.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Preserve a copy, verify all relevant stores, identify the affected objects and choose a recovery source before mutation.” 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 verify-pack syntax. For this chapter, useful prompts are: “What did you expect from Verify first, repair only with evidence?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing running gc, prune or repack immediately after any surprising statistic 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 many revisions compacted into one disposable pack. Include one ordinary case, one boundary and one deliberate failure caused by running gc, prune or repack immediately after any surprising statistic. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Verify first, repair only with evidence, separate the documented Git verify-pack mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

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

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

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

1. homework repository: model, boundary and recovery

Create a small homework repository using many revisions compacted into one disposable pack. Combine “verify-pack checks one indexed pack” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

2. reading-notes repository: model, boundary and recovery

Create a small reading-notes repository using similar text files that form delta chains after repacking. Combine “Verbose mode lists objects and a histogram” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

3. science dataset: model, boundary and recovery

Create a small science dataset using binary and text objects inspected without changing working files. Combine “Uncompressed and packed sizes answer different questions” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

4. CCA website: model, boundary and recovery

Create a small CCA website using a clone whose object database must be diagnosed read-only. Combine “Delta depth measures reconstruction links” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

5. family archive: model, boundary and recovery

Create a small family archive using a copied repository checked before any cleanup or repair. Combine “Combining stat-only and verbose changes output” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

6. library catalogue: model, boundary and recovery

Create a small library catalogue using pack statistics recorded across two safe repack experiments. Combine “Run against a stable object-store snapshot” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

7. test laboratory: model, boundary and recovery

Create a small test laboratory using valid indexes, damaged copies, multiple packs and SHA-1 or SHA-256 repositories. Combine “Choose broader diagnostics when the question is broader” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

8. design decision: model, boundary and recovery

Create a small design decision using verify-pack compared with fsck, cat-file, count-objects, show-index and repack. Combine “The input is normally the .idx path” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Frequently asked questions

How long should a practice session be?

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

Should every option or function be memorised?

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

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

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

Is the shortest solution the best?

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

When should official documentation be used?

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

How can a parent help without technical expertise?

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

How do we test transfer?

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

What should be saved after practice?

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

Can these exercises replace backups?

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

What counts as mastery?

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

Official and supporting references

• Primary technical documentation for Git verify-pack
• eduKatePunggol: How Studying Works

Return to contents