PUNGGOL TUITION · PRACTICAL MASTERY GUIDE

If a learner sees duplicate objects and reaches immediately for a deletion command, the first lesson is restraint. git pack-redundant is deprecated, scheduled for removal, limited to whole duplicate packs and usually the wrong answer for repository maintenance.

The safe core lesson is diagnostic: current Git requires –i-still-use-this, –all or explicit pack names selects the scope, standard input can exclude objects, –alt-odb changes required coverage, and –verbose writes statistics to stderr. For normal cleanup, the official manual recommends git gc.

This guide treats Git pack-redundant as a reasoning skill. It begins with the governing model, moves through worked examples and diagnostic routes, and ends with transfer cases, practice with explained answers, parent decisions and FAQs. The examples are proposed home or lesson activities; they are not claims about a physical Punggol branch, school affiliation, timetable, class size, fee or guaranteed result.

For a Punggol family, the practical aim is simple: a learner should be able to use a short study block before schoolwork, after CCA, or during a weekend library session without needing a large project. Each chapter is designed so the smallest useful example can be completed, discussed and saved as a test fixture.

The official technical reference for this article is Official git-pack-redundant manual. Where the feature is version-sensitive or still developing, the article states that boundary explicitly. Examples were independently checked against the runtime or specification named in the reference section.

Choose a reading route

If the immediate concern is “I can copy the syntax but I cannot explain the result”, use the first route. If a real project is already failing, use the diagnostic route. Parents can use the final route to decide whether more practice, a smaller prerequisite or a different example is needed. For the wider learning framework, see How Studying Works.

Start from the model: Chapters 1–4. Begin with Deprecation is the first fact and continue in order to Whole packs versus duplicate objects.

Diagnose a confusing result: Chapters 5–8. Begin with The acknowledgement flag and continue in order to –all processes all local packs.

Build reliable examples: Chapters 9–12. Begin with Explicit pack-filename mode and continue in order to Standard-input ignored objects.

Transfer to real work: Chapters 13–16. Begin with Do not pipe a lesson into rm and continue in order to Verify packs before interpreting redundancy.

Decide and teach: Chapters 17–20. Begin with Run fsck as a separate integrity check and continue in order to Choosing the supported route.

Open the full 20-chapter index

1. 1. Deprecation is the first fact
2. 2. Why git gc is usually better
3. 3. What a redundant pack means
4. 4. Whole packs versus duplicate objects
5. 5. The acknowledgement flag
6. 6. Inventory before analysis
7. 7. A safe duplicate-pack fixture
8. 8. –all processes all local packs
9. 9. Explicit pack-filename mode
10. 10. Output contains both index and pack paths
11. 11. –verbose writes statistics to stderr
12. 12. Standard-input ignored objects
13. 13. Do not pipe a lesson into rm
14. 14. –alt-odb and alternates
15. 15. Inspect alternates explicitly
16. 16. Verify packs before interpreting redundancy
17. 17. Run fsck as a separate integrity check
18. 18. Concurrent maintenance changes the answer
19. 19. Plan for command removal
20. 20. Choosing the supported route

CHAPTER 1 OF 20 · Back to contents

1. Deprecation is the first fact

The short answer: git pack-redundant is deprecated and scheduled for removal. The governing rule is: A tutorial must begin by questioning whether the command should be used at all.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The official manual explains that whole-pack removal rarely solves modern repository-size problems well. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the deprecation is the first fact example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git --version
git pack-redundant --i-still-use-this --all

Expected result and reasoning. On Git 2.51.1 the acknowledgement flag permits the diagnostic command; without it the command fails. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Presenting the tool as a routine cleanup recommendation ignores its published lifecycle. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “What unique job remains after considering git gc?”

• Evidence to collect: the exact input, environment version, observed result and the rule for deprecation is the first fact
• Variable to hold constant: the surrounding setup, so the comparison isolates deprecation is the first fact.
• Variable to change: run the command without the acknowledgement flag in a disposable repository
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For deprecation is the first fact, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a disposable repository. Transfer deprecation is the first fact into a disposable repository. Preserve the governing rule—A tutorial must begin by questioning whether the command should be used at all.—while identifying what changes in this setting. git pack-redundant is deprecated and scheduled for removal. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A tutorial must begin by questioning whether the command should be used at all.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a backup clone. Transfer deprecation is the first fact into a backup clone. Preserve the governing rule—A tutorial must begin by questioning whether the command should be used at all.—while identifying what changes in this setting. git pack-redundant is deprecated and scheduled for removal. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A tutorial must begin by questioning whether the command should be used at all.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a recovery rehearsal. Transfer deprecation is the first fact into a recovery rehearsal. Preserve the governing rule—A tutorial must begin by questioning whether the command should be used at all.—while identifying what changes in this setting. git pack-redundant is deprecated and scheduled for removal. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A tutorial must begin by questioning whether the command should be used at all.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a migration test. Transfer deprecation is the first fact into a migration test. Preserve the governing rule—A tutorial must begin by questioning whether the command should be used at all.—while identifying what changes in this setting. git pack-redundant is deprecated and scheduled for removal. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A tutorial must begin by questioning whether the command should be used at all.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for deprecation is the first fact, predict the result, then run the command without the acknowledgement flag in a disposable repository. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. On Git 2.51.1 the acknowledgement flag permits the diagnostic command; without it the command fails. The contrast is explained by this rule: A tutorial must begin by questioning whether the command should be used at all. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for deprecation is the first fact, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain deprecation is the first fact, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Contents · Full contents · Next: Why git gc is usually better →

CHAPTER 2 OF 20 · Back to contents

2. Why git gc is usually better

The short answer: git gc can repack objects and remove duplicates across packs. The governing rule is: Prefer gc for ordinary maintenance.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

pack-redundant removes only complete packs that another selected pack set makes unnecessary; it cannot surgically remove duplicate objects inside still-needed packs. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the why git gc is usually better example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git gc

Expected result and reasoning. For normal repositories, this is the official recommendation instead of pack-redundant. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Deleting every pack named by a naive duplicate-object count can destroy required objects. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Is the goal maintenance, forensic inspection or a narrowly justified whole-pack decision?”

• Evidence to collect: the exact input, environment version, observed result and the rule for why git gc is usually better
• Variable to hold constant: the surrounding setup, so the comparison isolates why git gc is usually better.
• Variable to change: compare the contracts of gc and pack-redundant
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For why git gc is usually better, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a CI maintenance job. Transfer why git gc is usually better into a CI maintenance job. Preserve the governing rule—Prefer gc for ordinary maintenance.—while identifying what changes in this setting. git gc can repack objects and remove duplicates across packs. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Prefer gc for ordinary maintenance.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: an alternate object database. Transfer why git gc is usually better into an alternate object database. Preserve the governing rule—Prefer gc for ordinary maintenance.—while identifying what changes in this setting. git gc can repack objects and remove duplicates across packs. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Prefer gc for ordinary maintenance.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a repository-size investigation. Transfer why git gc is usually better into a repository-size investigation. Preserve the governing rule—Prefer gc for ordinary maintenance.—while identifying what changes in this setting. git gc can repack objects and remove duplicates across packs. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Prefer gc for ordinary maintenance.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: an administrator runbook. Transfer why git gc is usually better into an administrator runbook. Preserve the governing rule—Prefer gc for ordinary maintenance.—while identifying what changes in this setting. git gc can repack objects and remove duplicates across packs. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Prefer gc for ordinary maintenance.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for why git gc is usually better, predict the result, then compare the contracts of gc and pack-redundant. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. For normal repositories, this is the official recommendation instead of pack-redundant. The contrast is explained by this rule: Prefer gc for ordinary maintenance. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for why git gc is usually better, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain why git gc is usually better, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: Deprecation is the first fact · Full contents · Next: What a redundant pack means →

CHAPTER 3 OF 20 · Back to contents

3. What a redundant pack means

The short answer: A redundant pack is a whole pack that is unnecessary to cover the required object set. The governing rule is: Redundancy is evaluated at pack-set level, not file-name similarity.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The command computes a small set of packs covering required objects and reports other whole packs as redundant. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the what a redundant pack means example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git pack-redundant --i-still-use-this --all

Expected result and reasoning. The output lists redundant .idx and .pack paths when such a set exists. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Two packs sharing some objects are not automatically interchangeable. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Are all required objects covered without this entire pack?”

• Evidence to collect: the exact input, environment version, observed result and the rule for what a redundant pack means
• Variable to hold constant: the surrounding setup, so the comparison isolates what a redundant pack means.
• Variable to change: construct two identical pack copies in a disposable fixture
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For what a redundant pack means, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a backup clone. Transfer what a redundant pack means into a backup clone. Preserve the governing rule—Redundancy is evaluated at pack-set level, not file-name similarity.—while identifying what changes in this setting. A redundant pack is a whole pack that is unnecessary to cover the required object set. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Redundancy is evaluated at pack-set level, not file-name similarity.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a recovery rehearsal. Transfer what a redundant pack means into a recovery rehearsal. Preserve the governing rule—Redundancy is evaluated at pack-set level, not file-name similarity.—while identifying what changes in this setting. A redundant pack is a whole pack that is unnecessary to cover the required object set. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Redundancy is evaluated at pack-set level, not file-name similarity.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a migration test. Transfer what a redundant pack means into a migration test. Preserve the governing rule—Redundancy is evaluated at pack-set level, not file-name similarity.—while identifying what changes in this setting. A redundant pack is a whole pack that is unnecessary to cover the required object set. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Redundancy is evaluated at pack-set level, not file-name similarity.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a disposable repository. Transfer what a redundant pack means into a disposable repository. Preserve the governing rule—Redundancy is evaluated at pack-set level, not file-name similarity.—while identifying what changes in this setting. A redundant pack is a whole pack that is unnecessary to cover the required object set. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Redundancy is evaluated at pack-set level, not file-name similarity.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for what a redundant pack means, predict the result, then construct two identical pack copies in a disposable fixture. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The output lists redundant .idx and .pack paths when such a set exists. The contrast is explained by this rule: Redundancy is evaluated at pack-set level, not file-name similarity. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for what a redundant pack means, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain what a redundant pack means, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: Why git gc is usually better · Full contents · Next: Whole packs versus duplicate objects →

CHAPTER 4 OF 20 · Back to contents

4. Whole packs versus duplicate objects

The short answer: The tool cannot remove individual duplicate objects from a needed pack. The governing rule is: One unique object can keep an otherwise overlapping pack necessary.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

Pack files are compressed object collections whose usefulness is decided as a unit by this command. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the whole packs versus duplicate objects example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git verify-pack -v .git/objects/pack/pack-A.idx
git verify-pack -v .git/objects/pack/pack-B.idx

Expected result and reasoning. Object inventories can reveal overlap, but pack-redundant still reports only whole files. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Counting duplicate rows and expecting proportional disk savings overstates the output. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Does each candidate pack contain any object unavailable elsewhere?”

• Evidence to collect: the exact input, environment version, observed result and the rule for whole packs versus duplicate objects
• Variable to hold constant: the surrounding setup, so the comparison isolates whole packs versus duplicate objects.
• Variable to change: add one unique object to one pack
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For whole packs versus duplicate objects, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: an alternate object database. Transfer whole packs versus duplicate objects into an alternate object database. Preserve the governing rule—One unique object can keep an otherwise overlapping pack necessary.—while identifying what changes in this setting. The tool cannot remove individual duplicate objects from a needed pack. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “One unique object can keep an otherwise overlapping pack necessary.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a repository-size investigation. Transfer whole packs versus duplicate objects into a repository-size investigation. Preserve the governing rule—One unique object can keep an otherwise overlapping pack necessary.—while identifying what changes in this setting. The tool cannot remove individual duplicate objects from a needed pack. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “One unique object can keep an otherwise overlapping pack necessary.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: an administrator runbook. Transfer whole packs versus duplicate objects into an administrator runbook. Preserve the governing rule—One unique object can keep an otherwise overlapping pack necessary.—while identifying what changes in this setting. The tool cannot remove individual duplicate objects from a needed pack. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “One unique object can keep an otherwise overlapping pack necessary.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a CI maintenance job. Transfer whole packs versus duplicate objects into a CI maintenance job. Preserve the governing rule—One unique object can keep an otherwise overlapping pack necessary.—while identifying what changes in this setting. The tool cannot remove individual duplicate objects from a needed pack. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “One unique object can keep an otherwise overlapping pack necessary.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for whole packs versus duplicate objects, predict the result, then add one unique object to one pack. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. Object inventories can reveal overlap, but pack-redundant still reports only whole files. The contrast is explained by this rule: One unique object can keep an otherwise overlapping pack necessary. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for whole packs versus duplicate objects, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain whole packs versus duplicate objects, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: What a redundant pack means · Full contents · Next: The acknowledgement flag →

CHAPTER 5 OF 20 · Back to contents

5. The acknowledgement flag

The short answer: Current Git releases may require –i-still-use-this even though older synopsis text omits it. The governing rule is: Bind invocations to the installed Git version and manual warning.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The flag is an intentional friction point signalling deprecation, not a generic option to hide in an alias. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the the acknowledgement flag example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git pack-redundant --all
git pack-redundant --i-still-use-this --all

Expected result and reasoning. In Git 2.51.1 the first fails and the second runs. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Creating a permanent alias conceals the warning from future maintainers. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “What should happen when a later Git removes the command entirely?”

• Evidence to collect: the exact input, environment version, observed result and the rule for the acknowledgement flag
• Variable to hold constant: the surrounding setup, so the comparison isolates the acknowledgement flag.
• Variable to change: capture both exit statuses and stderr
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For the acknowledgement flag, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a recovery rehearsal. Transfer the acknowledgement flag into a recovery rehearsal. Preserve the governing rule—Bind invocations to the installed Git version and manual warning.—while identifying what changes in this setting. Current Git releases may require –i-still-use-this even though older synopsis text omits it. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Bind invocations to the installed Git version and manual warning.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a migration test. Transfer the acknowledgement flag into a migration test. Preserve the governing rule—Bind invocations to the installed Git version and manual warning.—while identifying what changes in this setting. Current Git releases may require –i-still-use-this even though older synopsis text omits it. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Bind invocations to the installed Git version and manual warning.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a disposable repository. Transfer the acknowledgement flag into a disposable repository. Preserve the governing rule—Bind invocations to the installed Git version and manual warning.—while identifying what changes in this setting. Current Git releases may require –i-still-use-this even though older synopsis text omits it. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Bind invocations to the installed Git version and manual warning.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a backup clone. Transfer the acknowledgement flag into a backup clone. Preserve the governing rule—Bind invocations to the installed Git version and manual warning.—while identifying what changes in this setting. Current Git releases may require –i-still-use-this even though older synopsis text omits it. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Bind invocations to the installed Git version and manual warning.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for the acknowledgement flag, predict the result, then capture both exit statuses and stderr. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. In Git 2.51.1 the first fails and the second runs. The contrast is explained by this rule: Bind invocations to the installed Git version and manual warning. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for the acknowledgement flag, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain the acknowledgement flag, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: Whole packs versus duplicate objects · Full contents · Next: Inventory before analysis →

CHAPTER 6 OF 20 · Back to contents

6. Inventory before analysis

The short answer: List pack, index and reverse-index files before interpreting output. The governing rule is: Evidence starts with exact repository state.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

Repacking, fetching or concurrent maintenance can change the pack set between observation and action. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the inventory before analysis example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

find .git/objects/pack -maxdepth 1 -type f -name 'pack-*' -print
git count-objects -v

Expected result and reasoning. The inventory records filenames and aggregate storage before the diagnostic. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Running against the wrong worktree or bare repository produces a convincing but irrelevant answer. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Which git directory owns these packs?”

• Evidence to collect: the exact input, environment version, observed result and the rule for inventory before analysis
• Variable to hold constant: the surrounding setup, so the comparison isolates inventory before analysis.
• Variable to change: record git rev-parse –git-dir and absolute paths
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For inventory before analysis, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a repository-size investigation. Transfer inventory before analysis into a repository-size investigation. Preserve the governing rule—Evidence starts with exact repository state.—while identifying what changes in this setting. List pack, index and reverse-index files before interpreting output. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Evidence starts with exact repository state.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: an administrator runbook. Transfer inventory before analysis into an administrator runbook. Preserve the governing rule—Evidence starts with exact repository state.—while identifying what changes in this setting. List pack, index and reverse-index files before interpreting output. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Evidence starts with exact repository state.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a CI maintenance job. Transfer inventory before analysis into a CI maintenance job. Preserve the governing rule—Evidence starts with exact repository state.—while identifying what changes in this setting. List pack, index and reverse-index files before interpreting output. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Evidence starts with exact repository state.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: an alternate object database. Transfer inventory before analysis into an alternate object database. Preserve the governing rule—Evidence starts with exact repository state.—while identifying what changes in this setting. List pack, index and reverse-index files before interpreting output. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Evidence starts with exact repository state.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for inventory before analysis, predict the result, then record git rev-parse –git-dir and absolute paths. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The inventory records filenames and aggregate storage before the diagnostic. The contrast is explained by this rule: Evidence starts with exact repository state. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for inventory before analysis, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain inventory before analysis, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: The acknowledgement flag · Full contents · Next: A safe duplicate-pack fixture →

CHAPTER 7 OF 20 · Back to contents

7. A safe duplicate-pack fixture

The short answer: Experiments belong in a disposable repository. The governing rule is: Never practise pack deletion on the only copy of meaningful work.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

A small repository can be packed, then its .pack and .idx copied under another valid pack-style basename to produce whole-pack redundancy for observation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the a safe duplicate-pack fixture example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

tmp=$(mktemp -d)
git init "$tmp/repo"
# add test commits, repack, then duplicate the pack and index under a second pack-<40hex> basename

Expected result and reasoning. Git 2.51.1 reports one duplicate pair as redundant in the verified fixture. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Copying only .pack without its .idx creates a broken fixture rather than a redundant indexed pack. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Can the entire directory be discarded safely?”

• Evidence to collect: the exact input, environment version, observed result and the rule for a safe duplicate-pack fixture
• Variable to hold constant: the surrounding setup, so the comparison isolates a safe duplicate-pack fixture.
• Variable to change: remove one copied index and observe the changed state
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For a safe duplicate-pack fixture, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a migration test. Transfer a safe duplicate-pack fixture into a migration test. Preserve the governing rule—Never practise pack deletion on the only copy of meaningful work.—while identifying what changes in this setting. Experiments belong in a disposable repository. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Never practise pack deletion on the only copy of meaningful work.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a disposable repository. Transfer a safe duplicate-pack fixture into a disposable repository. Preserve the governing rule—Never practise pack deletion on the only copy of meaningful work.—while identifying what changes in this setting. Experiments belong in a disposable repository. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Never practise pack deletion on the only copy of meaningful work.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a backup clone. Transfer a safe duplicate-pack fixture into a backup clone. Preserve the governing rule—Never practise pack deletion on the only copy of meaningful work.—while identifying what changes in this setting. Experiments belong in a disposable repository. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Never practise pack deletion on the only copy of meaningful work.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a recovery rehearsal. Transfer a safe duplicate-pack fixture into a recovery rehearsal. Preserve the governing rule—Never practise pack deletion on the only copy of meaningful work.—while identifying what changes in this setting. Experiments belong in a disposable repository. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Never practise pack deletion on the only copy of meaningful work.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for a safe duplicate-pack fixture, predict the result, then remove one copied index and observe the changed state. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. Git 2.51.1 reports one duplicate pair as redundant in the verified fixture. The contrast is explained by this rule: Never practise pack deletion on the only copy of meaningful work. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for a safe duplicate-pack fixture, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain a safe duplicate-pack fixture, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: Inventory before analysis · Full contents · Next: –all processes all local packs →

CHAPTER 8 OF 20 · Back to contents

8. –all processes all local packs

The short answer: –all tells the command to consider every pack in the repository. The governing rule is: Any pack filenames supplied alongside –all are ignored.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

This mode is convenient for inventory-wide analysis but broadens scope, so repository identity must be explicit. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the –all processes all local packs example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git -C "$tmp/repo" pack-redundant --i-still-use-this --all

Expected result and reasoning. The verified duplicate fixture lists one .idx and one .pack path. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Assuming an extra filename narrows –all contradicts the manual. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Is the intended scope all packs or an explicit subset?”

• Evidence to collect: the exact input, environment version, observed result and the rule for –all processes all local packs
• Variable to hold constant: the surrounding setup, so the comparison isolates –all processes all local packs.
• Variable to change: remove –all and provide selected pack basenames
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For –all processes all local packs, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: an administrator runbook. Transfer –all processes all local packs into an administrator runbook. Preserve the governing rule—Any pack filenames supplied alongside –all are ignored.—while identifying what changes in this setting. –all tells the command to consider every pack in the repository. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Any pack filenames supplied alongside –all are ignored.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a CI maintenance job. Transfer –all processes all local packs into a CI maintenance job. Preserve the governing rule—Any pack filenames supplied alongside –all are ignored.—while identifying what changes in this setting. –all tells the command to consider every pack in the repository. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Any pack filenames supplied alongside –all are ignored.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: an alternate object database. Transfer –all processes all local packs into an alternate object database. Preserve the governing rule—Any pack filenames supplied alongside –all are ignored.—while identifying what changes in this setting. –all tells the command to consider every pack in the repository. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Any pack filenames supplied alongside –all are ignored.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a repository-size investigation. Transfer –all processes all local packs into a repository-size investigation. Preserve the governing rule—Any pack filenames supplied alongside –all are ignored.—while identifying what changes in this setting. –all tells the command to consider every pack in the repository. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Any pack filenames supplied alongside –all are ignored.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for –all processes all local packs, predict the result, then remove –all and provide selected pack basenames. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The verified duplicate fixture lists one .idx and one .pack path. The contrast is explained by this rule: Any pack filenames supplied alongside –all are ignored. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for –all processes all local packs, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain –all processes all local packs, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: A safe duplicate-pack fixture · Full contents · Next: Explicit pack-filename mode →

CHAPTER 9 OF 20 · Back to contents

9. Explicit pack-filename mode

The short answer: Without –all, provide the pack filenames whose set should be processed. The governing rule is: Mode selection is mandatory: use either –all or one or more pack filenames.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

An explicit subset can answer a narrow diagnostic question but does not describe every pack in the repository. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the explicit pack-filename mode example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git pack-redundant --i-still-use-this pack-a pack-b

Expected result and reasoning. The command analyses the named pack set when the names correspond to repository packs. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Omitting both mode and filenames is not an implicit safe dry run. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Which packs are inside and outside the question?”

• Evidence to collect: the exact input, environment version, observed result and the rule for explicit pack-filename mode
• Variable to hold constant: the surrounding setup, so the comparison isolates explicit pack-filename mode.
• Variable to change: compare explicit subset output with –all
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For explicit pack-filename mode, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a disposable repository. Transfer explicit pack-filename mode into a disposable repository. Preserve the governing rule—Mode selection is mandatory: use either –all or one or more pack filenames.—while identifying what changes in this setting. Without –all, provide the pack filenames whose set should be processed. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Mode selection is mandatory: use either –all or one or more pack filenames.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a backup clone. Transfer explicit pack-filename mode into a backup clone. Preserve the governing rule—Mode selection is mandatory: use either –all or one or more pack filenames.—while identifying what changes in this setting. Without –all, provide the pack filenames whose set should be processed. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Mode selection is mandatory: use either –all or one or more pack filenames.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a recovery rehearsal. Transfer explicit pack-filename mode into a recovery rehearsal. Preserve the governing rule—Mode selection is mandatory: use either –all or one or more pack filenames.—while identifying what changes in this setting. Without –all, provide the pack filenames whose set should be processed. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Mode selection is mandatory: use either –all or one or more pack filenames.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a migration test. Transfer explicit pack-filename mode into a migration test. Preserve the governing rule—Mode selection is mandatory: use either –all or one or more pack filenames.—while identifying what changes in this setting. Without –all, provide the pack filenames whose set should be processed. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Mode selection is mandatory: use either –all or one or more pack filenames.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for explicit pack-filename mode, predict the result, then compare explicit subset output with –all. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The command analyses the named pack set when the names correspond to repository packs. The contrast is explained by this rule: Mode selection is mandatory: use either –all or one or more pack filenames. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for explicit pack-filename mode, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain explicit pack-filename mode, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: –all processes all local packs · Full contents · Next: Output contains both index and pack paths →

CHAPTER 10 OF 20 · Back to contents

10. Output contains both index and pack paths

The short answer: Reported redundant material includes .idx and .pack files. The governing rule is: Treat output as a diagnostic record, not an automatic deletion instruction.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The verified fixture emitted two paths for the redundant pack pair, reflecting the indexed pack’s companion files. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the output contains both index and pack paths example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git pack-redundant --i-still-use-this --all > redundant.txt
cat redundant.txt

Expected result and reasoning. The record contains the redundant index and pack paths in the test fixture. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Counting lines as pack count doubles the number because each pack pair has two files. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Which two paths belong to one logical pack?”

• Evidence to collect: the exact input, environment version, observed result and the rule for output contains both index and pack paths
• Variable to hold constant: the surrounding setup, so the comparison isolates output contains both index and pack paths.
• Variable to change: group entries by pack basename
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For output contains both index and pack paths, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a CI maintenance job. Transfer output contains both index and pack paths into a CI maintenance job. Preserve the governing rule—Treat output as a diagnostic record, not an automatic deletion instruction.—while identifying what changes in this setting. Reported redundant material includes .idx and .pack files. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Treat output as a diagnostic record, not an automatic deletion instruction.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: an alternate object database. Transfer output contains both index and pack paths into an alternate object database. Preserve the governing rule—Treat output as a diagnostic record, not an automatic deletion instruction.—while identifying what changes in this setting. Reported redundant material includes .idx and .pack files. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Treat output as a diagnostic record, not an automatic deletion instruction.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a repository-size investigation. Transfer output contains both index and pack paths into a repository-size investigation. Preserve the governing rule—Treat output as a diagnostic record, not an automatic deletion instruction.—while identifying what changes in this setting. Reported redundant material includes .idx and .pack files. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Treat output as a diagnostic record, not an automatic deletion instruction.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: an administrator runbook. Transfer output contains both index and pack paths into an administrator runbook. Preserve the governing rule—Treat output as a diagnostic record, not an automatic deletion instruction.—while identifying what changes in this setting. Reported redundant material includes .idx and .pack files. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Treat output as a diagnostic record, not an automatic deletion instruction.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for output contains both index and pack paths, predict the result, then group entries by pack basename. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The record contains the redundant index and pack paths in the test fixture. The contrast is explained by this rule: Treat output as a diagnostic record, not an automatic deletion instruction. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for output contains both index and pack paths, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain output contains both index and pack paths, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: Explicit pack-filename mode · Full contents · Next: –verbose writes statistics to stderr →

CHAPTER 11 OF 20 · Back to contents

11. –verbose writes statistics to stderr

The short answer: Verbose mode reports pack-set statistics on standard error. The governing rule is: Capture stdout and stderr separately when output might feed another tool.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The data stream and human explanation have different purposes; mixing them makes automation ambiguous. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the –verbose writes statistics to stderr example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git pack-redundant --i-still-use-this --all --verbose >paths.txt 2>stats.txt

Expected result and reasoning. In the verified fixture, paths.txt held redundant paths while stats.txt described alternate packs, selected set, unique objects and size. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Redirecting only stdout and assuming all evidence was captured loses the statistics. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Which stream contains machine paths and which contains commentary?”

• Evidence to collect: the exact input, environment version, observed result and the rule for –verbose writes statistics to stderr
• Variable to hold constant: the surrounding setup, so the comparison isolates –verbose writes statistics to stderr.
• Variable to change: swap redirections deliberately in a disposable test
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For –verbose writes statistics to stderr, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a backup clone. Transfer –verbose writes statistics to stderr into a backup clone. Preserve the governing rule—Capture stdout and stderr separately when output might feed another tool.—while identifying what changes in this setting. Verbose mode reports pack-set statistics on standard error. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Capture stdout and stderr separately when output might feed another tool.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a recovery rehearsal. Transfer –verbose writes statistics to stderr into a recovery rehearsal. Preserve the governing rule—Capture stdout and stderr separately when output might feed another tool.—while identifying what changes in this setting. Verbose mode reports pack-set statistics on standard error. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Capture stdout and stderr separately when output might feed another tool.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a migration test. Transfer –verbose writes statistics to stderr into a migration test. Preserve the governing rule—Capture stdout and stderr separately when output might feed another tool.—while identifying what changes in this setting. Verbose mode reports pack-set statistics on standard error. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Capture stdout and stderr separately when output might feed another tool.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a disposable repository. Transfer –verbose writes statistics to stderr into a disposable repository. Preserve the governing rule—Capture stdout and stderr separately when output might feed another tool.—while identifying what changes in this setting. Verbose mode reports pack-set statistics on standard error. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Capture stdout and stderr separately when output might feed another tool.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for –verbose writes statistics to stderr, predict the result, then swap redirections deliberately in a disposable test. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. In the verified fixture, paths.txt held redundant paths while stats.txt described alternate packs, selected set, unique objects and size. The contrast is explained by this rule: Capture stdout and stderr separately when output might feed another tool. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for –verbose writes statistics to stderr, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain –verbose writes statistics to stderr, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: Output contains both index and pack paths · Full contents · Next: Standard-input ignored objects →

CHAPTER 12 OF 20 · Back to contents

12. Standard-input ignored objects

The short answer: Object IDs supplied on stdin are ignored when deciding which packs are required. The governing rule is: Ignored objects change the required coverage set; they are not pack filenames.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The feature was intended for analyses involving unreachable objects, so the provenance of every ignored ID matters. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the standard-input ignored objects example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

printf '%s
' "$oid" | git pack-redundant --i-still-use-this --all

Expected result and reasoning. The named object is excluded from the required-object calculation. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Piping arbitrary command output can accidentally ignore valid object IDs. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Why is each ignored object safe to exclude from this diagnostic?”

• Evidence to collect: the exact input, environment version, observed result and the rule for standard-input ignored objects
• Variable to hold constant: the surrounding setup, so the comparison isolates standard-input ignored objects.
• Variable to change: compare output with and without one known object ID
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For standard-input ignored objects, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: an alternate object database. Transfer standard-input ignored objects into an alternate object database. Preserve the governing rule—Ignored objects change the required coverage set; they are not pack filenames.—while identifying what changes in this setting. Object IDs supplied on stdin are ignored when deciding which packs are required. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Ignored objects change the required coverage set; they are not pack filenames.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a repository-size investigation. Transfer standard-input ignored objects into a repository-size investigation. Preserve the governing rule—Ignored objects change the required coverage set; they are not pack filenames.—while identifying what changes in this setting. Object IDs supplied on stdin are ignored when deciding which packs are required. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Ignored objects change the required coverage set; they are not pack filenames.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: an administrator runbook. Transfer standard-input ignored objects into an administrator runbook. Preserve the governing rule—Ignored objects change the required coverage set; they are not pack filenames.—while identifying what changes in this setting. Object IDs supplied on stdin are ignored when deciding which packs are required. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Ignored objects change the required coverage set; they are not pack filenames.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a CI maintenance job. Transfer standard-input ignored objects into a CI maintenance job. Preserve the governing rule—Ignored objects change the required coverage set; they are not pack filenames.—while identifying what changes in this setting. Object IDs supplied on stdin are ignored when deciding which packs are required. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Ignored objects change the required coverage set; they are not pack filenames.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for standard-input ignored objects, predict the result, then compare output with and without one known object ID. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The named object is excluded from the required-object calculation. The contrast is explained by this rule: Ignored objects change the required coverage set; they are not pack filenames. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for standard-input ignored objects, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain standard-input ignored objects, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: –verbose writes statistics to stderr · Full contents · Next: Do not pipe a lesson into rm →

CHAPTER 13 OF 20 · Back to contents

13. Do not pipe a lesson into rm

The short answer: The manual shows historical deletion pipelines, but an educational workflow should stop at reviewed output. The governing rule is: Automatic deletion is outside this guide’s safe scope.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

A stale repository state, parsing mistake or misunderstood ignored-object set can turn a diagnostic stream into irreversible loss. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the do not pipe a lesson into rm example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git pack-redundant --i-still-use-this --all > redundant.txt
# Review only; do not pipe to rm.

Expected result and reasoning. The file becomes evidence for a separate authorised maintenance decision; nothing is deleted. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Appending | xargs rm because the manual says output is suitable removes the safety boundary. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Who reviewed repository state, backups and recovery plan?”

• Evidence to collect: the exact input, environment version, observed result and the rule for do not pipe a lesson into rm
• Variable to hold constant: the surrounding setup, so the comparison isolates do not pipe a lesson into rm.
• Variable to change: verify the paths without deleting them
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For do not pipe a lesson into rm, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a recovery rehearsal. Transfer do not pipe a lesson into rm into a recovery rehearsal. Preserve the governing rule—Automatic deletion is outside this guide’s safe scope.—while identifying what changes in this setting. The manual shows historical deletion pipelines, but an educational workflow should stop at reviewed output. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Automatic deletion is outside this guide’s safe scope.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a migration test. Transfer do not pipe a lesson into rm into a migration test. Preserve the governing rule—Automatic deletion is outside this guide’s safe scope.—while identifying what changes in this setting. The manual shows historical deletion pipelines, but an educational workflow should stop at reviewed output. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Automatic deletion is outside this guide’s safe scope.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a disposable repository. Transfer do not pipe a lesson into rm into a disposable repository. Preserve the governing rule—Automatic deletion is outside this guide’s safe scope.—while identifying what changes in this setting. The manual shows historical deletion pipelines, but an educational workflow should stop at reviewed output. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Automatic deletion is outside this guide’s safe scope.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a backup clone. Transfer do not pipe a lesson into rm into a backup clone. Preserve the governing rule—Automatic deletion is outside this guide’s safe scope.—while identifying what changes in this setting. The manual shows historical deletion pipelines, but an educational workflow should stop at reviewed output. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Automatic deletion is outside this guide’s safe scope.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for do not pipe a lesson into rm, predict the result, then verify the paths without deleting them. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The file becomes evidence for a separate authorised maintenance decision; nothing is deleted. The contrast is explained by this rule: Automatic deletion is outside this guide’s safe scope. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for do not pipe a lesson into rm, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain do not pipe a lesson into rm, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: Standard-input ignored objects · Full contents · Next: –alt-odb and alternates →

CHAPTER 14 OF 20 · Back to contents

14. –alt-odb and alternates

The short answer: –alt-odb lets alternate-object-database packs satisfy required objects. The governing rule is: Use it only when the alternate topology is intentional and stable.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

Without the option, required objects must be represented in local packs; with it, alternate packs can cover them. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the –alt-odb and alternates example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git pack-redundant --i-still-use-this --all --alt-odb

Expected result and reasoning. The result may identify more local packs as unnecessary because alternate storage contributes coverage. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Treating an ephemeral alternate as permanent can leave the repository dependent on disappearing storage. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “What happens if the alternate path is unavailable tomorrow?”

• Evidence to collect: the exact input, environment version, observed result and the rule for –alt-odb and alternates
• Variable to hold constant: the surrounding setup, so the comparison isolates –alt-odb and alternates.
• Variable to change: temporarily remove the alternate only in a disposable fixture
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For –alt-odb and alternates, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a repository-size investigation. Transfer –alt-odb and alternates into a repository-size investigation. Preserve the governing rule—Use it only when the alternate topology is intentional and stable.—while identifying what changes in this setting. –alt-odb lets alternate-object-database packs satisfy required objects. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Use it only when the alternate topology is intentional and stable.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: an administrator runbook. Transfer –alt-odb and alternates into an administrator runbook. Preserve the governing rule—Use it only when the alternate topology is intentional and stable.—while identifying what changes in this setting. –alt-odb lets alternate-object-database packs satisfy required objects. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Use it only when the alternate topology is intentional and stable.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a CI maintenance job. Transfer –alt-odb and alternates into a CI maintenance job. Preserve the governing rule—Use it only when the alternate topology is intentional and stable.—while identifying what changes in this setting. –alt-odb lets alternate-object-database packs satisfy required objects. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Use it only when the alternate topology is intentional and stable.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: an alternate object database. Transfer –alt-odb and alternates into an alternate object database. Preserve the governing rule—Use it only when the alternate topology is intentional and stable.—while identifying what changes in this setting. –alt-odb lets alternate-object-database packs satisfy required objects. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Use it only when the alternate topology is intentional and stable.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for –alt-odb and alternates, predict the result, then temporarily remove the alternate only in a disposable fixture. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The result may identify more local packs as unnecessary because alternate storage contributes coverage. The contrast is explained by this rule: Use it only when the alternate topology is intentional and stable. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for –alt-odb and alternates, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain –alt-odb and alternates, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: Do not pipe a lesson into rm · Full contents · Next: Inspect alternates explicitly →

CHAPTER 15 OF 20 · Back to contents

15. Inspect alternates explicitly

The short answer: An alternates file changes the object database visible to Git. The governing rule is: Record .git/objects/info/alternates and resolve its paths before analysis.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

Relative alternates are interpreted from the object directory, and permission or lifecycle changes affect availability. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the inspect alternates explicitly example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

cat .git/objects/info/alternates
git rev-parse --git-path objects

Expected result and reasoning. The two observations identify the configured references and local object root. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Assuming no alternates because no extra packs appear locally misses the entire dependency. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Which organisation owns and preserves the alternate database?”

• Evidence to collect: the exact input, environment version, observed result and the rule for inspect alternates explicitly
• Variable to hold constant: the surrounding setup, so the comparison isolates inspect alternates explicitly.
• Variable to change: compare the repository with a clone that has no alternates
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For inspect alternates explicitly, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a migration test. Transfer inspect alternates explicitly into a migration test. Preserve the governing rule—Record .git/objects/info/alternates and resolve its paths before analysis.—while identifying what changes in this setting. An alternates file changes the object database visible to Git. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Record .git/objects/info/alternates and resolve its paths before analysis.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a disposable repository. Transfer inspect alternates explicitly into a disposable repository. Preserve the governing rule—Record .git/objects/info/alternates and resolve its paths before analysis.—while identifying what changes in this setting. An alternates file changes the object database visible to Git. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Record .git/objects/info/alternates and resolve its paths before analysis.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a backup clone. Transfer inspect alternates explicitly into a backup clone. Preserve the governing rule—Record .git/objects/info/alternates and resolve its paths before analysis.—while identifying what changes in this setting. An alternates file changes the object database visible to Git. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Record .git/objects/info/alternates and resolve its paths before analysis.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a recovery rehearsal. Transfer inspect alternates explicitly into a recovery rehearsal. Preserve the governing rule—Record .git/objects/info/alternates and resolve its paths before analysis.—while identifying what changes in this setting. An alternates file changes the object database visible to Git. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Record .git/objects/info/alternates and resolve its paths before analysis.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for inspect alternates explicitly, predict the result, then compare the repository with a clone that has no alternates. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The two observations identify the configured references and local object root. The contrast is explained by this rule: Record .git/objects/info/alternates and resolve its paths before analysis. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for inspect alternates explicitly, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain inspect alternates explicitly, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: –alt-odb and alternates · Full contents · Next: Verify packs before interpreting redundancy →

CHAPTER 16 OF 20 · Back to contents

16. Verify packs before interpreting redundancy

The short answer: Use git verify-pack to inspect pack indexes and object listings. The governing rule is: A corrupt or mismatched pack/index pair is not a trustworthy redundancy candidate.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

pack-redundant answers a coverage question; verification checks whether the indexed pack structure is readable. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the verify packs before interpreting redundancy example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git verify-pack -v .git/objects/pack/pack-<hash>.idx

Expected result and reasoning. A valid fixture prints object rows and a successful summary. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. A filename that looks correct does not prove content integrity. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Can Git read the index and corresponding pack completely?”

• Evidence to collect: the exact input, environment version, observed result and the rule for verify packs before interpreting redundancy
• Variable to hold constant: the surrounding setup, so the comparison isolates verify packs before interpreting redundancy.
• Variable to change: run verification on both original and copied index
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For verify packs before interpreting redundancy, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: an administrator runbook. Transfer verify packs before interpreting redundancy into an administrator runbook. Preserve the governing rule—A corrupt or mismatched pack/index pair is not a trustworthy redundancy candidate.—while identifying what changes in this setting. Use git verify-pack to inspect pack indexes and object listings. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A corrupt or mismatched pack/index pair is not a trustworthy redundancy candidate.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a CI maintenance job. Transfer verify packs before interpreting redundancy into a CI maintenance job. Preserve the governing rule—A corrupt or mismatched pack/index pair is not a trustworthy redundancy candidate.—while identifying what changes in this setting. Use git verify-pack to inspect pack indexes and object listings. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A corrupt or mismatched pack/index pair is not a trustworthy redundancy candidate.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: an alternate object database. Transfer verify packs before interpreting redundancy into an alternate object database. Preserve the governing rule—A corrupt or mismatched pack/index pair is not a trustworthy redundancy candidate.—while identifying what changes in this setting. Use git verify-pack to inspect pack indexes and object listings. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A corrupt or mismatched pack/index pair is not a trustworthy redundancy candidate.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a repository-size investigation. Transfer verify packs before interpreting redundancy into a repository-size investigation. Preserve the governing rule—A corrupt or mismatched pack/index pair is not a trustworthy redundancy candidate.—while identifying what changes in this setting. Use git verify-pack to inspect pack indexes and object listings. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A corrupt or mismatched pack/index pair is not a trustworthy redundancy candidate.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for verify packs before interpreting redundancy, predict the result, then run verification on both original and copied index. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. A valid fixture prints object rows and a successful summary. The contrast is explained by this rule: A corrupt or mismatched pack/index pair is not a trustworthy redundancy candidate. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for verify packs before interpreting redundancy, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain verify packs before interpreting redundancy, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: Inspect alternates explicitly · Full contents · Next: Run fsck as a separate integrity check →

CHAPTER 17 OF 20 · Back to contents

17. Run fsck as a separate integrity check

The short answer: git fsck examines object validity and connectivity beyond the redundancy calculation. The governing rule is: Redundancy output is not a repository health certificate.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

A repository can have no redundant pack and still have missing or corrupt objects. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the run fsck as a separate integrity check example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git fsck --full

Expected result and reasoning. A sound disposable fixture should avoid missing or corrupt-object reports; reachability messages must be classified separately. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Treating an empty pack-redundant result as proof of health confuses two contracts. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Is the finding about pack coverage, object validity or reachability?”

• Evidence to collect: the exact input, environment version, observed result and the rule for run fsck as a separate integrity check
• Variable to hold constant: the surrounding setup, so the comparison isolates run fsck as a separate integrity check.
• Variable to change: compare fsck before and after deliberately breaking only a disposable copy
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For run fsck as a separate integrity check, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a disposable repository. Transfer run fsck as a separate integrity check into a disposable repository. Preserve the governing rule—Redundancy output is not a repository health certificate.—while identifying what changes in this setting. git fsck examines object validity and connectivity beyond the redundancy calculation. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Redundancy output is not a repository health certificate.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a backup clone. Transfer run fsck as a separate integrity check into a backup clone. Preserve the governing rule—Redundancy output is not a repository health certificate.—while identifying what changes in this setting. git fsck examines object validity and connectivity beyond the redundancy calculation. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Redundancy output is not a repository health certificate.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a recovery rehearsal. Transfer run fsck as a separate integrity check into a recovery rehearsal. Preserve the governing rule—Redundancy output is not a repository health certificate.—while identifying what changes in this setting. git fsck examines object validity and connectivity beyond the redundancy calculation. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Redundancy output is not a repository health certificate.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a migration test. Transfer run fsck as a separate integrity check into a migration test. Preserve the governing rule—Redundancy output is not a repository health certificate.—while identifying what changes in this setting. git fsck examines object validity and connectivity beyond the redundancy calculation. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Redundancy output is not a repository health certificate.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for run fsck as a separate integrity check, predict the result, then compare fsck before and after deliberately breaking only a disposable copy. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. A sound disposable fixture should avoid missing or corrupt-object reports; reachability messages must be classified separately. The contrast is explained by this rule: Redundancy output is not a repository health certificate. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for run fsck as a separate integrity check, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain run fsck as a separate integrity check, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: Verify packs before interpreting redundancy · Full contents · Next: Concurrent maintenance changes the answer →

CHAPTER 18 OF 20 · Back to contents

18. Concurrent maintenance changes the answer

The short answer: Fetches, repacks and gc can replace pack files during analysis. The governing rule is: Use a controlled maintenance window for any real administrative decision.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The computed pack set is a snapshot of repository state, not a durable promise about later filenames. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the concurrent maintenance changes the answer example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git count-objects -v
git pack-redundant --i-still-use-this --all
git count-objects -v

Expected result and reasoning. Matching before-and-after inventories make the observation easier to trust. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Saving path output and acting days later risks targeting files that no longer represent the same state. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Did any process mutate the object database between inventory and review?”

• Evidence to collect: the exact input, environment version, observed result and the rule for concurrent maintenance changes the answer
• Variable to hold constant: the surrounding setup, so the comparison isolates concurrent maintenance changes the answer.
• Variable to change: run git repack only in a copied fixture and compare filenames
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For concurrent maintenance changes the answer, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a CI maintenance job. Transfer concurrent maintenance changes the answer into a CI maintenance job. Preserve the governing rule—Use a controlled maintenance window for any real administrative decision.—while identifying what changes in this setting. Fetches, repacks and gc can replace pack files during analysis. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Use a controlled maintenance window for any real administrative decision.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: an alternate object database. Transfer concurrent maintenance changes the answer into an alternate object database. Preserve the governing rule—Use a controlled maintenance window for any real administrative decision.—while identifying what changes in this setting. Fetches, repacks and gc can replace pack files during analysis. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Use a controlled maintenance window for any real administrative decision.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a repository-size investigation. Transfer concurrent maintenance changes the answer into a repository-size investigation. Preserve the governing rule—Use a controlled maintenance window for any real administrative decision.—while identifying what changes in this setting. Fetches, repacks and gc can replace pack files during analysis. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Use a controlled maintenance window for any real administrative decision.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: an administrator runbook. Transfer concurrent maintenance changes the answer into an administrator runbook. Preserve the governing rule—Use a controlled maintenance window for any real administrative decision.—while identifying what changes in this setting. Fetches, repacks and gc can replace pack files during analysis. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Use a controlled maintenance window for any real administrative decision.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for concurrent maintenance changes the answer, predict the result, then run git repack only in a copied fixture and compare filenames. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. Matching before-and-after inventories make the observation easier to trust. The contrast is explained by this rule: Use a controlled maintenance window for any real administrative decision. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for concurrent maintenance changes the answer, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain concurrent maintenance changes the answer, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: Run fsck as a separate integrity check · Full contents · Next: Plan for command removal →

CHAPTER 19 OF 20 · Back to contents

19. Plan for command removal

The short answer: A future Git release may remove pack-redundant. The governing rule is: Do not build a new long-lived workflow around a scheduled-for-removal command.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

Version gates and explicit failure messages prevent automation from silently switching behaviour. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the plan for command removal example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

if ! git help -a | grep -q 'pack-redundant'; then
  echo 'Use the supported maintenance workflow' >&2
  exit 1
fi

Expected result and reasoning. The wrapper fails clearly when the command is unavailable instead of improvising deletion logic. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Vendoring an old Git solely to retain deprecated cleanup behaviour adds security and maintenance risk. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “What supported workflow survives the upgrade?”

• Evidence to collect: the exact input, environment version, observed result and the rule for plan for command removal
• Variable to hold constant: the surrounding setup, so the comparison isolates plan for command removal.
• Variable to change: test the failure branch with a simulated unavailable command
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For plan for command removal, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: a backup clone. Transfer plan for command removal into a backup clone. Preserve the governing rule—Do not build a new long-lived workflow around a scheduled-for-removal command.—while identifying what changes in this setting. A future Git release may remove pack-redundant. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Do not build a new long-lived workflow around a scheduled-for-removal command.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a recovery rehearsal. Transfer plan for command removal into a recovery rehearsal. Preserve the governing rule—Do not build a new long-lived workflow around a scheduled-for-removal command.—while identifying what changes in this setting. A future Git release may remove pack-redundant. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Do not build a new long-lived workflow around a scheduled-for-removal command.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a migration test. Transfer plan for command removal into a migration test. Preserve the governing rule—Do not build a new long-lived workflow around a scheduled-for-removal command.—while identifying what changes in this setting. A future Git release may remove pack-redundant. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Do not build a new long-lived workflow around a scheduled-for-removal command.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a disposable repository. Transfer plan for command removal into a disposable repository. Preserve the governing rule—Do not build a new long-lived workflow around a scheduled-for-removal command.—while identifying what changes in this setting. A future Git release may remove pack-redundant. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Do not build a new long-lived workflow around a scheduled-for-removal command.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for plan for command removal, predict the result, then test the failure branch with a simulated unavailable command. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The wrapper fails clearly when the command is unavailable instead of improvising deletion logic. The contrast is explained by this rule: Do not build a new long-lived workflow around a scheduled-for-removal command. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for plan for command removal, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain plan for command removal, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: Concurrent maintenance changes the answer · Full contents · Next: Choosing the supported route →

CHAPTER 20 OF 20 · Back to contents

20. Choosing the supported route

The short answer: Use pack-redundant only for a narrowly justified diagnostic on a controlled repository. The governing rule is: Choose git gc for normal size maintenance and preserve review boundaries for object-store work.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

Tool choice should reflect whole-pack limits, alternates, reachability, integrity and deprecation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

Read the choosing the supported route example once without executing it. Mark the exact input, the operation under study, and the expected observable result. Then write a one-sentence prediction. Only after that should the learner run the example. This order separates understanding from trial-and-error and makes any surprise diagnostically useful.

git gc
git count-objects -v

Expected result and reasoning. Normal maintenance uses supported commands and then observes the resulting storage. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. More plumbing flags do not make a deprecated tool a better default. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

Use a four-pass diagnosis. Pass one: classify. Identify the kind of value or state being examined. Pass two: trace. Follow the operation in the order defined by the platform or specification. Pass three: observe. Capture a minimal output, not a screenshot of a large project. Pass four: contrast. Change one feature and run again. For this chapter, the highest-value question is: “Can the objective be achieved by gc, repack, verify-pack, fsck or observation alone?”

• Evidence to collect: the exact input, environment version, observed result and the rule for choosing the supported route
• Variable to hold constant: the surrounding setup, so the comparison isolates choosing the supported route.
• Variable to change: write the reason for rejecting pack-redundant in a routine case
• Explanation standard: name the rule, not merely the successful command or copied syntax.

For choosing the supported route, a common unproductive move is to make several changes at once. That can make the symptom disappear while leaving the misconception intact. Reset to the smallest example, keep a brief prediction log, and preserve both the successful and unsuccessful case. The pair becomes a reusable test fixture and a much clearer revision note than a paragraph of definitions.

Four transfer cases

Transfer case 1: an alternate object database. Transfer choosing the supported route into an alternate object database. Preserve the governing rule—Choose git gc for normal size maintenance and preserve review boundaries for object-store work.—while identifying what changes in this setting. Use pack-redundant only for a narrowly justified diagnostic on a controlled repository. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Choose git gc for normal size maintenance and preserve review boundaries for object-store work.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a repository-size investigation. Transfer choosing the supported route into a repository-size investigation. Preserve the governing rule—Choose git gc for normal size maintenance and preserve review boundaries for object-store work.—while identifying what changes in this setting. Use pack-redundant only for a narrowly justified diagnostic on a controlled repository. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Choose git gc for normal size maintenance and preserve review boundaries for object-store work.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: an administrator runbook. Transfer choosing the supported route into an administrator runbook. Preserve the governing rule—Choose git gc for normal size maintenance and preserve review boundaries for object-store work.—while identifying what changes in this setting. Use pack-redundant only for a narrowly justified diagnostic on a controlled repository. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Choose git gc for normal size maintenance and preserve review boundaries for object-store work.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a CI maintenance job. Transfer choosing the supported route into a CI maintenance job. Preserve the governing rule—Choose git gc for normal size maintenance and preserve review boundaries for object-store work.—while identifying what changes in this setting. Use pack-redundant only for a narrowly justified diagnostic on a controlled repository. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Choose git gc for normal size maintenance and preserve review boundaries for object-store work.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for choosing the supported route, predict the result, then write the reason for rejecting pack-redundant in a routine case. Explain both outcomes without relying on trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. Normal maintenance uses supported commands and then observes the resulting storage. The contrast is explained by this rule: Choose git gc for normal size maintenance and preserve review boundaries for object-store work. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

Ask the learner to name the evidence that matters for choosing the supported route, then request one controlled variation. A correct value without a causal explanation is not yet mastery. A useful conversation is brief: ask for the rule, ask for a prediction, then ask which observation would disprove it. Avoid turning the exchange into a vocabulary quiz. The goal is to hear a causal explanation and see a controlled test. Praise a corrected prediction when the learner uses evidence well; that is stronger progress than protecting an unexamined first answer.

Ready to move on? Move forward when the learner can explain choosing the supported route, solve the worked case without prompts, and handle at least two transfer cases with a changed context. Revisit this chapter when the explanation relies on “usually”, “looks like”, or “the computer says so” without identifying the governing rule.

← Previous: Plan for command removal · Full contents · Parent guide →

Parent guide: what mastery looks like

A learner has not mastered Git pack-redundant merely because one polished example runs. Look for four behaviours: they can state the rule in plain language; predict before executing; isolate one changed condition; and explain why a transfer case is the same problem or a different one. Those behaviours make progress visible without requiring a parent to become a specialist.

Use a ten-minute check-in. Ask the learner to choose one chapter, reconstruct its example from memory, and narrate the causal chain. Then change one input. If the learner can update the prediction and justify the change, stop. More repetitions are not automatically better. Save the two-case pair and return to it after a few days.

If every answer is hesitant, reduce the scope. Return to the earliest chapter whose rule cannot be stated accurately. If explanations are fluent but real tasks still fail, move to a capstone because the missing skill is likely transfer or diagnosis. If frustration rises, separate typing errors from conceptual errors and solve only one category in that session.

Capstone practice with explained routes

Capstone 1: Rebuild the smallest trustworthy fixture

Scenario. Create a disposable Git fixture that demonstrates deprecated whole-pack redundancy analysis without unrelated project code.

Route. Record environment, input, prediction and output. Keep one nearby contrast. Begin with a written prediction, collect the smallest sufficient evidence, and explain which observation would make you revise the conclusion.

Explained resolution. The fixture succeeds when another learner can reproduce the observation and explain the rule separating the two cases. A strong submission includes the result, the causal chain and a controlled contrasting case. It does not hide uncertainty: if platform, version or environment matters, state that boundary.

Capstone 2: Diagnose a believable wrong explanation

Scenario. A learner has the correct output but explains it with the wrong mechanism.

Route. Change the one condition the wrong explanation says matters while holding the real governing condition constant. Begin with a written prediction, collect the smallest sufficient evidence, and explain which observation would make you revise the conclusion.

Explained resolution. The controlled contrast exposes the misconception without turning the task into guesswork. A strong submission includes the result, the causal chain and a controlled contrasting case. It does not hide uncertainty: if platform, version or environment matters, state that boundary.

Capstone 3: Handle a version boundary

Scenario. Two environments produce different observations.

Route. Capture versions, platform or browser, exact input and relevant state before comparing. Begin with a written prediction, collect the smallest sufficient evidence, and explain which observation would make you revise the conclusion.

Explained resolution. A difference is not automatically an error; bind the claim to the documented environment and retest. A strong submission includes the result, the causal chain and a controlled contrasting case. It does not hide uncertainty: if platform, version or environment matters, state that boundary.

Capstone 4: Design a parent check-in

Scenario. A parent has ten minutes and no specialist background.

Route. Ask for one rule, one prediction, one run and one changed condition. Begin with a written prediction, collect the smallest sufficient evidence, and explain which observation would make you revise the conclusion.

Explained resolution. The learner demonstrates mastery through a causal explanation and evidence-based revision. A strong submission includes the result, the causal chain and a controlled contrasting case. It does not hide uncertainty: if platform, version or environment matters, state that boundary.

Capstone 5: Transfer into a larger project

Scenario. The isolated fixture works but a school or home project does not.

Route. Preserve the fixture, then compare project inputs and dependencies one at a time. Begin with a written prediction, collect the smallest sufficient evidence, and explain which observation would make you revise the conclusion.

Explained resolution. The first dependency that changes the result becomes the next diagnostic focus; the verified rule remains the baseline. A strong submission includes the result, the causal chain and a controlled contrasting case. It does not hide uncertainty: if platform, version or environment matters, state that boundary.

Capstone 6: Write a regression check

Scenario. The behaviour must remain understood after an update.

Route. Save the smallest positive case, the near miss and version metadata. Begin with a written prediction, collect the smallest sufficient evidence, and explain which observation would make you revise the conclusion.

Explained resolution. A useful check reports a meaningful changed observation and points back to the governing rule. A strong submission includes the result, the causal chain and a controlled contrasting case. It does not hide uncertainty: if platform, version or environment matters, state that boundary.

Capstone 7: Explain a limitation honestly

Scenario. The selected feature does not cover an important job or is not universally available.

Route. Name the limitation, show what evidence the feature provides and identify the safer route. Begin with a written prediction, collect the smallest sufficient evidence, and explain which observation would make you revise the conclusion.

Explained resolution. Good advice is bounded; it neither discards a useful tool nor stretches it into a guarantee. A strong submission includes the result, the causal chain and a controlled contrasting case. It does not hide uncertainty: if platform, version or environment matters, state that boundary.

Capstone 8: Choose the right tool

Scenario. Several related methods or commands appear to solve the same task.

Route. Define desired output, evaluation timing, compatibility and acceptable failure modes. Begin with a written prediction, collect the smallest sufficient evidence, and explain which observation would make you revise the conclusion.

Explained resolution. Select the contract that matches the job and state why at least one tempting alternative was rejected. A strong submission includes the result, the causal chain and a controlled contrasting case. It does not hide uncertainty: if platform, version or environment matters, state that boundary.

Frequently asked questions

Is Git pack-redundant mainly a syntax topic?

No. Syntax is only the handle. Mastery means stating the contract, predicting boundary cases, collecting the right evidence, and choosing a safer or more suitable tool when the contract does not fit.

How long should one practice session be?

Ten to twenty focused minutes is enough for one rule, one worked example, one near miss and one explanation. Stop when the learner can explain the contrast; preserve the fixture for later retrieval.

Should every edge case be memorised?

No. Memorise the central rule and organise edge cases by cause: version, platform, input type, browser support, database schema or repository state. Keep the primary source beside the fixture.

What can a non-specialist parent ask?

Ask for a prediction, the rule behind it, the observation that could disprove it and one changed case. Those questions reveal understanding without requiring the parent to know the command or final value.

When is copying an example useful?

Copying establishes a trusted baseline. It becomes learning after the student predicts the result, reconstructs the example, changes one condition and explains the changed outcome.

How do we separate setup errors from concept errors?

Run a known-good minimal fixture first. If it fails, inspect version, support and transcription. If it passes but the learner predicts a controlled variation incorrectly, the misconception is conceptual.

Should practice start inside a large project?

Not initially. Begin in a disposable directory, tiny script, isolated HTML file or in-memory database. Transfer the verified rule only after the smallest case is understood.

What belongs in revision notes?

Keep the rule in one sentence, the smallest successful example, a near miss, observed output, environment version and one diagnostic question. This is more reusable than copied pages of prose.

What if two computers disagree?

Treat the difference as evidence. Record versions, operating system or browser, exact input and relevant state. Then consult the versioned primary source before deciding that either observation is wrong.

When should the learner move on?

Move on when the learner can explain the rule, predict two contrasts, diagnose a deliberately broken case and transfer the idea to a fresh context without step-by-step prompting.

References and verification notes

Primary technical source: Official git-pack-redundant manual. The manual states the deprecation and removal plan, required acknowledgement flag, whole-pack limitation, git gc recommendation, stdin semantics and options –all, –alt-odb and –verbose.

The worked examples were checked with Git 2.51.1 in a disposable repository containing a deliberately duplicated indexed pack; the read-only fixture reproduced one redundant .idx/.pack pair and separate verbose stderr statistics. The checks confirm the specific examples in this guide; they do not promise identical behaviour on an older version, a different operating system, a different browser implementation, or a repository with different state. Keep the version and environment with the saved fixture.

Last reviewed: 17 October 2026. This article is educational guidance for families and learners. It does not advertise a physical Punggol outlet or make admissions, affiliation, score or outcome guarantees.