When a learner can reproduce a familiar example but a small variation causes confusion, the problem is usually an incomplete model rather than a lack of effort. The fastest useful response is to expose the hidden state and test one boundary at a time.

git var prints a Git logical variable: a resolved value that Git derives from configuration, environment and built-in defaults for a specific operational job. The current manual documents identity, editor, sequence editor, pager, default branch, shell and system or global attribute and configuration paths. Mastery means distinguishing a logical variable from an environment variable or raw config key, reading precedence without inventing it, handling absent values and multi-line paths, and avoiding the deprecated use of git var -l as a general configuration listing interface. This guide begins with that mechanism, then develops it through worked traces, deliberate mistakes, explained practice and transfer decisions.

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

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

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

A logical variable is Git resolved operational information, not simply one environment variable or one line from a config file. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is looking only at env output and assuming it predicts Git final behaviour. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Ask git var for one documented name and compare it with each candidate source in a disposable environment.

For the git var prints a logical variable chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on looking only at env output and assuming it predicts Git final behaviour. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git var GIT_AUTHOR_IDENT

Four purposeful transfer cases

Case 1: homework repository. Predict the rule using the author identity and first branch name used in a disposable project. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading-notes repository. Contrast the rule using the editor used for commit messages and the pager used for long output. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science project. Stress-test the rule using system and global configuration paths checked without modifying them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA website. Explain the rule using a sequence editor for an interactive rebase rehearsal. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers looking only at env output and assuming it predicts Git final behaviour.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Ask git var for one documented name and compare it with each candidate source in a disposable environment.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from git var prints a logical variable?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing looking only at env output and assuming it predicts Git final behaviour be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library catalogue with automation that requests one logical variable and validates exit status. Include one ordinary case, one boundary and one deliberate failure caused by looking only at env output and assuming it predicts Git final behaviour. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

The synopsis accepts either -l or one variable name, and an unknown or valueless variable makes the command fail. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is passing several variable names and assuming one invocation returns a table. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Query one logical variable per decision and record standard output and exit status.

For the Use the documented command shape chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on passing several variable names and assuming one invocation returns a table. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git var GIT_EDITOR

Four purposeful transfer cases

Case 1: science project. Contrast the rule using system and global configuration paths checked without modifying them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA website. Stress-test the rule using a sequence editor for an interactive rebase rehearsal. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family computer. Explain the rule using different environment and global settings resolved in a safe test shell. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library catalogue. Transfer the rule using automation that requests one logical variable and validates exit status. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers passing several variable names and assuming one invocation returns a table.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Query one logical variable per decision and record standard output and exit status.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from Use the documented command shape?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing passing several variable names and assuming one invocation returns a table be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with temporary HOME, repository config, environment precedence and disabled path cases. Include one ordinary case, one boundary and one deliberate failure caused by passing several variable names and assuming one invocation returns a table. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

The manual states that git var exits with code 1 when the requested variable has no value. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is capturing empty standard output without checking whether resolution failed. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use a shell conditional or subprocess return code before consuming the value.

For the Exit status is part of the interface chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on capturing empty standard output without checking whether resolution failed. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

if value=$(git var GIT_ATTR_SYSTEM); then printf '%s
' "$value"; fi

Four purposeful transfer cases

Case 1: family computer. Stress-test the rule using different environment and global settings resolved in a safe test shell. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library catalogue. Explain the rule using automation that requests one logical variable and validates exit status. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Transfer the rule using temporary HOME, repository config, environment precedence and disabled path cases. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Predict the rule using git var compared with git config get, environment inspection and shell lookup. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers capturing empty standard output without checking whether resolution failed.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Use a shell conditional or subprocess return code before consuming the value.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from Exit status is part of the interface?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing capturing empty standard output without checking whether resolution failed be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design decision with git var compared with git config get, environment inspection and shell lookup. Include one ordinary case, one boundary and one deliberate failure caused by capturing empty standard output without checking whether resolution failed. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Exit status is part of the interface, separate the documented Git var mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The author logical variable describes who originally wrote the change and includes identity plus current date information in Git ident form. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is parsing it as only name and email by splitting on spaces. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use Git plumbing that understands ident syntax, or treat the output as one opaque diagnostic string.

For the GIT_AUTHOR_IDENT is a complete ident chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on parsing it as only name and email by splitting on spaces. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git var GIT_AUTHOR_IDENT

Four purposeful transfer cases

Case 1: test laboratory. Explain the rule using temporary HOME, repository config, environment precedence and disabled path cases. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Transfer the rule using git var compared with git config get, environment inspection and shell lookup. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework repository. Predict the rule using the author identity and first branch name used in a disposable project. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading-notes repository. Contrast the rule using the editor used for commit messages and the pager used for long output. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers parsing it as only name and email by splitting on spaces.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Use Git plumbing that understands ident syntax, or treat the output as one opaque diagnostic string.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from GIT_AUTHOR_IDENT is a complete ident?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing parsing it as only name and email by splitting on spaces be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework repository with the author identity and first branch name used in a disposable project. Include one ordinary case, one boundary and one deliberate failure caused by parsing it as only name and email by splitting on spaces. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

GIT_AUTHOR_IDENT identifies the author of the content, while GIT_COMMITTER_IDENT identifies the person recording it in Git. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is assuming amended, rebased or applied commits must have identical author and committer fields. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Inspect both variables and then inspect an actual commit with a format that shows both roles.

For the Author and committer are different roles chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming amended, rebased or applied commits must have identical author and committer fields. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git var GIT_AUTHOR_IDENT
git var GIT_COMMITTER_IDENT

Four purposeful transfer cases

Case 1: homework repository. Transfer the rule using the author identity and first branch name used in a disposable project. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading-notes repository. Predict the rule using the editor used for commit messages and the pager used for long output. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science project. Contrast the rule using system and global configuration paths checked without modifying them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA website. Stress-test the rule using a sequence editor for an interactive rebase rehearsal. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers assuming amended, rebased or applied commits must have identical author and committer fields.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Inspect both variables and then inspect an actual commit with a format that shows both roles.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from Author and committer are different roles?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming amended, rebased or applied commits must have identical author and committer fields be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny reading-notes repository with the editor used for commit messages and the pager used for long output. Include one ordinary case, one boundary and one deliberate failure caused by assuming amended, rebased or applied commits must have identical author and committer fields. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

Git identity can be influenced by environment and configuration, so git var reports the resolved result rather than one chosen source. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is editing global config before discovering a repository or environment override. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Create a temporary repository and vary one source at a time while keeping the rest fixed.

For the Identity resolution has precedence chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on editing global config before discovering a repository or environment override. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git -c user.name='Lab User' -c user.email='lab@example.test' var GIT_AUTHOR_IDENT

Four purposeful transfer cases

Case 1: science project. Predict the rule using system and global configuration paths checked without modifying them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA website. Contrast the rule using a sequence editor for an interactive rebase rehearsal. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family computer. Stress-test the rule using different environment and global settings resolved in a safe test shell. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library catalogue. Explain the rule using automation that requests one logical variable and validates exit status. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers editing global config before discovering a repository or environment override.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Create a temporary repository and vary one source at a time while keeping the rest fixed.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from Identity resolution has precedence?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing editing global config before discovering a repository or environment override be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science project with system and global configuration paths checked without modifying them. Include one ordinary case, one boundary and one deliberate failure caused by editing global config before discovering a repository or environment override. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

GIT_EDITOR follows the documented preference chain from the GIT_EDITOR environment variable to core.editor, VISUAL, EDITOR and the compile-time default. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is checking only EDITOR and wondering why Git launches another program. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Clear or set one source at a time in a disposable shell and query the logical variable after each change.

For the GIT_EDITOR is the resolved editor command chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on checking only EDITOR and wondering why Git launches another program. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

GIT_EDITOR='code --wait' git var GIT_EDITOR

Four purposeful transfer cases

Case 1: family computer. Contrast the rule using different environment and global settings resolved in a safe test shell. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library catalogue. Stress-test the rule using automation that requests one logical variable and validates exit status. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Explain the rule using temporary HOME, repository config, environment precedence and disabled path cases. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Transfer the rule using git var compared with git config get, environment inspection and shell lookup. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers checking only EDITOR and wondering why Git launches another program.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Clear or set one source at a time in a disposable shell and query the logical variable after each change.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from GIT_EDITOR is the resolved editor command?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing checking only EDITOR and wondering why Git launches another program be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA website with a sequence editor for an interactive rebase rehearsal. Include one ordinary case, one boundary and one deliberate failure caused by checking only EDITOR and wondering why Git launches another program. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

The editor value can include paths, quoting and arguments and is meant to be interpreted by the shell when Git uses it. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is splitting the value on whitespace in automation and breaking quoted executable paths. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Keep the returned command intact unless a trusted shell-command parser is deliberately part of the design.

For the Editor values are shell command strings chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on splitting the value on whitespace in automation and breaking quoted executable paths. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git -c core.editor='my-editor --wait' var GIT_EDITOR

Four purposeful transfer cases

Case 1: test laboratory. Stress-test the rule using temporary HOME, repository config, environment precedence and disabled path cases. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Explain the rule using git var compared with git config get, environment inspection and shell lookup. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework repository. Transfer the rule using the author identity and first branch name used in a disposable project. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading-notes repository. Predict the rule using the editor used for commit messages and the pager used for long output. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers splitting the value on whitespace in automation and breaking quoted executable paths.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Keep the returned command intact unless a trusted shell-command parser is deliberately part of the design.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from Editor values are shell command strings?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing splitting the value on whitespace in automation and breaking quoted executable paths be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family computer with different environment and global settings resolved in a safe test shell. Include one ordinary case, one boundary and one deliberate failure caused by splitting the value on whitespace in automation and breaking quoted executable paths. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

The sequence editor for interactive rebase prefers GIT_SEQUENCE_EDITOR, then sequence.editor, then the resolved GIT_EDITOR value. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is changing core.editor when only the rebase todo editor should change. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Query both logical variables and test interactive rebase only inside a disposable repository.

For the GIT_SEQUENCE_EDITOR has its own precedence chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on changing core.editor when only the rebase todo editor should change. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git -c sequence.editor='cat' var GIT_SEQUENCE_EDITOR

Four purposeful transfer cases

Case 1: homework repository. Explain the rule using the author identity and first branch name used in a disposable project. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading-notes repository. Transfer the rule using the editor used for commit messages and the pager used for long output. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science project. Predict the rule using system and global configuration paths checked without modifying them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA website. Contrast the rule using a sequence editor for an interactive rebase rehearsal. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers changing core.editor when only the rebase todo editor should change.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Query both logical variables and test interactive rebase only inside a disposable repository.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from GIT_SEQUENCE_EDITOR has its own precedence?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing changing core.editor when only the rebase todo editor should change be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library catalogue with automation that requests one logical variable and validates exit status. Include one ordinary case, one boundary and one deliberate failure caused by changing core.editor when only the rebase todo editor should change. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

The pager logical variable follows GIT_PAGER, core.pager, PAGER and a compile-time default such as less. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is treating pager output as a boolean setting instead of a command. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compare git var GIT_PAGER with the relevant sources and keep terminal testing non-interactive.

For the GIT_PAGER is a resolved viewer command chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on treating pager output as a boolean setting instead of a command. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

GIT_PAGER=cat git var GIT_PAGER

Four purposeful transfer cases

Case 1: science project. Transfer the rule using system and global configuration paths checked without modifying them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA website. Predict the rule using a sequence editor for an interactive rebase rehearsal. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family computer. Contrast the rule using different environment and global settings resolved in a safe test shell. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library catalogue. Stress-test the rule using automation that requests one logical variable and validates exit status. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers treating pager output as a boolean setting instead of a command.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Compare git var GIT_PAGER with the relevant sources and keep terminal testing non-interactive.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from GIT_PAGER is a resolved viewer command?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating pager output as a boolean setting instead of a command be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with temporary HOME, repository config, environment precedence and disabled path cases. Include one ordinary case, one boundary and one deliberate failure caused by treating pager output as a boolean setting instead of a command. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

GIT_DEFAULT_BRANCH is the name Git would use for the first branch in a newly initialized repository under the current settings. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is assuming it renames an existing repository branch. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Query the logical variable, then test git init in a separate empty directory rather than modifying real history.

For the GIT_DEFAULT_BRANCH names a future initial branch chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming it renames an existing repository branch. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git -c init.defaultBranch=main var GIT_DEFAULT_BRANCH

Four purposeful transfer cases

Case 1: family computer. Predict the rule using different environment and global settings resolved in a safe test shell. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library catalogue. Contrast the rule using automation that requests one logical variable and validates exit status. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Stress-test the rule using temporary HOME, repository config, environment precedence and disabled path cases. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Explain the rule using git var compared with git config get, environment inspection and shell lookup. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers assuming it renames an existing repository branch.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Query the logical variable, then test git init in a separate empty directory rather than modifying real history.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from GIT_DEFAULT_BRANCH names a future initial branch?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming it renames an existing repository branch be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design decision with git var compared with git config get, environment inspection and shell lookup. Include one ordinary case, one boundary and one deliberate failure caused by assuming it renames an existing repository branch. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For GIT_DEFAULT_BRANCH names a future initial branch, separate the documented Git var mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

GIT_SHELL_PATH is the path of the binary providing the POSIX shell for Git commands that use it. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is assuming it is the user login shell or the value of SHELL. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compare git var output with shell environment separately and avoid rewriting either path casually.

For the GIT_SHELL_PATH reports Git POSIX shell chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming it is the user login shell or the value of SHELL. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git var GIT_SHELL_PATH

Four purposeful transfer cases

Case 1: test laboratory. Contrast the rule using temporary HOME, repository config, environment precedence and disabled path cases. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Stress-test the rule using git var compared with git config get, environment inspection and shell lookup. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework repository. Explain the rule using the author identity and first branch name used in a disposable project. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading-notes repository. Transfer the rule using the editor used for commit messages and the pager used for long output. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers assuming it is the user login shell or the value of SHELL.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Compare git var output with shell environment separately and avoid rewriting either path casually.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from GIT_SHELL_PATH reports Git POSIX shell?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming it is the user login shell or the value of SHELL be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework repository with the author identity and first branch name used in a disposable project. Include one ordinary case, one boundary and one deliberate failure caused by assuming it is the user login shell or the value of SHELL. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

GIT_ATTR_SYSTEM gives the system gitattributes path if that source is enabled. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is assuming every printed path exists or that no output means a filesystem error. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Check command status, then test path existence separately because Git can print configured paths that do not exist.

For the GIT_ATTR_SYSTEM reports the system attributes path chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming every printed path exists or that no output means a filesystem error. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git var GIT_ATTR_SYSTEM

Four purposeful transfer cases

Case 1: homework repository. Stress-test the rule using the author identity and first branch name used in a disposable project. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading-notes repository. Explain the rule using the editor used for commit messages and the pager used for long output. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science project. Transfer the rule using system and global configuration paths checked without modifying them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA website. Predict the rule using a sequence editor for an interactive rebase rehearsal. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers assuming every printed path exists or that no output means a filesystem error.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Check command status, then test path existence separately because Git can print configured paths that do not exist.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from GIT_ATTR_SYSTEM reports the system attributes path?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming every printed path exists or that no output means a filesystem error be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny reading-notes repository with the editor used for commit messages and the pager used for long output. Include one ordinary case, one boundary and one deliberate failure caused by assuming every printed path exists or that no output means a filesystem error. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

GIT_ATTR_GLOBAL reports the resolved global gitattributes path, subject to environment and configuration rules. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is confusing it with the repository .gitattributes file. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Classify system, global and repository attribute scopes before inspecting rules.

For the GIT_ATTR_GLOBAL reports the per-user attributes path chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on confusing it with the repository .gitattributes file. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git var GIT_ATTR_GLOBAL

Four purposeful transfer cases

Case 1: science project. Explain the rule using system and global configuration paths checked without modifying them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA website. Transfer the rule using a sequence editor for an interactive rebase rehearsal. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family computer. Predict the rule using different environment and global settings resolved in a safe test shell. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library catalogue. Contrast the rule using automation that requests one logical variable and validates exit status. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers confusing it with the repository .gitattributes file.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Classify system, global and repository attribute scopes before inspecting rules.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from GIT_ATTR_GLOBAL reports the per-user attributes path?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing confusing it with the repository .gitattributes file be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science project with system and global configuration paths checked without modifying them. Include one ordinary case, one boundary and one deliberate failure caused by confusing it with the repository .gitattributes file. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For GIT_ATTR_GLOBAL reports the per-user attributes path, separate the documented Git var mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

GIT_CONFIG_SYSTEM identifies the system configuration file path when that source is enabled. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is opening or editing the file merely because its path was printed. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Treat the query as discovery, then use git config with an explicit scope for supported reads or writes.

For the GIT_CONFIG_SYSTEM reports the system config path chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on opening or editing the file merely because its path was printed. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git var GIT_CONFIG_SYSTEM

Four purposeful transfer cases

Case 1: family computer. Transfer the rule using different environment and global settings resolved in a safe test shell. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library catalogue. Predict the rule using automation that requests one logical variable and validates exit status. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Contrast the rule using temporary HOME, repository config, environment precedence and disabled path cases. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Stress-test the rule using git var compared with git config get, environment inspection and shell lookup. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers opening or editing the file merely because its path was printed.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Treat the query as discovery, then use git config with an explicit scope for supported reads or writes.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from GIT_CONFIG_SYSTEM reports the system config path?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing opening or editing the file merely because its path was printed be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA website with a sequence editor for an interactive rebase rehearsal. Include one ordinary case, one boundary and one deliberate failure caused by opening or editing the file merely because its path was printed. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

GIT_CONFIG_GLOBAL can contain multiple newline-separated paths ordered from highest to lowest priority. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is assuming every logical path variable is exactly one line. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Read output line by line and preserve ordering rather than trimming it into one filename.

For the GIT_CONFIG_GLOBAL may contain several paths chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming every logical path variable is exactly one line. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git var GIT_CONFIG_GLOBAL

Four purposeful transfer cases

Case 1: test laboratory. Predict the rule using temporary HOME, repository config, environment precedence and disabled path cases. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Contrast the rule using git var compared with git config get, environment inspection and shell lookup. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework repository. Stress-test the rule using the author identity and first branch name used in a disposable project. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading-notes repository. Explain the rule using the editor used for commit messages and the pager used for long output. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers assuming every logical path variable is exactly one line.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Read output line by line and preserve ordering rather than trimming it into one filename.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from GIT_CONFIG_GLOBAL may contain several paths?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming every logical path variable is exactly one line be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family computer with different environment and global settings resolved in a safe test shell. Include one ordinary case, one boundary and one deliberate failure caused by assuming every logical path variable is exactly one line. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

Path variables are not printed when their source is disabled by the relevant environment mechanism, even though ordinary defaults might otherwise identify a path. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is turning a no-value result into a fabricated default path. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Check exit status and leave the value absent when Git says the source is disabled.

For the Disabled path sources can have no value chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on turning a no-value result into a fabricated default path. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

GIT_CONFIG_NOSYSTEM=1 git var GIT_CONFIG_SYSTEM

Four purposeful transfer cases

Case 1: homework repository. Contrast the rule using the author identity and first branch name used in a disposable project. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: reading-notes repository. Stress-test the rule using the editor used for commit messages and the pager used for long output. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: science project. Explain the rule using system and global configuration paths checked without modifying them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: CCA website. Transfer the rule using a sequence editor for an interactive rebase rehearsal. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers turning a no-value result into a fabricated default path.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Check exit status and leave the value absent when Git says the source is disabled.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from Disabled path sources can have no value?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing turning a no-value result into a fabricated default path be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library catalogue with automation that requests one logical variable and validates exit status. Include one ordinary case, one boundary and one deliberate failure caused by turning a no-value result into a fabricated default path. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Disabled path sources can have no value, separate the documented Git var mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

git var -l displays logical variables and also configuration variables, but using it to list configuration is deprecated in favour of git config list. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is building a configuration parser around the legacy mixed listing. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use git var for named logical variables and git config list for configuration enumeration.

For the The -l listing is not a config-list replacement chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on building a configuration parser around the legacy mixed listing. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git var -l
git config list

Four purposeful transfer cases

Case 1: science project. Stress-test the rule using system and global configuration paths checked without modifying them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: CCA website. Explain the rule using a sequence editor for an interactive rebase rehearsal. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: family computer. Transfer the rule using different environment and global settings resolved in a safe test shell. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: library catalogue. Predict the rule using automation that requests one logical variable and validates exit status. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers building a configuration parser around the legacy mixed listing.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Use git var for named logical variables and git config list for configuration enumeration.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from The -l listing is not a config-list replacement?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing building a configuration parser around the legacy mixed listing be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny test laboratory with temporary HOME, repository config, environment precedence and disabled path cases. Include one ordinary case, one boundary and one deliberate failure caused by building a configuration parser around the legacy mixed listing. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For The -l listing is not a config-list replacement, separate the documented Git var mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

git var does not modify the repository, but scripts can still mis-handle newlines, shell commands, identities or absent values. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is using command substitution without quoting and feeding the result into eval. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Quote captured data, validate status and never execute returned command strings unless that execution is truly intended.

For the Read-only queries still need safe parsing chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using command substitution without quoting and feeding the result into eval. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

editor=$(git var GIT_EDITOR) || exit 1
printf '%s
' "$editor"

Four purposeful transfer cases

Case 1: family computer. Explain the rule using different environment and global settings resolved in a safe test shell. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: library catalogue. Transfer the rule using automation that requests one logical variable and validates exit status. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: test laboratory. Predict the rule using temporary HOME, repository config, environment precedence and disabled path cases. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: design decision. Contrast the rule using git var compared with git config get, environment inspection and shell lookup. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers using command substitution without quoting and feeding the result into eval.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Quote captured data, validate status and never execute returned command strings unless that execution is truly intended.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from Read-only queries still need safe parsing?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using command substitution without quoting and feeding the result into eval be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny design decision with git var compared with git config get, environment inspection and shell lookup. Include one ordinary case, one boundary and one deliberate failure caused by using command substitution without quoting and feeding the result into eval. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Read-only queries still need safe parsing, separate the documented Git var mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

Use git var when Git resolved identity, editor, pager, default branch, shell or path is the question; use git config for config keys and ordinary shell tools for unrelated environment values. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is treating git var as a universal discovery command for every Git setting. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Name the semantic question first, then choose the interface whose output contract directly answers it.

For the Choose git var only for documented logical jobs chapter on Git var, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on treating git var as a universal discovery command for every Git setting. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

git var GIT_DEFAULT_BRANCH
git config get init.defaultBranch

Four purposeful transfer cases

Case 1: test laboratory. Transfer the rule using temporary HOME, repository config, environment precedence and disabled path cases. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 2: design decision. Predict the rule using git var compared with git config get, environment inspection and shell lookup. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 3: homework repository. Contrast the rule using the author identity and first branch name used in a disposable project. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Case 4: reading-notes repository. Stress-test the rule using the editor used for commit messages and the pager used for long output. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers treating git var as a universal discovery command for every Git setting.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Name the semantic question first, then choose the interface whose output contract directly answers it.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final Git var syntax. For this chapter, useful prompts are: “What did you expect from Choose git var only for documented logical jobs?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating git var as a universal discovery command for every Git setting be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework repository with the author identity and first branch name used in a disposable project. Include one ordinary case, one boundary and one deliberate failure caused by treating git var as a universal discovery command for every Git setting. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Choose git var only for documented logical jobs, separate the documented Git var mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

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

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

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

1. homework repository: model, boundary and recovery

Create a small homework repository using the author identity and first branch name used in a disposable project. Combine “git var prints a logical variable” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

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

Create a small reading-notes repository using the editor used for commit messages and the pager used for long output. Combine “GIT_AUTHOR_IDENT is a complete ident” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

3. science project: model, boundary and recovery

Create a small science project using system and global configuration paths checked without modifying them. Combine “GIT_EDITOR is the resolved editor command” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

4. CCA website: model, boundary and recovery

Create a small CCA website using a sequence editor for an interactive rebase rehearsal. Combine “GIT_PAGER is a resolved viewer command” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

5. family computer: model, boundary and recovery

Create a small family computer using different environment and global settings resolved in a safe test shell. Combine “GIT_ATTR_SYSTEM reports the system attributes path” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

6. library catalogue: model, boundary and recovery

Create a small library catalogue using automation that requests one logical variable and validates exit status. Combine “GIT_CONFIG_GLOBAL may contain several paths” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

7. test laboratory: model, boundary and recovery

Create a small test laboratory using temporary HOME, repository config, environment precedence and disabled path cases. Combine “Read-only queries still need safe parsing” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

8. design decision: model, boundary and recovery

Create a small design decision using git var compared with git config get, environment inspection and shell lookup. Combine “Use the documented command shape” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Frequently asked questions

How long should a practice session be?

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

Should every option or function be memorised?

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

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

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

Is the shortest solution the best?

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

When should official documentation be used?

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

How can a parent help without technical expertise?

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

How do we test transfer?

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

What should be saved after practice?

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

Can these exercises replace backups?

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

What counts as mastery?

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

Official and supporting references

• Primary technical documentation for Git var
• eduKatePunggol: How Studying Works

Return to contents