Sometimes a script does not merely need to print a Git blob; it needs an actual temporary file that another file-based tool can open. `git unpack-file` performs that narrow bridge, but the generated name, object type and cleanup responsibility must all be handled deliberately.

The command accepts a blob object ID, creates a temporary file containing the blob’s bytes and prints a name in the form `.merge_file_XXXXX`. Mastery means distinguishing the immutable object from the new working-directory file, capturing stdout safely, checking failures and removing only the exact temporary path your process created.

This guide teaches the command in disposable repositories, compares it with neighbouring Git tools, handles binary data and unusual filenames, and shows parents how to ask evidence-focused questions without turning a narrow plumbing command into a risky copying recipe.

Punggol families can use this guide in short sessions around homework, CCAs and rest. The examples are proposed learning activities. They do not claim a physical tuition branch, timetable, fee, class size, school relationship or guaranteed result.

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

git unpack-file accepts a blob object ID and rejects non-blob objects for this job. That is the invariant to preserve when names, data or surrounding project details change.

Git repositories contain commits, trees, tags and blobs; only blobs hold the file-content bytes this command materialises. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is passing a commit ID because it appears at the top of git log. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

oid=$(git rev-parse HEAD:notes.txt)
git cat-file -t "$oid"
git unpack-file "$oid"

Read the trace, not just the last line

Trace revision/path resolution, object type and command input separately. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “The input must identify a blob object”, separate contract from coincidence. The contract is “git unpack-file accepts a blob object ID and rejects non-blob objects for this job.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Verify the object type with git cat-file -t before unpacking.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “The input must identify a blob object” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file accepts a blob object ID and rejects non-blob objects for this job.” should remain invariant and what observation would expose passing a commit ID because it appears at the top of git log.

Case 2: CCA media catalogue. Contrast “The input must identify a blob object” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file accepts a blob object ID and rejects non-blob objects for this job.” should remain invariant and what observation would expose passing a commit ID because it appears at the top of git log.

Case 3: science investigation archive. Stress-test “The input must identify a blob object” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file accepts a blob object ID and rejects non-blob objects for this job.” should remain invariant and what observation would expose passing a commit ID because it appears at the top of git log.

Case 4: revision-note builder. Explain “The input must identify a blob object” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file accepts a blob object ID and rejects non-blob objects for this job.” should remain invariant and what observation would expose passing a commit ID because it appears at the top of git log.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals passing a commit ID because it appears at the top of git log.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Verify the object type with git cat-file -t before unpacking.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “The input must identify a blob object”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests git unpack-file accepts a blob object ID and rejects non-blob objects for this job.?”, and “Can you make a smaller example of passing a commit ID because it appears at the top of git log?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Resolve notes.txt from HEAD and prove the resolved object is a blob. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Use an explicit type check in educational and safety-sensitive scripts. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “The input must identify a blob object” means the learner can predict the ordinary case, recognise passing a commit ID because it appears at the top of git log, diagnose the earliest mistaken assumption, recover with “Verify the object type with git cat-file -t before unpacking.” and defend this decision: Use an explicit type check in educational and safety-sensitive scripts. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

On success, git unpack-file prints the generated temporary filename, typically in the form .merge_file_XXXXX. That is the invariant to preserve when names, data or surrounding project details change.

The filename is data produced by the command, not a name to guess in advance. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is hard-coding .merge_file_12345 or globbing every .merge_file_*. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

tmp=$(git unpack-file "$oid")
printf "%s\n" "$tmp"

Read the trace, not just the last line

Trace stdout separately from the file’s content. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “The output is a generated temporary filename”, separate contract from coincidence. The contract is “On success, git unpack-file prints the generated temporary filename, typically in the form .merge_file_XXXXX.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Capture one successful stdout line into a variable and validate it before use.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “The output is a generated temporary filename” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “On success, git unpack-file prints the generated temporary filename, typically in the form .merge_file_XXXXX.” should remain invariant and what observation would expose hard-coding .merge_file_12345 or globbing every .merge_file_*.

Case 2: CCA media catalogue. Contrast “The output is a generated temporary filename” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “On success, git unpack-file prints the generated temporary filename, typically in the form .merge_file_XXXXX.” should remain invariant and what observation would expose hard-coding .merge_file_12345 or globbing every .merge_file_*.

Case 3: science investigation archive. Stress-test “The output is a generated temporary filename” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “On success, git unpack-file prints the generated temporary filename, typically in the form .merge_file_XXXXX.” should remain invariant and what observation would expose hard-coding .merge_file_12345 or globbing every .merge_file_*.

Case 4: revision-note builder. Explain “The output is a generated temporary filename” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “On success, git unpack-file prints the generated temporary filename, typically in the form .merge_file_XXXXX.” should remain invariant and what observation would expose hard-coding .merge_file_12345 or globbing every .merge_file_*.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals hard-coding .merge_file_12345 or globbing every .merge_file_*.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Capture one successful stdout line into a variable and validate it before use.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “The output is a generated temporary filename”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests On success, git unpack-file prints the generated temporary filename, typically in the form .merge_file_XXXXX.?”, and “Can you make a smaller example of hard-coding .merge_file_12345 or globbing every .merge_file_*?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain why the shell variable should hold the printed name rather than a wildcard. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Treat generated paths as untrusted strings: quote them and validate scope. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “The output is a generated temporary filename” means the learner can predict the ordinary case, recognise hard-coding .merge_file_12345 or globbing every .merge_file_*, diagnose the earliest mistaken assumption, recover with “Capture one successful stdout line into a variable and validate it before use.” and defend this decision: Treat generated paths as untrusted strings: quote them and validate scope. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

The temporary file’s contents are the bytes stored in the selected blob. That is the invariant to preserve when names, data or surrounding project details change.

This enables file-oriented tools without altering the blob object itself. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is comparing only what a text terminal displays and claiming byte-for-byte equality. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

tmp=$(git unpack-file "$oid")
cmp -- note.txt "$tmp"

Read the trace, not just the last line

Trace object ID, created path and byte comparison status. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “The created file contains the blob bytes”, separate contract from coincidence. The contract is “The temporary file’s contents are the bytes stored in the selected blob.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Use cmp or a cryptographic digest on a known fixture, including a newline boundary.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “The created file contains the blob bytes” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “The temporary file’s contents are the bytes stored in the selected blob.” should remain invariant and what observation would expose comparing only what a text terminal displays and claiming byte-for-byte equality.

Case 2: CCA media catalogue. Contrast “The created file contains the blob bytes” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “The temporary file’s contents are the bytes stored in the selected blob.” should remain invariant and what observation would expose comparing only what a text terminal displays and claiming byte-for-byte equality.

Case 3: science investigation archive. Stress-test “The created file contains the blob bytes” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “The temporary file’s contents are the bytes stored in the selected blob.” should remain invariant and what observation would expose comparing only what a text terminal displays and claiming byte-for-byte equality.

Case 4: revision-note builder. Explain “The created file contains the blob bytes” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “The temporary file’s contents are the bytes stored in the selected blob.” should remain invariant and what observation would expose comparing only what a text terminal displays and claiming byte-for-byte equality.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals comparing only what a text terminal displays and claiming byte-for-byte equality.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use cmp or a cryptographic digest on a known fixture, including a newline boundary.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “The created file contains the blob bytes”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests The temporary file’s contents are the bytes stored in the selected blob.?”, and “Can you make a smaller example of comparing only what a text terminal displays and claiming byte-for-byte equality?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Create a two-line fixture and verify exact equality after unpacking. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Use byte checks for scripts; use visual inspection only as a teaching supplement. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “The created file contains the blob bytes” means the learner can predict the ordinary case, recognise comparing only what a text terminal displays and claiming byte-for-byte equality, diagnose the earliest mistaken assumption, recover with “Use cmp or a cryptographic digest on a known fixture, including a newline boundary.” and defend this decision: Use byte checks for scripts; use visual inspection only as a teaching supplement. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

git unpack-file creates an ordinary temporary file but does not modify the underlying Git object. That is the invariant to preserve when names, data or surrounding project details change.

Editing the temporary copy changes working-directory state, not the content-addressed object. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is editing the copy and expecting the original blob ID to update. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

tmp=$(git unpack-file "$oid")
printf "extra\n" >> "$tmp"
git hash-object "$tmp"

Read the trace, not just the last line

Trace original OID, copy bytes, edit and new computed OID. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “The blob remains immutable”, separate contract from coincidence. The contract is “git unpack-file creates an ordinary temporary file but does not modify the underlying Git object.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Hash the copy before and after an edit and compare with the original object ID.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “The blob remains immutable” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file creates an ordinary temporary file but does not modify the underlying Git object.” should remain invariant and what observation would expose editing the copy and expecting the original blob ID to update.

Case 2: CCA media catalogue. Contrast “The blob remains immutable” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file creates an ordinary temporary file but does not modify the underlying Git object.” should remain invariant and what observation would expose editing the copy and expecting the original blob ID to update.

Case 3: science investigation archive. Stress-test “The blob remains immutable” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file creates an ordinary temporary file but does not modify the underlying Git object.” should remain invariant and what observation would expose editing the copy and expecting the original blob ID to update.

Case 4: revision-note builder. Explain “The blob remains immutable” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file creates an ordinary temporary file but does not modify the underlying Git object.” should remain invariant and what observation would expose editing the copy and expecting the original blob ID to update.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals editing the copy and expecting the original blob ID to update.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Hash the copy before and after an edit and compare with the original object ID.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “The blob remains immutable”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests git unpack-file creates an ordinary temporary file but does not modify the underlying Git object.?”, and “Can you make a smaller example of editing the copy and expecting the original blob ID to update?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain why the repository still contains the original object after the edit. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Use normal Git workflows to create new objects or commits; do not confuse a copy with object mutation. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “The blob remains immutable” means the learner can predict the ordinary case, recognise editing the copy and expecting the original blob ID to update, diagnose the earliest mistaken assumption, recover with “Hash the copy before and after an edit and compare with the original object ID.” and defend this decision: Use normal Git workflows to create new objects or commits; do not confuse a copy with object mutation. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

The printed temporary name should be captured and every later expansion should be double-quoted. That is the invariant to preserve when names, data or surrounding project details change.

Quoting is the general safe shell rule even when today’s generated form has no spaces. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is using cat $tmp and teaching learners that filenames never need quotes. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

tmp=$(git unpack-file "$oid")
cat -- "$tmp"

Read the trace, not just the last line

Trace shell parsing before the called program receives arguments. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Command substitution must be quoted”, separate contract from coincidence. The contract is “The printed temporary name should be captured and every later expansion should be double-quoted.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Write `tmp=$(…)` and `cat — “$tmp”`, including `–` where the consumer supports it.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Command substitution must be quoted” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “The printed temporary name should be captured and every later expansion should be double-quoted.” should remain invariant and what observation would expose using cat $tmp and teaching learners that filenames never need quotes.

Case 2: CCA media catalogue. Contrast “Command substitution must be quoted” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “The printed temporary name should be captured and every later expansion should be double-quoted.” should remain invariant and what observation would expose using cat $tmp and teaching learners that filenames never need quotes.

Case 3: science investigation archive. Stress-test “Command substitution must be quoted” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “The printed temporary name should be captured and every later expansion should be double-quoted.” should remain invariant and what observation would expose using cat $tmp and teaching learners that filenames never need quotes.

Case 4: revision-note builder. Explain “Command substitution must be quoted” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “The printed temporary name should be captured and every later expansion should be double-quoted.” should remain invariant and what observation would expose using cat $tmp and teaching learners that filenames never need quotes.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals using cat $tmp and teaching learners that filenames never need quotes.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Write `tmp=$(…)` and `cat — “$tmp”`, including `–` where the consumer supports it.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Command substitution must be quoted”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests The printed temporary name should be captured and every later expansion should be double-quoted.?”, and “Can you make a smaller example of using cat $tmp and teaching learners that filenames never need quotes?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Repair an example that uses `rm $tmp`. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Make quoting habitual before learners meet user-controlled filenames. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Command substitution must be quoted” means the learner can predict the ordinary case, recognise using cat $tmp and teaching learners that filenames never need quotes, diagnose the earliest mistaken assumption, recover with “Write `tmp=$(…)` and `cat — “$tmp”`, including `–` where the consumer supports it.” and defend this decision: Make quoting habitual before learners meet user-controlled filenames. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A script should use the generated name only if git unpack-file succeeds. That is the invariant to preserve when names, data or surrounding project details change.

Command substitution can otherwise leave an empty or stale variable and the next command may target the wrong thing. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is running a consumer even after unpack-file prints a fatal error. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

if tmp=$(git unpack-file "$oid"); then
  tool -- "$tmp"
else
  echo "could not materialise blob" >&2
fi

Read the trace, not just the last line

Trace exit status, assignment and branch selection. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Exit status must gate later steps”, separate contract from coincidence. The contract is “A script should use the generated name only if git unpack-file succeeds.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Put the assignment in an if statement or use strict error handling with explicit diagnostics.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Exit status must gate later steps” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “A script should use the generated name only if git unpack-file succeeds.” should remain invariant and what observation would expose running a consumer even after unpack-file prints a fatal error.

Case 2: CCA media catalogue. Contrast “Exit status must gate later steps” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “A script should use the generated name only if git unpack-file succeeds.” should remain invariant and what observation would expose running a consumer even after unpack-file prints a fatal error.

Case 3: science investigation archive. Stress-test “Exit status must gate later steps” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “A script should use the generated name only if git unpack-file succeeds.” should remain invariant and what observation would expose running a consumer even after unpack-file prints a fatal error.

Case 4: revision-note builder. Explain “Exit status must gate later steps” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “A script should use the generated name only if git unpack-file succeeds.” should remain invariant and what observation would expose running a consumer even after unpack-file prints a fatal error.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals running a consumer even after unpack-file prints a fatal error.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Put the assignment in an if statement or use strict error handling with explicit diagnostics.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Exit status must gate later steps”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A script should use the generated name only if git unpack-file succeeds.?”, and “Can you make a smaller example of running a consumer even after unpack-file prints a fatal error?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Design a failure test using a commit ID. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Gate every dependent operation on success rather than inferring success from a variable. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Exit status must gate later steps” means the learner can predict the ordinary case, recognise running a consumer even after unpack-file prints a fatal error, diagnose the earliest mistaken assumption, recover with “Put the assignment in an if statement or use strict error handling with explicit diagnostics.” and defend this decision: Gate every dependent operation on success rather than inferring success from a variable. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

git unpack-file resolves the object through the current repository context. That is the invariant to preserve when names, data or surrounding project details change.

Running outside a repository or in the wrong repository changes which object database is available. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is copying an OID between unrelated repositories and expecting universal lookup. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

root=$(git rev-parse --show-toplevel)
cd "$root"
tmp=$(git unpack-file "$oid")

Read the trace, not just the last line

Trace repository root, object database and working directory. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Repository context determines object lookup”, separate contract from coincidence. The contract is “git unpack-file resolves the object through the current repository context.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Record git rev-parse –show-toplevel and test object existence in the intended repository.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Repository context determines object lookup” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file resolves the object through the current repository context.” should remain invariant and what observation would expose copying an OID between unrelated repositories and expecting universal lookup.

Case 2: CCA media catalogue. Contrast “Repository context determines object lookup” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file resolves the object through the current repository context.” should remain invariant and what observation would expose copying an OID between unrelated repositories and expecting universal lookup.

Case 3: science investigation archive. Stress-test “Repository context determines object lookup” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file resolves the object through the current repository context.” should remain invariant and what observation would expose copying an OID between unrelated repositories and expecting universal lookup.

Case 4: revision-note builder. Explain “Repository context determines object lookup” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file resolves the object through the current repository context.” should remain invariant and what observation would expose copying an OID between unrelated repositories and expecting universal lookup.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals copying an OID between unrelated repositories and expecting universal lookup.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Record git rev-parse –show-toplevel and test object existence in the intended repository.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Repository context determines object lookup”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests git unpack-file resolves the object through the current repository context.?”, and “Can you make a smaller example of copying an OID between unrelated repositories and expecting universal lookup?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain why the same hexadecimal ID string can be unavailable in another repository. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Pass repository context explicitly in automation with `git -C` when appropriate. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Repository context determines object lookup” means the learner can predict the ordinary case, recognise copying an OID between unrelated repositories and expecting universal lookup, diagnose the earliest mistaken assumption, recover with “Record git rev-parse –show-toplevel and test object existence in the intended repository.” and defend this decision: Pass repository context explicitly in automation with `git -C` when appropriate. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A `REV:path` expression can be resolved to a blob ID with git rev-parse or verified with git cat-file before calling unpack-file. That is the invariant to preserve when names, data or surrounding project details change.

This separates revision selection from temporary-file creation. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is passing the literal string HEAD:notes.txt to a script that promises only raw blob IDs without documenting resolution. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

spec=HEAD:notes.txt
oid=$(git rev-parse "$spec")
test "$(git cat-file -t "$oid")" = blob
tmp=$(git unpack-file "$oid")

Read the trace, not just the last line

Trace human-readable spec and resolved object identity separately. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Resolve revision paths before materialising”, separate contract from coincidence. The contract is “A `REV:path` expression can be resolved to a blob ID with git rev-parse or verified with git cat-file before calling unpack-file.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Resolve, type-check and then materialise in three labelled steps.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Resolve revision paths before materialising” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “A `REV:path` expression can be resolved to a blob ID with git rev-parse or verified with git cat-file before calling unpack-file.” should remain invariant and what observation would expose passing the literal string HEAD:notes.txt to a script that promises only raw blob IDs without documenting resolution.

Case 2: CCA media catalogue. Contrast “Resolve revision paths before materialising” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “A `REV:path` expression can be resolved to a blob ID with git rev-parse or verified with git cat-file before calling unpack-file.” should remain invariant and what observation would expose passing the literal string HEAD:notes.txt to a script that promises only raw blob IDs without documenting resolution.

Case 3: science investigation archive. Stress-test “Resolve revision paths before materialising” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “A `REV:path` expression can be resolved to a blob ID with git rev-parse or verified with git cat-file before calling unpack-file.” should remain invariant and what observation would expose passing the literal string HEAD:notes.txt to a script that promises only raw blob IDs without documenting resolution.

Case 4: revision-note builder. Explain “Resolve revision paths before materialising” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “A `REV:path` expression can be resolved to a blob ID with git rev-parse or verified with git cat-file before calling unpack-file.” should remain invariant and what observation would expose passing the literal string HEAD:notes.txt to a script that promises only raw blob IDs without documenting resolution.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals passing the literal string HEAD:notes.txt to a script that promises only raw blob IDs without documenting resolution.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Resolve, type-check and then materialise in three labelled steps.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Resolve revision paths before materialising”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A `REV:path` expression can be resolved to a blob ID with git rev-parse or verified with git cat-file before calling unpack-file.?”, and “Can you make a smaller example of passing the literal string HEAD:notes.txt to a script that promises only raw blob IDs without documenting resolution?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Materialise a file from the parent commit without checking out that commit. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Keep selection logic explicit so reviewers can see which historical content is requested. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Resolve revision paths before materialising” means the learner can predict the ordinary case, recognise passing the literal string HEAD:notes.txt to a script that promises only raw blob IDs without documenting resolution, diagnose the earliest mistaken assumption, recover with “Resolve, type-check and then materialise in three labelled steps.” and defend this decision: Keep selection logic explicit so reviewers can see which historical content is requested. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

git unpack-file writes blob bytes without turning them into text. That is the invariant to preserve when names, data or surrounding project details change.

Images, archives and other binary objects should not be piped through text assumptions. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is opening a binary temporary file with a text recoder and calling corruption a Git bug. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

oid=$(git hash-object -w sample.bin)
tmp=$(git unpack-file "$oid")
cmp -- sample.bin "$tmp"

Read the trace, not just the last line

Trace bytes and exit status rather than terminal glyphs. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Binary blobs require byte-safe consumers”, separate contract from coincidence. The contract is “git unpack-file writes blob bytes without turning them into text.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Verify with cmp or a digest and choose a binary-aware consumer.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Binary blobs require byte-safe consumers” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file writes blob bytes without turning them into text.” should remain invariant and what observation would expose opening a binary temporary file with a text recoder and calling corruption a Git bug.

Case 2: CCA media catalogue. Contrast “Binary blobs require byte-safe consumers” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file writes blob bytes without turning them into text.” should remain invariant and what observation would expose opening a binary temporary file with a text recoder and calling corruption a Git bug.

Case 3: science investigation archive. Stress-test “Binary blobs require byte-safe consumers” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file writes blob bytes without turning them into text.” should remain invariant and what observation would expose opening a binary temporary file with a text recoder and calling corruption a Git bug.

Case 4: revision-note builder. Explain “Binary blobs require byte-safe consumers” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file writes blob bytes without turning them into text.” should remain invariant and what observation would expose opening a binary temporary file with a text recoder and calling corruption a Git bug.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals opening a binary temporary file with a text recoder and calling corruption a Git bug.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Verify with cmp or a digest and choose a binary-aware consumer.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Binary blobs require byte-safe consumers”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests git unpack-file writes blob bytes without turning them into text.?”, and “Can you make a smaller example of opening a binary temporary file with a text recoder and calling corruption a Git bug?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Create a fixture containing zero bytes and verify round-trip equality. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Select downstream tools from MIME/content knowledge, not the `.merge_file_*` name. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Binary blobs require byte-safe consumers” means the learner can predict the ordinary case, recognise opening a binary temporary file with a text recoder and calling corruption a Git bug, diagnose the earliest mistaken assumption, recover with “Verify with cmp or a digest and choose a binary-aware consumer.” and defend this decision: Select downstream tools from MIME/content knowledge, not the `.merge_file_*` name. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

The `.merge_file_XXXXX` name does not preserve the source filename or extension. That is the invariant to preserve when names, data or surrounding project details change.

Some downstream applications infer format from content, while others rely on an extension. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is assuming a PNG blob produces a `.png` temporary name. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

tmp=$(git unpack-file "$oid")
file -- "$tmp"

Read the trace, not just the last line

Trace content identification separately from filename suffix. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “The generated name has no original extension”, separate contract from coincidence. The contract is “The `.merge_file_XXXXX` name does not preserve the source filename or extension.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Pass an explicit format option to the consumer or copy to a second controlled temp name when truly required.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “The generated name has no original extension” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “The `.merge_file_XXXXX` name does not preserve the source filename or extension.” should remain invariant and what observation would expose assuming a PNG blob produces a `.png` temporary name.

Case 2: CCA media catalogue. Contrast “The generated name has no original extension” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “The `.merge_file_XXXXX` name does not preserve the source filename or extension.” should remain invariant and what observation would expose assuming a PNG blob produces a `.png` temporary name.

Case 3: science investigation archive. Stress-test “The generated name has no original extension” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “The `.merge_file_XXXXX` name does not preserve the source filename or extension.” should remain invariant and what observation would expose assuming a PNG blob produces a `.png` temporary name.

Case 4: revision-note builder. Explain “The generated name has no original extension” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “The `.merge_file_XXXXX` name does not preserve the source filename or extension.” should remain invariant and what observation would expose assuming a PNG blob produces a `.png` temporary name.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals assuming a PNG blob produces a `.png` temporary name.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Pass an explicit format option to the consumer or copy to a second controlled temp name when truly required.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “The generated name has no original extension”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests The `.merge_file_XXXXX` name does not preserve the source filename or extension.?”, and “Can you make a smaller example of assuming a PNG blob produces a `.png` temporary name?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain why `file` may recognise a PNG while an extension-only viewer does not. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Prefer consumers with explicit format controls; create any renamed copy safely and clean both paths. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “The generated name has no original extension” means the learner can predict the ordinary case, recognise assuming a PNG blob produces a `.png` temporary name, diagnose the earliest mistaken assumption, recover with “Pass an explicit format option to the consumer or copy to a second controlled temp name when truly required.” and defend this decision: Prefer consumers with explicit format controls; create any renamed copy safely and clean both paths. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

On success, stdout carries the temporary filename, so scripts should not mix unrelated stdout messages into the capture. That is the invariant to preserve when names, data or surrounding project details change.

Clean data channels make command composition reliable. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is wrapping git unpack-file in a function that echoes progress to stdout before the path. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

materialise(){
  echo "creating temp file" >&2
  git unpack-file "$1"
}
tmp=$(materialise "$oid")

Read the trace, not just the last line

Trace stdout and stderr as separate streams. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Standard output is the path channel”, separate contract from coincidence. The contract is “On success, stdout carries the temporary filename, so scripts should not mix unrelated stdout messages into the capture.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Send progress to stderr and reserve stdout for the one generated name.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Standard output is the path channel” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “On success, stdout carries the temporary filename, so scripts should not mix unrelated stdout messages into the capture.” should remain invariant and what observation would expose wrapping git unpack-file in a function that echoes progress to stdout before the path.

Case 2: CCA media catalogue. Contrast “Standard output is the path channel” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “On success, stdout carries the temporary filename, so scripts should not mix unrelated stdout messages into the capture.” should remain invariant and what observation would expose wrapping git unpack-file in a function that echoes progress to stdout before the path.

Case 3: science investigation archive. Stress-test “Standard output is the path channel” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “On success, stdout carries the temporary filename, so scripts should not mix unrelated stdout messages into the capture.” should remain invariant and what observation would expose wrapping git unpack-file in a function that echoes progress to stdout before the path.

Case 4: revision-note builder. Explain “Standard output is the path channel” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “On success, stdout carries the temporary filename, so scripts should not mix unrelated stdout messages into the capture.” should remain invariant and what observation would expose wrapping git unpack-file in a function that echoes progress to stdout before the path.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals wrapping git unpack-file in a function that echoes progress to stdout before the path.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Send progress to stderr and reserve stdout for the one generated name.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Standard output is the path channel”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests On success, stdout carries the temporary filename, so scripts should not mix unrelated stdout messages into the capture.?”, and “Can you make a smaller example of wrapping git unpack-file in a function that echoes progress to stdout before the path?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Repair a wrapper that prints two lines to stdout. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Document stream contracts for every helper used in shell automation. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Standard output is the path channel” means the learner can predict the ordinary case, recognise wrapping git unpack-file in a function that echoes progress to stdout before the path, diagnose the earliest mistaken assumption, recover with “Send progress to stderr and reserve stdout for the one generated name.” and defend this decision: Document stream contracts for every helper used in shell automation. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

The caller that captures the generated path should remove that exact file when it is no longer needed. That is the invariant to preserve when names, data or surrounding project details change.

Broad cleanup can delete unrelated temporary files from other invocations. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is running `rm -f .merge_file_*` in a shared working directory. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

tmp=$(git unpack-file "$oid")
cleanup(){ rm -f -- "$tmp"; }
trap cleanup EXIT

Read the trace, not just the last line

Trace creation, trap installation, consumer and exit cleanup. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Cleanup owns one exact path”, separate contract from coincidence. The contract is “The caller that captures the generated path should remove that exact file when it is no longer needed.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Install a trap after successful creation and remove only the quoted captured name.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Cleanup owns one exact path” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “The caller that captures the generated path should remove that exact file when it is no longer needed.” should remain invariant and what observation would expose running `rm -f .merge_file_*` in a shared working directory.

Case 2: CCA media catalogue. Contrast “Cleanup owns one exact path” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “The caller that captures the generated path should remove that exact file when it is no longer needed.” should remain invariant and what observation would expose running `rm -f .merge_file_*` in a shared working directory.

Case 3: science investigation archive. Stress-test “Cleanup owns one exact path” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “The caller that captures the generated path should remove that exact file when it is no longer needed.” should remain invariant and what observation would expose running `rm -f .merge_file_*` in a shared working directory.

Case 4: revision-note builder. Explain “Cleanup owns one exact path” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “The caller that captures the generated path should remove that exact file when it is no longer needed.” should remain invariant and what observation would expose running `rm -f .merge_file_*` in a shared working directory.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals running `rm -f .merge_file_*` in a shared working directory.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Install a trap after successful creation and remove only the quoted captured name.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Cleanup owns one exact path”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests The caller that captures the generated path should remove that exact file when it is no longer needed.?”, and “Can you make a smaller example of running `rm -f .merge_file_*` in a shared working directory?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain why a wildcard cleanup is unsafe during two concurrent scripts. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Use a robust trap function when filenames or multiple resources make inline quoting complex. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Cleanup owns one exact path” means the learner can predict the ordinary case, recognise running `rm -f .merge_file_*` in a shared working directory, diagnose the earliest mistaken assumption, recover with “Install a trap after successful creation and remove only the quoted captured name.” and defend this decision: Use a robust trap function when filenames or multiple resources make inline quoting complex. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A script may terminate before its normal final rm, leaving a materialised file behind. That is the invariant to preserve when names, data or surrounding project details change.

Temporary-file discipline includes error and signal paths. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is placing rm only after a consumer that can fail under `set -e`. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

cleanup(){ test -z "${tmp-}" || rm -f -- "$tmp"; }
trap cleanup EXIT HUP INT TERM

Read the trace, not just the last line

Trace which traps run and avoid promising uncatchable-signal cleanup. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Signals and early exits belong in the cleanup plan”, separate contract from coincidence. The contract is “A script may terminate before its normal final rm, leaving a materialised file behind.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Install cleanup immediately after success and make it idempotent.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Signals and early exits belong in the cleanup plan” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “A script may terminate before its normal final rm, leaving a materialised file behind.” should remain invariant and what observation would expose placing rm only after a consumer that can fail under `set -e`.

Case 2: CCA media catalogue. Contrast “Signals and early exits belong in the cleanup plan” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “A script may terminate before its normal final rm, leaving a materialised file behind.” should remain invariant and what observation would expose placing rm only after a consumer that can fail under `set -e`.

Case 3: science investigation archive. Stress-test “Signals and early exits belong in the cleanup plan” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “A script may terminate before its normal final rm, leaving a materialised file behind.” should remain invariant and what observation would expose placing rm only after a consumer that can fail under `set -e`.

Case 4: revision-note builder. Explain “Signals and early exits belong in the cleanup plan” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “A script may terminate before its normal final rm, leaving a materialised file behind.” should remain invariant and what observation would expose placing rm only after a consumer that can fail under `set -e`.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals placing rm only after a consumer that can fail under `set -e`.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Install cleanup immediately after success and make it idempotent.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Signals and early exits belong in the cleanup plan”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A script may terminate before its normal final rm, leaving a materialised file behind.?”, and “Can you make a smaller example of placing rm only after a consumer that can fail under `set -e`?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Force the consumer to fail and verify the file is removed on shell exit. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Keep temporary data sensitivity and crash-recovery expectations in the design. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Signals and early exits belong in the cleanup plan” means the learner can predict the ordinary case, recognise placing rm only after a consumer that can fail under `set -e`, diagnose the earliest mistaken assumption, recover with “Install cleanup immediately after success and make it idempotent.” and defend this decision: Keep temporary data sensitivity and crash-recovery expectations in the design. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

The created file is an ordinary filesystem object whose permissions and directory context matter. That is the invariant to preserve when names, data or surrounding project details change.

A blob that was safely stored in Git can become exposed if materialised in an unsuitable shared directory. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is assuming “temporary” automatically means private on every system. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

tmp=$(git unpack-file "$oid")
ls -l -- "$tmp"

Read the trace, not just the last line

Trace process umask, created mode and containing directory. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Permissions protect the temporary copy”, separate contract from coincidence. The contract is “The created file is an ordinary filesystem object whose permissions and directory context matter.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Inspect mode and working-directory permissions in the deployment environment.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Permissions protect the temporary copy” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “The created file is an ordinary filesystem object whose permissions and directory context matter.” should remain invariant and what observation would expose assuming “temporary” automatically means private on every system.

Case 2: CCA media catalogue. Contrast “Permissions protect the temporary copy” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “The created file is an ordinary filesystem object whose permissions and directory context matter.” should remain invariant and what observation would expose assuming “temporary” automatically means private on every system.

Case 3: science investigation archive. Stress-test “Permissions protect the temporary copy” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “The created file is an ordinary filesystem object whose permissions and directory context matter.” should remain invariant and what observation would expose assuming “temporary” automatically means private on every system.

Case 4: revision-note builder. Explain “Permissions protect the temporary copy” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “The created file is an ordinary filesystem object whose permissions and directory context matter.” should remain invariant and what observation would expose assuming “temporary” automatically means private on every system.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals assuming “temporary” automatically means private on every system.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Inspect mode and working-directory permissions in the deployment environment.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Permissions protect the temporary copy”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests The created file is an ordinary filesystem object whose permissions and directory context matter.?”, and “Can you make a smaller example of assuming “temporary” automatically means private on every system?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Write a policy for materialising a confidential fixture in CI. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Do not use unpack-file for secrets unless the storage and lifecycle model is explicitly approved. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Permissions protect the temporary copy” means the learner can predict the ordinary case, recognise assuming “temporary” automatically means private on every system, diagnose the earliest mistaken assumption, recover with “Inspect mode and working-directory permissions in the deployment environment.” and defend this decision: Do not use unpack-file for secrets unless the storage and lifecycle model is explicitly approved. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A commit, tree or tag is not a blob, and the error report should say which type was supplied. That is the invariant to preserve when names, data or surrounding project details change.

Precise diagnosis teaches Git’s object model instead of producing a generic “command failed”. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is retrying the same commit ID or adding force flags that the command does not support. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

type=$(git cat-file -t "$oid")
if test "$type" != blob; then
  printf "expected blob, got %s\n" "$type" >&2
  exit 2
fi

Read the trace, not just the last line

Trace resolution and type before the command. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Wrong object types deserve precise diagnostics”, separate contract from coincidence. The contract is “A commit, tree or tag is not a blob, and the error report should say which type was supplied.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Call cat-file -t on the resolved object and branch on the result.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Wrong object types deserve precise diagnostics” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “A commit, tree or tag is not a blob, and the error report should say which type was supplied.” should remain invariant and what observation would expose retrying the same commit ID or adding force flags that the command does not support.

Case 2: CCA media catalogue. Contrast “Wrong object types deserve precise diagnostics” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “A commit, tree or tag is not a blob, and the error report should say which type was supplied.” should remain invariant and what observation would expose retrying the same commit ID or adding force flags that the command does not support.

Case 3: science investigation archive. Stress-test “Wrong object types deserve precise diagnostics” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “A commit, tree or tag is not a blob, and the error report should say which type was supplied.” should remain invariant and what observation would expose retrying the same commit ID or adding force flags that the command does not support.

Case 4: revision-note builder. Explain “Wrong object types deserve precise diagnostics” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “A commit, tree or tag is not a blob, and the error report should say which type was supplied.” should remain invariant and what observation would expose retrying the same commit ID or adding force flags that the command does not support.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals retrying the same commit ID or adding force flags that the command does not support.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Call cat-file -t on the resolved object and branch on the result.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Wrong object types deserve precise diagnostics”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A commit, tree or tag is not a blob, and the error report should say which type was supplied.?”, and “Can you make a smaller example of retrying the same commit ID or adding force flags that the command does not support?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Provide a commit ID and show the diagnostic without creating a temp file. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Use object-model language rather than treating every hexadecimal string as interchangeable. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Wrong object types deserve precise diagnostics” means the learner can predict the ordinary case, recognise retrying the same commit ID or adding force flags that the command does not support, diagnose the earliest mistaken assumption, recover with “Call cat-file -t on the resolved object and branch on the result.” and defend this decision: Use object-model language rather than treating every hexadecimal string as interchangeable. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A malformed revision, an unknown object ID and a known non-blob object fail at different stages. That is the invariant to preserve when names, data or surrounding project details change.

Separating them shortens debugging and avoids misleading recovery advice. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is labelling every error “file not found”. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

if ! oid=$(git rev-parse --verify "$spec^{object}"); then
  echo "cannot resolve object" >&2
fi

Read the trace, not just the last line

Trace user specification before resolved OID. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Missing and malformed IDs are different failures”, separate contract from coincidence. The contract is “A malformed revision, an unknown object ID and a known non-blob object fail at different stages.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Validate revision syntax/resolution, existence/type and unpacking as separate operations.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Missing and malformed IDs are different failures” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “A malformed revision, an unknown object ID and a known non-blob object fail at different stages.” should remain invariant and what observation would expose labelling every error “file not found”.

Case 2: CCA media catalogue. Contrast “Missing and malformed IDs are different failures” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “A malformed revision, an unknown object ID and a known non-blob object fail at different stages.” should remain invariant and what observation would expose labelling every error “file not found”.

Case 3: science investigation archive. Stress-test “Missing and malformed IDs are different failures” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “A malformed revision, an unknown object ID and a known non-blob object fail at different stages.” should remain invariant and what observation would expose labelling every error “file not found”.

Case 4: revision-note builder. Explain “Missing and malformed IDs are different failures” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “A malformed revision, an unknown object ID and a known non-blob object fail at different stages.” should remain invariant and what observation would expose labelling every error “file not found”.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals labelling every error “file not found”.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Validate revision syntax/resolution, existence/type and unpacking as separate operations.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Missing and malformed IDs are different failures”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A malformed revision, an unknown object ID and a known non-blob object fail at different stages.?”, and “Can you make a smaller example of labelling every error “file not found”?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Create three tests: nonsense text, absent full ID and commit ID. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Do not blindly retry deterministic input errors; fix the failing boundary. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Missing and malformed IDs are different failures” means the learner can predict the ordinary case, recognise labelling every error “file not found”, diagnose the earliest mistaken assumption, recover with “Validate revision syntax/resolution, existence/type and unpacking as separate operations.” and defend this decision: Do not blindly retry deterministic input errors; fix the failing boundary. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

Each unpack-file invocation generates its own name, and concurrent jobs must keep those paths separate. That is the invariant to preserve when names, data or surrounding project details change.

Global variables and wildcard cleanup create cross-job races. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is storing every generated name in one shared `tmp` file without locking. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

tmp_a=$(git unpack-file "$oid_a")
tmp_b=$(git unpack-file "$oid_b")

Read the trace, not just the last line

Trace creator, path and cleanup owner as a tuple. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Parallel invocations need independent variables”, separate contract from coincidence. The contract is “Each unpack-file invocation generates its own name, and concurrent jobs must keep those paths separate.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Keep the path in process-local state or a job-specific record and clean by ownership.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Parallel invocations need independent variables” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “Each unpack-file invocation generates its own name, and concurrent jobs must keep those paths separate.” should remain invariant and what observation would expose storing every generated name in one shared `tmp` file without locking.

Case 2: CCA media catalogue. Contrast “Parallel invocations need independent variables” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “Each unpack-file invocation generates its own name, and concurrent jobs must keep those paths separate.” should remain invariant and what observation would expose storing every generated name in one shared `tmp` file without locking.

Case 3: science investigation archive. Stress-test “Parallel invocations need independent variables” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “Each unpack-file invocation generates its own name, and concurrent jobs must keep those paths separate.” should remain invariant and what observation would expose storing every generated name in one shared `tmp` file without locking.

Case 4: revision-note builder. Explain “Parallel invocations need independent variables” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “Each unpack-file invocation generates its own name, and concurrent jobs must keep those paths separate.” should remain invariant and what observation would expose storing every generated name in one shared `tmp` file without locking.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals storing every generated name in one shared `tmp` file without locking.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Keep the path in process-local state or a job-specific record and clean by ownership.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Parallel invocations need independent variables”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Each unpack-file invocation generates its own name, and concurrent jobs must keep those paths separate.?”, and “Can you make a smaller example of storing every generated name in one shared `tmp` file without locking?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain a failure where job A deletes job B’s file with a wildcard. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Use process isolation or structured orchestration when materialising many blobs. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Parallel invocations need independent variables” means the learner can predict the ordinary case, recognise storing every generated name in one shared `tmp` file without locking, diagnose the earliest mistaken assumption, recover with “Keep the path in process-local state or a job-specific record and clean by ownership.” and defend this decision: Use process isolation or structured orchestration when materialising many blobs. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

git cat-file can write blob content to stdout, while git unpack-file creates a named file and prints that name. That is the invariant to preserve when names, data or surrounding project details change.

The downstream interface decides which tool is simpler. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is using unpack-file only to immediately cat and delete it. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

git cat-file blob "$oid" | sha256sum
tmp=$(git unpack-file "$oid")
path_only_tool "$tmp"

Read the trace, not just the last line

Trace whether the consumer needs bytes or a filesystem path. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Compare unpack-file with cat-file”, separate contract from coincidence. The contract is “git cat-file can write blob content to stdout, while git unpack-file creates a named file and prints that name.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Pipe cat-file to a stream consumer; use unpack-file for a tool that truly requires a pathname.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Compare unpack-file with cat-file” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “git cat-file can write blob content to stdout, while git unpack-file creates a named file and prints that name.” should remain invariant and what observation would expose using unpack-file only to immediately cat and delete it.

Case 2: CCA media catalogue. Contrast “Compare unpack-file with cat-file” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “git cat-file can write blob content to stdout, while git unpack-file creates a named file and prints that name.” should remain invariant and what observation would expose using unpack-file only to immediately cat and delete it.

Case 3: science investigation archive. Stress-test “Compare unpack-file with cat-file” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “git cat-file can write blob content to stdout, while git unpack-file creates a named file and prints that name.” should remain invariant and what observation would expose using unpack-file only to immediately cat and delete it.

Case 4: revision-note builder. Explain “Compare unpack-file with cat-file” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “git cat-file can write blob content to stdout, while git unpack-file creates a named file and prints that name.” should remain invariant and what observation would expose using unpack-file only to immediately cat and delete it.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals using unpack-file only to immediately cat and delete it.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Pipe cat-file to a stream consumer; use unpack-file for a tool that truly requires a pathname.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Compare unpack-file with cat-file”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests git cat-file can write blob content to stdout, while git unpack-file creates a named file and prints that name.?”, and “Can you make a smaller example of using unpack-file only to immediately cat and delete it?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Choose a tool for hashing content and another for an editor that accepts only paths. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Minimise temporary data when a stream is sufficient. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Compare unpack-file with cat-file” means the learner can predict the ordinary case, recognise using unpack-file only to immediately cat and delete it, diagnose the earliest mistaken assumption, recover with “Pipe cat-file to a stream consumer; use unpack-file for a tool that truly requires a pathname.” and defend this decision: Minimise temporary data when a stream is sufficient. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

git show REV:path prints selected content, while archive and checkout-related tools solve broader tree or worktree jobs. That is the invariant to preserve when names, data or surrounding project details change.

unpack-file is intentionally one-blob plumbing, not a historical workspace builder. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is looping over a whole tree with unpack-file when an archive is the real product. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

git show HEAD:notes.txt
git archive --format=tar HEAD
git unpack-file "$oid"

Read the trace, not just the last line

Trace requested unit and output channel. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Compare unpack-file with show and archive workflows”, separate contract from coincidence. The contract is “git show REV:path prints selected content, while archive and checkout-related tools solve broader tree or worktree jobs.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Name the unit of work: one blob, one printed file, a tree archive or a checked-out worktree.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Compare unpack-file with show and archive workflows” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “git show REV:path prints selected content, while archive and checkout-related tools solve broader tree or worktree jobs.” should remain invariant and what observation would expose looping over a whole tree with unpack-file when an archive is the real product.

Case 2: CCA media catalogue. Contrast “Compare unpack-file with show and archive workflows” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “git show REV:path prints selected content, while archive and checkout-related tools solve broader tree or worktree jobs.” should remain invariant and what observation would expose looping over a whole tree with unpack-file when an archive is the real product.

Case 3: science investigation archive. Stress-test “Compare unpack-file with show and archive workflows” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “git show REV:path prints selected content, while archive and checkout-related tools solve broader tree or worktree jobs.” should remain invariant and what observation would expose looping over a whole tree with unpack-file when an archive is the real product.

Case 4: revision-note builder. Explain “Compare unpack-file with show and archive workflows” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “git show REV:path prints selected content, while archive and checkout-related tools solve broader tree or worktree jobs.” should remain invariant and what observation would expose looping over a whole tree with unpack-file when an archive is the real product.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals looping over a whole tree with unpack-file when an archive is the real product.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Name the unit of work: one blob, one printed file, a tree archive or a checked-out worktree.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Compare unpack-file with show and archive workflows”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests git show REV:path prints selected content, while archive and checkout-related tools solve broader tree or worktree jobs.?”, and “Can you make a smaller example of looping over a whole tree with unpack-file when an archive is the real product?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Pick a command for exporting an entire directory at a revision. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Do not stretch a narrow plumbing command into a competing broad workflow. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Compare unpack-file with show and archive workflows” means the learner can predict the ordinary case, recognise looping over a whole tree with unpack-file when an archive is the real product, diagnose the earliest mistaken assumption, recover with “Name the unit of work: one blob, one printed file, a tree archive or a checked-out worktree.” and defend this decision: Do not stretch a narrow plumbing command into a competing broad workflow. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

git unpack-file is the right fit when a known blob must become a short-lived ordinary file for a pathname-based consumer. That is the invariant to preserve when names, data or surrounding project details change.

The final decision combines object type, repository context, byte fidelity, permissions, cleanup and alternative tools. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is choosing it merely because the command name sounds like archive extraction. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

tmp=$(git unpack-file "$oid")
trap cleanup EXIT
consumer -- "$tmp"

Read the trace, not just the last line

Map stream consumer, path consumer, tree export and worktree edit to different Git tools. Write the trace as a sequence of labelled states. For Git unpack-file, the decisive evidence may be an iterator close, a cached classification, a glyph-spacing decision or a repository object path; printing only the final Boolean or filename can hide the mechanism that produced it.

For “Choose unpack-file only for a pathname boundary”, separate contract from coincidence. The contract is “git unpack-file is the right fit when a known blob must become a short-lived ordinary file for a pathname-based consumer.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Write the consumer requirement first, then verify that one blob and one temporary path are exactly the needed bridge.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework evidence folder. Model “Choose unpack-file only for a pathname boundary” with subject folders, draft answers and a reviewed copy. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file is the right fit when a known blob must become a short-lived ordinary file for a pathname-based consumer.” should remain invariant and what observation would expose choosing it merely because the command name sounds like archive extraction.

Case 2: CCA media catalogue. Contrast “Choose unpack-file only for a pathname boundary” with event folders, selected images and caption notes. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file is the right fit when a known blob must become a short-lived ordinary file for a pathname-based consumer.” should remain invariant and what observation would expose choosing it merely because the command name sounds like archive extraction.

Case 3: science investigation archive. Stress-test “Choose unpack-file only for a pathname boundary” with raw readings, cleaned tables and chart exports. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file is the right fit when a known blob must become a short-lived ordinary file for a pathname-based consumer.” should remain invariant and what observation would expose choosing it merely because the command name sounds like archive extraction.

Case 4: revision-note builder. Explain “Choose unpack-file only for a pathname boundary” with topic notes, worked examples and a generated index. Before touching a tool, state which part of the case corresponds to the input, why “git unpack-file is the right fit when a known blob must become a short-lived ordinary file for a pathname-based consumer.” should remain invariant and what observation would expose choosing it merely because the command name sounds like archive extraction.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals choosing it merely because the command name sounds like archive extraction.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Write the consumer requirement first, then verify that one blob and one temporary path are exactly the needed bridge.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Git unpack-file to support “Choose unpack-file only for a pathname boundary”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests git unpack-file is the right fit when a known blob must become a short-lived ordinary file for a pathname-based consumer.?”, and “Can you make a smaller example of choosing it merely because the command name sounds like archive extraction?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Use cat-file/show, unpack-file, archive and ordinary checkout/worktree workflows respectively. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

undefined Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Choose unpack-file only for a pathname boundary” means the learner can predict the ordinary case, recognise choosing it merely because the command name sounds like archive extraction, diagnose the earliest mistaken assumption, recover with “Write the consumer requirement first, then verify that one blob and one temporary path are exactly the needed bridge.” and defend this decision: undefined Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

For Git unpack-file, start with evidence rather than a label such as careless. Ask for one prediction and one trace. If the first transition is wrong, rebuild the model. If the model is sound but reference use is weak, practise finding the governing contract. If routine cases work but boundaries fail, vary one condition. If explanations transfer, move to a small project.

Punggol family routines are often busy, so use one complete Git unpack-file prediction–observation–explanation cycle while attention is good. Ten to twenty focused minutes can be enough. Keep a four-line record: concept, prediction, observed difference and next test. Stop when fatigue replaces reasoning.

Use disposable fixtures, temporary directories and test repositories. Backups remain necessary. The activities in this guide are proposed home-learning exercises, not advertised lesson times, branch facilities, school affiliations or outcome guarantees.

1. Materialise and verify one text blob

Create a disposable repository, write a blob, unpack it and prove byte equality. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

2. Build a safe shell wrapper

Gate the consumer on success, quote the generated path and reserve stdout for data. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

3. Reject a commit with a type diagnostic

Supply HEAD, report its actual object type and create no temp file. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

4. Round-trip a binary fixture

Store bytes containing NUL, unpack them and compare with cmp. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

5. Test cleanup on failure

Install an idempotent trap and make the downstream consumer exit nonzero. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

6. Resolve historical file content

Resolve a REV:path expression, type-check it and materialise without checkout. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

7. Choose stream or pathname

Solve one hashing job and one pathname-only tool job. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

8. Write a concurrent-job incident report

Explain how wildcard cleanup can delete another job’s file and repair the design. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Frequently asked questions

How long should a practice session be?

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

Should every option or method be memorised?

No. For Git unpack-file, memorise governing distinctions and practise retrieving the primary reference. Understanding means predicting and explaining, not reciting a parameter list.

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

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

Is the shortest solution the best?

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

When should the official reference be used?

Use it whenever Git unpack-file syntax, supported values, version behaviour or implementation boundaries matter. The primary source settles the current contract.

How can a parent help without technical expertise?

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

How do we test transfer?

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

What should be saved after practice?

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

Can these exercises replace backups?

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

What counts as mastery?

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

Primary and supporting references

• Primary technical source for Git unpack-file
• eduKatePunggol: How Studying Works

Return to contents