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 check-ref-format validates whether a proposed reference or branch name follows Git refname rules before a script tries to create or store it. Mastery means distinguishing a full ref from a branch shorthand, knowing why revision operators and shell-hostile characters are refused, using –branch for branch-facing input, treating @{-n} expansion carefully, using –normalize and –refspec-pattern only for their documented jobs, checking exit status, and letting higher-level Git commands enforce the final operation. This guide begins with that mechanism, then develops it through worked traces, deliberate mistakes, explained practice and transfer decisions.
The aim is independent reasoning. A learner should be able to predict behaviour, locate the earliest wrong assumption, use a safe diagnostic procedure and defend a design choice in a new project.
Punggol families can use the guide in short sessions around homework, CCAs and rest. The activities are proposed learning exercises, not claims about a physical branch, timetable, class size, fee, school relationship or guaranteed result.
Use disposable data and repositories, preserve backups, and check version-sensitive details against the official source. Current documentation settles a technical contract; observation and explanation turn that contract into usable knowledge.
Find your next learning step
Choose the route that matches the present difficulty. Use the complete index for a systematic course.
Build the model
Chapters 1-4 . Begin here, then continue after the learner can predict, verify and explain.
Use the core tools
Chapters 5-8 . Begin here, then continue after the learner can predict, verify and explain.
Handle boundaries
Chapters 9-12 . Begin here, then continue after the learner can predict, verify and explain.
Debug and verify
Chapters 13-16 . Begin here, then continue after the learner can predict, verify and explain.
Transfer with judgment
Chapters 17-20 . Begin here, then continue after the learner can predict, verify and explain.
Open the full chapter index . Jump to capstone practice . Use the How Studying Works hub . Read the official documentation
Complete chapter index
Chapters 1-4 . Build the model
Chapters 5-8 . Use the core tools
Chapters 9-12 . Handle boundaries
Chapters 13-16 . Debug and verify
branches and tags are references commonly stored under refs/heads and refs/tags, so a full ref name includes its namespace rather than only a friendly branch word. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is calling main a complete ref name in every API. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Label user branch input and stored full ref as separate fields.
For the Git refs live in named hierarchies chapter on Git check-ref-format, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on calling main a complete ref name in every API. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
name=main
full=refs/heads/mainExplained result. main is a branch-facing name while refs/heads/main is the corresponding full reference path. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: coding assignment. Predict the rule using a packaging script validates a student-supplied branch name before creating it. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “branches and tags are references commonly stored under refs/heads and refs/tags, so a full ref name includes its namespace rather than only a friendly branch word.” Apply this procedure: Label user branch input and stored full ref as separate fields. The expected mechanism is: main is a branch-facing name while refs/heads/main is the corresponding full reference path. For the coding assignment, add one near-miss that exposes calling main a complete ref name in every API. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: group website. Contrast the rule using a release tool maps a safe label into refs/tags without inventing punctuation rules. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “branches and tags are references commonly stored under refs/heads and refs/tags, so a full ref name includes its namespace rather than only a friendly branch word.” Apply this procedure: Label user branch input and stored full ref as separate fields. The expected mechanism is: main is a branch-facing name while refs/heads/main is the corresponding full reference path. For the group website, add one near-miss that exposes calling main a complete ref name in every API. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: CCA repository. Stress-test the rule using feature branches follow one readable hierarchy and reject ambiguous names. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “branches and tags are references commonly stored under refs/heads and refs/tags, so a full ref name includes its namespace rather than only a friendly branch word.” Apply this procedure: Label user branch input and stored full ref as separate fields. The expected mechanism is: main is a branch-facing name while refs/heads/main is the corresponding full reference path. For the CCA repository, add one near-miss that exposes calling main a complete ref name in every API. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: science pipeline. Explain the rule using generated refs are normalized and verified before update-ref. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “branches and tags are references commonly stored under refs/heads and refs/tags, so a full ref name includes its namespace rather than only a friendly branch word.” Apply this procedure: Label user branch input and stored full ref as separate fields. The expected mechanism is: main is a branch-facing name while refs/heads/main is the corresponding full reference path. For the science pipeline, add one near-miss that exposes calling main a complete ref name in every API. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers calling main a complete ref name in every API.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Label user branch input and stored full ref as separate fields.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from Git refs live in named hierarchies?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing calling main a complete ref name in every API be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny refspec laboratory with one wildcard pattern is accepted only in the pattern-validation mode. Include one ordinary case, one boundary and one deliberate failure caused by calling main a complete ref name in every API. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: branches and tags are references commonly stored under refs/heads and refs/tags, so a full ref name includes its namespace rather than only a friendly branch word. It shows a trace, not only a final value. The ordinary case should demonstrate “main is a branch-facing name while refs/heads/main is the corresponding full reference path.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Label user branch input and stored full ref as separate fields. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Git refs live in named hierarchies, separate the documented Git check-ref-format mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
without –allow-onelevel, check-ref-format requires at least one slash so the name includes a category-like component. 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 validating main as though it were a default full ref. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use –branch for branch names or prepend the intended refs namespace before full-ref validation.
For the A normal full ref needs more than one component chapter on Git check-ref-format, 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 validating main as though it were a default full ref. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format refs/heads/mainExplained result. The namespaced ref contains the required slash and can satisfy the ordinary structural rule. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: CCA repository. Contrast the rule using feature branches follow one readable hierarchy and reject ambiguous names. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “without –allow-onelevel, check-ref-format requires at least one slash so the name includes a category-like component.” Apply this procedure: Use –branch for branch names or prepend the intended refs namespace before full-ref validation. The expected mechanism is: The namespaced ref contains the required slash and can satisfy the ordinary structural rule. For the CCA repository, add one near-miss that exposes validating main as though it were a default full ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: science pipeline. Stress-test the rule using generated refs are normalized and verified before update-ref. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “without –allow-onelevel, check-ref-format requires at least one slash so the name includes a category-like component.” Apply this procedure: Use –branch for branch names or prepend the intended refs namespace before full-ref validation. The expected mechanism is: The namespaced ref contains the required slash and can satisfy the ordinary structural rule. For the science pipeline, add one near-miss that exposes validating main as though it were a default full ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family project. Explain the rule using previous-checkout shorthand is tested in attached and detached states. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “without –allow-onelevel, check-ref-format requires at least one slash so the name includes a category-like component.” Apply this procedure: Use –branch for branch names or prepend the intended refs namespace before full-ref validation. The expected mechanism is: The namespaced ref contains the required slash and can satisfy the ordinary structural rule. For the family project, add one near-miss that exposes validating main as though it were a default full ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: refspec laboratory. Transfer the rule using one wildcard pattern is accepted only in the pattern-validation mode. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “without –allow-onelevel, check-ref-format requires at least one slash so the name includes a category-like component.” Apply this procedure: Use –branch for branch names or prepend the intended refs namespace before full-ref validation. The expected mechanism is: The namespaced ref contains the required slash and can satisfy the ordinary structural rule. For the refspec laboratory, add one near-miss that exposes validating main as though it were a default full ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers validating main as though it were a default full ref.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Use –branch for branch names or prepend the intended refs namespace before full-ref validation.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from A normal full ref needs more than one component?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing validating main as though it were a default full ref be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny shell-safety fixture with spaces, metacharacters and option-like inputs are quoted and rejected correctly. Include one ordinary case, one boundary and one deliberate failure caused by validating main as though it were a default full ref. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: without –allow-onelevel, check-ref-format requires at least one slash so the name includes a category-like component. It shows a trace, not only a final value. The ordinary case should demonstrate “The namespaced ref contains the required slash and can satisfy the ordinary structural rule.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use –branch for branch names or prepend the intended refs namespace before full-ref validation. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For A normal full ref needs more than one component, separate the documented Git check-ref-format 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
no slash-separated refname component may begin with a dot, preventing hidden-looking and ambiguous path components. 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 the first character of the whole ref. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Split on slashes and test every component.
For the Components cannot begin with a dot chapter on Git check-ref-format, 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 the first character of the whole ref. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format refs/heads/.draftExplained result. The command fails because the final component begins with a dot. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family project. Stress-test the rule using previous-checkout shorthand is tested in attached and detached states. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “no slash-separated refname component may begin with a dot, preventing hidden-looking and ambiguous path components.” Apply this procedure: Split on slashes and test every component. The expected mechanism is: The command fails because the final component begins with a dot. For the family project, add one near-miss that exposes checking only the first character of the whole ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: refspec laboratory. Explain the rule using one wildcard pattern is accepted only in the pattern-validation mode. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “no slash-separated refname component may begin with a dot, preventing hidden-looking and ambiguous path components.” Apply this procedure: Split on slashes and test every component. The expected mechanism is: The command fails because the final component begins with a dot. For the refspec laboratory, add one near-miss that exposes checking only the first character of the whole ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: shell-safety fixture. Transfer the rule using spaces, metacharacters and option-like inputs are quoted and rejected correctly. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “no slash-separated refname component may begin with a dot, preventing hidden-looking and ambiguous path components.” Apply this procedure: Split on slashes and test every component. The expected mechanism is: The command fails because the final component begins with a dot. For the shell-safety fixture, add one near-miss that exposes checking only the first character of the whole ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: workflow decision. Predict the rule using check-ref-format, switch, branch and update-ref responsibilities are separated. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “no slash-separated refname component may begin with a dot, preventing hidden-looking and ambiguous path components.” Apply this procedure: Split on slashes and test every component. The expected mechanism is: The command fails because the final component begins with a dot. For the workflow decision, add one near-miss that exposes checking only the first character of the whole ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers checking only the first character of the whole ref.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Split on slashes and test every component.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from Components cannot begin with a dot?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing checking only the first character of the whole ref be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny workflow decision with check-ref-format, switch, branch and update-ref responsibilities are separated. Include one ordinary case, one boundary and one deliberate failure caused by checking only the first character of the whole ref. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: no slash-separated refname component may begin with a dot, preventing hidden-looking and ambiguous path components. It shows a trace, not only a final value. The ordinary case should demonstrate “The command fails because the final component begins with a dot.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Split on slashes and test every component. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Components cannot begin with a dot, separate the documented Git check-ref-format mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
a refname component ending in .lock is forbidden because it conflicts with lockfile conventions used for safe reference updates. 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 removing .lock only from the end of the complete string. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Inspect every component in a hierarchical name.
For the Components cannot end with .lock chapter on Git check-ref-format, 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 removing .lock only from the end of the complete string. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format refs/heads/topic.lockExplained result. The proposed ref is rejected rather than colliding conceptually with Git lock handling. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: shell-safety fixture. Explain the rule using spaces, metacharacters and option-like inputs are quoted and rejected correctly. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a refname component ending in .lock is forbidden because it conflicts with lockfile conventions used for safe reference updates.” Apply this procedure: Inspect every component in a hierarchical name. The expected mechanism is: The proposed ref is rejected rather than colliding conceptually with Git lock handling. For the shell-safety fixture, add one near-miss that exposes removing .lock only from the end of the complete string. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: workflow decision. Transfer the rule using check-ref-format, switch, branch and update-ref responsibilities are separated. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a refname component ending in .lock is forbidden because it conflicts with lockfile conventions used for safe reference updates.” Apply this procedure: Inspect every component in a hierarchical name. The expected mechanism is: The proposed ref is rejected rather than colliding conceptually with Git lock handling. For the workflow decision, add one near-miss that exposes removing .lock only from the end of the complete string. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: coding assignment. Predict the rule using a packaging script validates a student-supplied branch name before creating it. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a refname component ending in .lock is forbidden because it conflicts with lockfile conventions used for safe reference updates.” Apply this procedure: Inspect every component in a hierarchical name. The expected mechanism is: The proposed ref is rejected rather than colliding conceptually with Git lock handling. For the coding assignment, add one near-miss that exposes removing .lock only from the end of the complete string. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: group website. Contrast the rule using a release tool maps a safe label into refs/tags without inventing punctuation rules. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a refname component ending in .lock is forbidden because it conflicts with lockfile conventions used for safe reference updates.” Apply this procedure: Inspect every component in a hierarchical name. The expected mechanism is: The proposed ref is rejected rather than colliding conceptually with Git lock handling. For the group website, add one near-miss that exposes removing .lock only from the end of the complete string. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers removing .lock only from the end of the complete string.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Inspect every component in a hierarchical name.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from Components cannot end with .lock?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing removing .lock only from the end of the complete string be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny coding assignment with a packaging script validates a student-supplied branch name before creating it. Include one ordinary case, one boundary and one deliberate failure caused by removing .lock only from the end of the complete string. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: a refname component ending in .lock is forbidden because it conflicts with lockfile conventions used for safe reference updates. It shows a trace, not only a final value. The ordinary case should demonstrate “The proposed ref is rejected rather than colliding conceptually with Git lock handling.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Inspect every component in a hierarchical name. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Components cannot end with .lock, separate the documented Git check-ref-format 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 .. is not allowed anywhere in a refname because it overlaps revision-range syntax and creates ambiguity. 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 accepting two dots when they appear inside a longer word. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Search the complete candidate for the exact sequence before creation.
For the Two consecutive dots are forbidden chapter on Git check-ref-format, 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 accepting two dots when they appear inside a longer word. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format refs/heads/week1..week2Explained result. The command returns a nonzero status because the range-like sequence is invalid in a ref name. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: coding assignment. Transfer the rule using a packaging script validates a student-supplied branch name before creating it. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the sequence .. is not allowed anywhere in a refname because it overlaps revision-range syntax and creates ambiguity.” Apply this procedure: Search the complete candidate for the exact sequence before creation. The expected mechanism is: The command returns a nonzero status because the range-like sequence is invalid in a ref name. For the coding assignment, add one near-miss that exposes accepting two dots when they appear inside a longer word. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: group website. Predict the rule using a release tool maps a safe label into refs/tags without inventing punctuation rules. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the sequence .. is not allowed anywhere in a refname because it overlaps revision-range syntax and creates ambiguity.” Apply this procedure: Search the complete candidate for the exact sequence before creation. The expected mechanism is: The command returns a nonzero status because the range-like sequence is invalid in a ref name. For the group website, add one near-miss that exposes accepting two dots when they appear inside a longer word. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: CCA repository. Contrast the rule using feature branches follow one readable hierarchy and reject ambiguous names. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the sequence .. is not allowed anywhere in a refname because it overlaps revision-range syntax and creates ambiguity.” Apply this procedure: Search the complete candidate for the exact sequence before creation. The expected mechanism is: The command returns a nonzero status because the range-like sequence is invalid in a ref name. For the CCA repository, add one near-miss that exposes accepting two dots when they appear inside a longer word. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: science pipeline. Stress-test the rule using generated refs are normalized and verified before update-ref. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the sequence .. is not allowed anywhere in a refname because it overlaps revision-range syntax and creates ambiguity.” Apply this procedure: Search the complete candidate for the exact sequence before creation. The expected mechanism is: The command returns a nonzero status because the range-like sequence is invalid in a ref name. For the science pipeline, add one near-miss that exposes accepting two dots when they appear inside a longer word. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers accepting two dots when they appear inside a longer word.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Search the complete candidate for the exact sequence before creation.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from Two consecutive dots are forbidden?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing accepting two dots when they appear inside a longer word be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny group website with a release tool maps a safe label into refs/tags without inventing punctuation rules. Include one ordinary case, one boundary and one deliberate failure caused by accepting two dots when they appear inside a longer word. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: the sequence .. is not allowed anywhere in a refname because it overlaps revision-range syntax and creates ambiguity. It shows a trace, not only a final value. The ordinary case should demonstrate “The command returns a nonzero status because the range-like sequence is invalid in a ref name.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Search the complete candidate for the exact sequence before creation. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Two consecutive dots are forbidden, separate the documented Git check-ref-format 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
ASCII control characters, DEL and spaces cannot appear in refnames, protecting parsing and command-line handling. 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 trimming visible spaces and ignoring embedded or nonprinting characters. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test raw input bytes and let Git decide validity after shell-safe quoting.
For the Control characters and spaces are forbidden chapter on Git check-ref-format, 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 trimming visible spaces and ignoring embedded or nonprinting characters. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format "refs/heads/my topic"Explained result. The embedded space causes validation to fail. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: CCA repository. Predict the rule using feature branches follow one readable hierarchy and reject ambiguous names. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “ASCII control characters, DEL and spaces cannot appear in refnames, protecting parsing and command-line handling.” Apply this procedure: Test raw input bytes and let Git decide validity after shell-safe quoting. The expected mechanism is: The embedded space causes validation to fail. For the CCA repository, add one near-miss that exposes trimming visible spaces and ignoring embedded or nonprinting characters. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: science pipeline. Contrast the rule using generated refs are normalized and verified before update-ref. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “ASCII control characters, DEL and spaces cannot appear in refnames, protecting parsing and command-line handling.” Apply this procedure: Test raw input bytes and let Git decide validity after shell-safe quoting. The expected mechanism is: The embedded space causes validation to fail. For the science pipeline, add one near-miss that exposes trimming visible spaces and ignoring embedded or nonprinting characters. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family project. Stress-test the rule using previous-checkout shorthand is tested in attached and detached states. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “ASCII control characters, DEL and spaces cannot appear in refnames, protecting parsing and command-line handling.” Apply this procedure: Test raw input bytes and let Git decide validity after shell-safe quoting. The expected mechanism is: The embedded space causes validation to fail. For the family project, add one near-miss that exposes trimming visible spaces and ignoring embedded or nonprinting characters. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: refspec laboratory. Explain the rule using one wildcard pattern is accepted only in the pattern-validation mode. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “ASCII control characters, DEL and spaces cannot appear in refnames, protecting parsing and command-line handling.” Apply this procedure: Test raw input bytes and let Git decide validity after shell-safe quoting. The expected mechanism is: The embedded space causes validation to fail. For the refspec laboratory, add one near-miss that exposes trimming visible spaces and ignoring embedded or nonprinting characters. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers trimming visible spaces and ignoring embedded or nonprinting characters.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Test raw input bytes and let Git decide validity after shell-safe quoting.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from Control characters and spaces are forbidden?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing trimming visible spaces and ignoring embedded or nonprinting characters be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny CCA repository with feature branches follow one readable hierarchy and reject ambiguous names. Include one ordinary case, one boundary and one deliberate failure caused by trimming visible spaces and ignoring embedded or nonprinting characters. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: ASCII control characters, DEL and spaces cannot appear in refnames, protecting parsing and command-line handling. It shows a trace, not only a final value. The ordinary case should demonstrate “The embedded space causes validation to fail.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Test raw input bytes and let Git decide validity after shell-safe quoting. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Control characters and spaces are forbidden, separate the documented Git check-ref-format 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 characters ~, ^ and : are forbidden because Git revision and refspec expressions give them other meanings. 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 allowing punctuation merely because the filesystem accepts it. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compare each candidate with the documented revision grammar.
For the Tilde caret and colon are revision operators chapter on Git check-ref-format, 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 allowing punctuation merely because the filesystem accepts it. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format refs/heads/base^2Explained result. The caret makes the candidate invalid as a ref name rather than being treated as decoration. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family project. Contrast the rule using previous-checkout shorthand is tested in attached and detached states. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the characters ~, ^ and : are forbidden because Git revision and refspec expressions give them other meanings.” Apply this procedure: Compare each candidate with the documented revision grammar. The expected mechanism is: The caret makes the candidate invalid as a ref name rather than being treated as decoration. For the family project, add one near-miss that exposes allowing punctuation merely because the filesystem accepts it. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: refspec laboratory. Stress-test the rule using one wildcard pattern is accepted only in the pattern-validation mode. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the characters ~, ^ and : are forbidden because Git revision and refspec expressions give them other meanings.” Apply this procedure: Compare each candidate with the documented revision grammar. The expected mechanism is: The caret makes the candidate invalid as a ref name rather than being treated as decoration. For the refspec laboratory, add one near-miss that exposes allowing punctuation merely because the filesystem accepts it. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: shell-safety fixture. Explain the rule using spaces, metacharacters and option-like inputs are quoted and rejected correctly. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the characters ~, ^ and : are forbidden because Git revision and refspec expressions give them other meanings.” Apply this procedure: Compare each candidate with the documented revision grammar. The expected mechanism is: The caret makes the candidate invalid as a ref name rather than being treated as decoration. For the shell-safety fixture, add one near-miss that exposes allowing punctuation merely because the filesystem accepts it. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: workflow decision. Transfer the rule using check-ref-format, switch, branch and update-ref responsibilities are separated. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the characters ~, ^ and : are forbidden because Git revision and refspec expressions give them other meanings.” Apply this procedure: Compare each candidate with the documented revision grammar. The expected mechanism is: The caret makes the candidate invalid as a ref name rather than being treated as decoration. For the workflow decision, add one near-miss that exposes allowing punctuation merely because the filesystem accepts it. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers allowing punctuation merely because the filesystem accepts it.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Compare each candidate with the documented revision grammar.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from Tilde caret and colon are revision operators?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing allowing punctuation merely because the filesystem accepts it be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny science pipeline with generated refs are normalized and verified before update-ref. Include one ordinary case, one boundary and one deliberate failure caused by allowing punctuation merely because the filesystem accepts it. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: the characters ~, ^ and : are forbidden because Git revision and refspec expressions give them other meanings. It shows a trace, not only a final value. The ordinary case should demonstrate “The caret makes the candidate invalid as a ref name rather than being treated as decoration.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Compare each candidate with the documented revision grammar. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Tilde caret and colon are revision operators, separate the documented Git check-ref-format mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 8 OF 20 . Use the core tools
8. Question mark asterisk and bracket are normally forbidden
?, * and [ are excluded from ordinary refnames because glob and pattern languages use them, with one documented wildcard exception for refspec patterns. 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 validating a wildcard pattern in ordinary ref mode. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Choose ordinary-name or refspec-pattern validation before invoking the command.
For the Question mark asterisk and bracket are normally forbidden chapter on Git check-ref-format, 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 validating a wildcard pattern in ordinary ref mode. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format refs/heads/topic*Explained result. The ordinary refname check fails because asterisk is not allowed in this mode. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: shell-safety fixture. Stress-test the rule using spaces, metacharacters and option-like inputs are quoted and rejected correctly. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “?, * and [ are excluded from ordinary refnames because glob and pattern languages use them, with one documented wildcard exception for refspec patterns.” Apply this procedure: Choose ordinary-name or refspec-pattern validation before invoking the command. The expected mechanism is: The ordinary refname check fails because asterisk is not allowed in this mode. For the shell-safety fixture, add one near-miss that exposes validating a wildcard pattern in ordinary ref mode. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: workflow decision. Explain the rule using check-ref-format, switch, branch and update-ref responsibilities are separated. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “?, * and [ are excluded from ordinary refnames because glob and pattern languages use them, with one documented wildcard exception for refspec patterns.” Apply this procedure: Choose ordinary-name or refspec-pattern validation before invoking the command. The expected mechanism is: The ordinary refname check fails because asterisk is not allowed in this mode. For the workflow decision, add one near-miss that exposes validating a wildcard pattern in ordinary ref mode. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: coding assignment. Transfer the rule using a packaging script validates a student-supplied branch name before creating it. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “?, * and [ are excluded from ordinary refnames because glob and pattern languages use them, with one documented wildcard exception for refspec patterns.” Apply this procedure: Choose ordinary-name or refspec-pattern validation before invoking the command. The expected mechanism is: The ordinary refname check fails because asterisk is not allowed in this mode. For the coding assignment, add one near-miss that exposes validating a wildcard pattern in ordinary ref mode. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: group website. Predict the rule using a release tool maps a safe label into refs/tags without inventing punctuation rules. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “?, * and [ are excluded from ordinary refnames because glob and pattern languages use them, with one documented wildcard exception for refspec patterns.” Apply this procedure: Choose ordinary-name or refspec-pattern validation before invoking the command. The expected mechanism is: The ordinary refname check fails because asterisk is not allowed in this mode. For the group website, add one near-miss that exposes validating a wildcard pattern in ordinary ref mode. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers validating a wildcard pattern in ordinary ref mode.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Choose ordinary-name or refspec-pattern validation before invoking the command.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Git check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from Question mark asterisk and bracket are normally forbidden?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing validating a wildcard pattern in ordinary ref mode be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny family project with previous-checkout shorthand is tested in attached and detached states. Include one ordinary case, one boundary and one deliberate failure caused by validating a wildcard pattern in ordinary ref mode. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: ?, * and [ are excluded from ordinary refnames because glob and pattern languages use them, with one documented wildcard exception for refspec patterns. It shows a trace, not only a final value. The ordinary case should demonstrate “The ordinary refname check fails because asterisk is not allowed in this mode.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Choose ordinary-name or refspec-pattern validation before invoking the command. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Question mark asterisk and bracket are normally forbidden, separate the documented Git check-ref-format mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
a refname cannot begin or end with slash or contain repeated consecutive slashes in ordinary validation. 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 collapsing slashes silently in every user-facing branch name. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Reject unexpected structure unless normalization is explicitly part of the contract.
For the Slashes need clean boundaries chapter on Git check-ref-format, 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 collapsing slashes silently in every user-facing branch name. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format refs//heads/mainExplained result. The repeated slash causes ordinary validation to fail. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: coding assignment. Explain the rule using a packaging script validates a student-supplied branch name before creating it. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a refname cannot begin or end with slash or contain repeated consecutive slashes in ordinary validation.” Apply this procedure: Reject unexpected structure unless normalization is explicitly part of the contract. The expected mechanism is: The repeated slash causes ordinary validation to fail. For the coding assignment, add one near-miss that exposes collapsing slashes silently in every user-facing branch name. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: group website. Transfer the rule using a release tool maps a safe label into refs/tags without inventing punctuation rules. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a refname cannot begin or end with slash or contain repeated consecutive slashes in ordinary validation.” Apply this procedure: Reject unexpected structure unless normalization is explicitly part of the contract. The expected mechanism is: The repeated slash causes ordinary validation to fail. For the group website, add one near-miss that exposes collapsing slashes silently in every user-facing branch name. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: CCA repository. Predict the rule using feature branches follow one readable hierarchy and reject ambiguous names. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a refname cannot begin or end with slash or contain repeated consecutive slashes in ordinary validation.” Apply this procedure: Reject unexpected structure unless normalization is explicitly part of the contract. The expected mechanism is: The repeated slash causes ordinary validation to fail. For the CCA repository, add one near-miss that exposes collapsing slashes silently in every user-facing branch name. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: science pipeline. Contrast the rule using generated refs are normalized and verified before update-ref. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a refname cannot begin or end with slash or contain repeated consecutive slashes in ordinary validation.” Apply this procedure: Reject unexpected structure unless normalization is explicitly part of the contract. The expected mechanism is: The repeated slash causes ordinary validation to fail. For the science pipeline, add one near-miss that exposes collapsing slashes silently in every user-facing branch name. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers collapsing slashes silently in every user-facing branch name.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Reject unexpected structure unless normalization is explicitly part of the contract.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from Slashes need clean boundaries?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing collapsing slashes silently in every user-facing branch name be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny refspec laboratory with one wildcard pattern is accepted only in the pattern-validation mode. Include one ordinary case, one boundary and one deliberate failure caused by collapsing slashes silently in every user-facing branch name. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: a refname cannot begin or end with slash or contain repeated consecutive slashes in ordinary validation. It shows a trace, not only a final value. The ordinary case should demonstrate “The repeated slash causes ordinary validation to fail.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Reject unexpected structure unless normalization is explicitly part of the contract. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Slashes need clean boundaries, separate the documented Git check-ref-format mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
a trailing dot is forbidden even when the preceding component otherwise looks readable. 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 dot-leading components. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test both ends of every proposed full name.
For the A refname cannot end with a dot chapter on Git check-ref-format, 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 dot-leading components. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format refs/heads/release.Explained result. The command rejects the trailing-dot refname. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: CCA repository. Transfer the rule using feature branches follow one readable hierarchy and reject ambiguous names. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a trailing dot is forbidden even when the preceding component otherwise looks readable.” Apply this procedure: Test both ends of every proposed full name. The expected mechanism is: The command rejects the trailing-dot refname. For the CCA repository, add one near-miss that exposes checking only dot-leading components. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: science pipeline. Predict the rule using generated refs are normalized and verified before update-ref. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a trailing dot is forbidden even when the preceding component otherwise looks readable.” Apply this procedure: Test both ends of every proposed full name. The expected mechanism is: The command rejects the trailing-dot refname. For the science pipeline, add one near-miss that exposes checking only dot-leading components. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family project. Contrast the rule using previous-checkout shorthand is tested in attached and detached states. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a trailing dot is forbidden even when the preceding component otherwise looks readable.” Apply this procedure: Test both ends of every proposed full name. The expected mechanism is: The command rejects the trailing-dot refname. For the family project, add one near-miss that exposes checking only dot-leading components. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: refspec laboratory. Stress-test the rule using one wildcard pattern is accepted only in the pattern-validation mode. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a trailing dot is forbidden even when the preceding component otherwise looks readable.” Apply this procedure: Test both ends of every proposed full name. The expected mechanism is: The command rejects the trailing-dot refname. For the refspec laboratory, add one near-miss that exposes checking only dot-leading components. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers checking only dot-leading components.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Test both ends of every proposed full name.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from A refname cannot end with a dot?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing checking only dot-leading components be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny shell-safety fixture with spaces, metacharacters and option-like inputs are quoted and rejected correctly. Include one ordinary case, one boundary and one deliberate failure caused by checking only dot-leading components. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: a trailing dot is forbidden even when the preceding component otherwise looks readable. It shows a trace, not only a final value. The ordinary case should demonstrate “The command rejects the trailing-dot refname.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Test both ends of every proposed full name. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For A refname cannot end with a dot, separate the documented Git check-ref-format 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
@{ cannot appear in a refname because Git uses it for reflog and related revision syntax. 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 allowing a timestamp-like label containing @{. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Keep human annotations outside the ref name or encode them with safe separators.
For the The sequence at-open-brace is reserved chapter on Git check-ref-format, 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 allowing a timestamp-like label containing @{. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format 'refs/heads/work@{today}'Explained result. The reserved sequence makes the proposed name invalid. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family project. Predict the rule using previous-checkout shorthand is tested in attached and detached states. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “@{ cannot appear in a refname because Git uses it for reflog and related revision syntax.” Apply this procedure: Keep human annotations outside the ref name or encode them with safe separators. The expected mechanism is: The reserved sequence makes the proposed name invalid. For the family project, add one near-miss that exposes allowing a timestamp-like label containing @{. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: refspec laboratory. Contrast the rule using one wildcard pattern is accepted only in the pattern-validation mode. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “@{ cannot appear in a refname because Git uses it for reflog and related revision syntax.” Apply this procedure: Keep human annotations outside the ref name or encode them with safe separators. The expected mechanism is: The reserved sequence makes the proposed name invalid. For the refspec laboratory, add one near-miss that exposes allowing a timestamp-like label containing @{. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: shell-safety fixture. Stress-test the rule using spaces, metacharacters and option-like inputs are quoted and rejected correctly. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “@{ cannot appear in a refname because Git uses it for reflog and related revision syntax.” Apply this procedure: Keep human annotations outside the ref name or encode them with safe separators. The expected mechanism is: The reserved sequence makes the proposed name invalid. For the shell-safety fixture, add one near-miss that exposes allowing a timestamp-like label containing @{. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: workflow decision. Explain the rule using check-ref-format, switch, branch and update-ref responsibilities are separated. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “@{ cannot appear in a refname because Git uses it for reflog and related revision syntax.” Apply this procedure: Keep human annotations outside the ref name or encode them with safe separators. The expected mechanism is: The reserved sequence makes the proposed name invalid. For the workflow decision, add one near-miss that exposes allowing a timestamp-like label containing @{. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers allowing a timestamp-like label containing @{.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Keep human annotations outside the ref name or encode them with safe separators.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from The sequence at-open-brace is reserved?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing allowing a timestamp-like label containing @{ be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny workflow decision with check-ref-format, switch, branch and update-ref responsibilities are separated. Include one ordinary case, one boundary and one deliberate failure caused by allowing a timestamp-like label containing @{. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: @{ cannot appear in a refname because Git uses it for reflog and related revision syntax. It shows a trace, not only a final value. The ordinary case should demonstrate “The reserved sequence makes the proposed name invalid.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Keep human annotations outside the ref name or encode them with safe separators. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For The sequence at-open-brace is reserved, separate the documented Git check-ref-format 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 one-character name @ is forbidden even though at signs may appear in other positions that do not create the reserved sequence. 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 generalizing the single-character rule into a ban on every at sign. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test the exact candidate with Git rather than maintaining an approximate regex.
For the A single at sign is not a ref name chapter on Git check-ref-format, 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 generalizing the single-character rule into a ban on every at sign. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format --allow-onelevel @Explained result. The command still rejects the single at sign. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: shell-safety fixture. Contrast the rule using spaces, metacharacters and option-like inputs are quoted and rejected correctly. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the one-character name @ is forbidden even though at signs may appear in other positions that do not create the reserved sequence.” Apply this procedure: Test the exact candidate with Git rather than maintaining an approximate regex. The expected mechanism is: The command still rejects the single at sign. For the shell-safety fixture, add one near-miss that exposes generalizing the single-character rule into a ban on every at sign. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: workflow decision. Stress-test the rule using check-ref-format, switch, branch and update-ref responsibilities are separated. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the one-character name @ is forbidden even though at signs may appear in other positions that do not create the reserved sequence.” Apply this procedure: Test the exact candidate with Git rather than maintaining an approximate regex. The expected mechanism is: The command still rejects the single at sign. For the workflow decision, add one near-miss that exposes generalizing the single-character rule into a ban on every at sign. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: coding assignment. Explain the rule using a packaging script validates a student-supplied branch name before creating it. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the one-character name @ is forbidden even though at signs may appear in other positions that do not create the reserved sequence.” Apply this procedure: Test the exact candidate with Git rather than maintaining an approximate regex. The expected mechanism is: The command still rejects the single at sign. For the coding assignment, add one near-miss that exposes generalizing the single-character rule into a ban on every at sign. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: group website. Transfer the rule using a release tool maps a safe label into refs/tags without inventing punctuation rules. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the one-character name @ is forbidden even though at signs may appear in other positions that do not create the reserved sequence.” Apply this procedure: Test the exact candidate with Git rather than maintaining an approximate regex. The expected mechanism is: The command still rejects the single at sign. For the group website, add one near-miss that exposes generalizing the single-character rule into a ban on every at sign. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers generalizing the single-character rule into a ban on every at sign.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Test the exact candidate with Git rather than maintaining an approximate regex.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from A single at sign is not a ref name?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing generalizing the single-character rule into a ban on every at sign be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny coding assignment with a packaging script validates a student-supplied branch name before creating it. Include one ordinary case, one boundary and one deliberate failure caused by generalizing the single-character rule into a ban on every at sign. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: the one-character name @ is forbidden even though at signs may appear in other positions that do not create the reserved sequence. It shows a trace, not only a final value. The ordinary case should demonstrate “The command still rejects the single at sign.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Test the exact candidate with Git rather than maintaining an approximate regex. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For A single at sign is not a ref name, separate the documented Git check-ref-format mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
a refname cannot contain backslash, avoiding platform and escape ambiguities. 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 backslash as an alternative hierarchy separator on Windows. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Always use Git ref syntax with forward slashes and quote shell input.
For the Backslash is forbidden chapter on Git check-ref-format, 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 backslash as an alternative hierarchy separator on Windows. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format 'refsheadsmain'Explained result. The backslash-containing candidate is invalid. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: coding assignment. Stress-test the rule using a packaging script validates a student-supplied branch name before creating it. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a refname cannot contain backslash, avoiding platform and escape ambiguities.” Apply this procedure: Always use Git ref syntax with forward slashes and quote shell input. The expected mechanism is: The backslash-containing candidate is invalid. For the coding assignment, add one near-miss that exposes treating backslash as an alternative hierarchy separator on Windows. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: group website. Explain the rule using a release tool maps a safe label into refs/tags without inventing punctuation rules. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a refname cannot contain backslash, avoiding platform and escape ambiguities.” Apply this procedure: Always use Git ref syntax with forward slashes and quote shell input. The expected mechanism is: The backslash-containing candidate is invalid. For the group website, add one near-miss that exposes treating backslash as an alternative hierarchy separator on Windows. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: CCA repository. Transfer the rule using feature branches follow one readable hierarchy and reject ambiguous names. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a refname cannot contain backslash, avoiding platform and escape ambiguities.” Apply this procedure: Always use Git ref syntax with forward slashes and quote shell input. The expected mechanism is: The backslash-containing candidate is invalid. For the CCA repository, add one near-miss that exposes treating backslash as an alternative hierarchy separator on Windows. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: science pipeline. Predict the rule using generated refs are normalized and verified before update-ref. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a refname cannot contain backslash, avoiding platform and escape ambiguities.” Apply this procedure: Always use Git ref syntax with forward slashes and quote shell input. The expected mechanism is: The backslash-containing candidate is invalid. For the science pipeline, add one near-miss that exposes treating backslash as an alternative hierarchy separator on Windows. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers treating backslash as an alternative hierarchy separator on Windows.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Always use Git ref syntax with forward slashes and quote shell input.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from Backslash is forbidden?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating backslash as an alternative hierarchy separator on Windows be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny group website with a release tool maps a safe label into refs/tags without inventing punctuation rules. Include one ordinary case, one boundary and one deliberate failure caused by treating backslash as an alternative hierarchy separator on Windows. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: a refname cannot contain backslash, avoiding platform and escape ambiguities. It shows a trace, not only a final value. The ordinary case should demonstrate “The backslash-containing candidate is invalid.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Always use Git ref syntax with forward slashes and quote shell input. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Backslash is forbidden, separate the documented Git check-ref-format 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
–branch applies branch-name validation and is stricter in relevant cases, including rejecting a leading dash that a full ref component rule alone might permit. 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 validating refs/heads/$name and assuming every accepted value is safe as a branch argument. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use –branch for names that a user will pass to branch-oriented porcelain.
For the –branch validates branch-facing input chapter on Git check-ref-format, 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 validating refs/heads/$name and assuming every accepted value is safe as a branch argument. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format --branch feature/dataExplained result. The command validates the candidate under the branch-name contract. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: CCA repository. Explain the rule using feature branches follow one readable hierarchy and reject ambiguous names. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–branch applies branch-name validation and is stricter in relevant cases, including rejecting a leading dash that a full ref component rule alone might permit.” Apply this procedure: Use –branch for names that a user will pass to branch-oriented porcelain. The expected mechanism is: The command validates the candidate under the branch-name contract. For the CCA repository, add one near-miss that exposes validating refs/heads/$name and assuming every accepted value is safe as a branch argument. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: science pipeline. Transfer the rule using generated refs are normalized and verified before update-ref. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–branch applies branch-name validation and is stricter in relevant cases, including rejecting a leading dash that a full ref component rule alone might permit.” Apply this procedure: Use –branch for names that a user will pass to branch-oriented porcelain. The expected mechanism is: The command validates the candidate under the branch-name contract. For the science pipeline, add one near-miss that exposes validating refs/heads/$name and assuming every accepted value is safe as a branch argument. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family project. Predict the rule using previous-checkout shorthand is tested in attached and detached states. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–branch applies branch-name validation and is stricter in relevant cases, including rejecting a leading dash that a full ref component rule alone might permit.” Apply this procedure: Use –branch for names that a user will pass to branch-oriented porcelain. The expected mechanism is: The command validates the candidate under the branch-name contract. For the family project, add one near-miss that exposes validating refs/heads/$name and assuming every accepted value is safe as a branch argument. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: refspec laboratory. Contrast the rule using one wildcard pattern is accepted only in the pattern-validation mode. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–branch applies branch-name validation and is stricter in relevant cases, including rejecting a leading dash that a full ref component rule alone might permit.” Apply this procedure: Use –branch for names that a user will pass to branch-oriented porcelain. The expected mechanism is: The command validates the candidate under the branch-name contract. For the refspec laboratory, add one near-miss that exposes validating refs/heads/$name and assuming every accepted value is safe as a branch argument. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers validating refs/heads/$name and assuming every accepted value is safe as a branch argument.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Use –branch for names that a user will pass to branch-oriented porcelain.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from –branch validates branch-facing input?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing validating refs/heads/$name and assuming every accepted value is safe as a branch argument be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny CCA repository with feature branches follow one readable hierarchy and reject ambiguous names. Include one ordinary case, one boundary and one deliberate failure caused by validating refs/heads/$name and assuming every accepted value is safe as a branch argument. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: –branch applies branch-name validation and is stricter in relevant cases, including rejecting a leading dash that a full ref component rule alone might permit. It shows a trace, not only a final value. The ordinary case should demonstrate “The command validates the candidate under the branch-name contract.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use –branch for names that a user will pass to branch-oriented porcelain. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For –branch validates branch-facing input, separate the documented Git check-ref-format 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
inside a repository, –branch first expands @{-n} previous-checkout syntax so porcelain can accept the same shorthand as switch or checkout. 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 storing the literal characters @{-1} as the new branch name. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Capture and inspect the printed expanded result before use.
For the –branch expands previous-checkout shorthand chapter on Git check-ref-format, 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 storing the literal characters @{-1} as the new branch name. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format --branch '@{-1}'Explained result. The output is the previous checkout target when the repository history can resolve it. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family project. Transfer the rule using previous-checkout shorthand is tested in attached and detached states. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “inside a repository, –branch first expands @{-n} previous-checkout syntax so porcelain can accept the same shorthand as switch or checkout.” Apply this procedure: Capture and inspect the printed expanded result before use. The expected mechanism is: The output is the previous checkout target when the repository history can resolve it. For the family project, add one near-miss that exposes storing the literal characters @{-1} as the new branch name. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: refspec laboratory. Predict the rule using one wildcard pattern is accepted only in the pattern-validation mode. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “inside a repository, –branch first expands @{-n} previous-checkout syntax so porcelain can accept the same shorthand as switch or checkout.” Apply this procedure: Capture and inspect the printed expanded result before use. The expected mechanism is: The output is the previous checkout target when the repository history can resolve it. For the refspec laboratory, add one near-miss that exposes storing the literal characters @{-1} as the new branch name. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: shell-safety fixture. Contrast the rule using spaces, metacharacters and option-like inputs are quoted and rejected correctly. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “inside a repository, –branch first expands @{-n} previous-checkout syntax so porcelain can accept the same shorthand as switch or checkout.” Apply this procedure: Capture and inspect the printed expanded result before use. The expected mechanism is: The output is the previous checkout target when the repository history can resolve it. For the shell-safety fixture, add one near-miss that exposes storing the literal characters @{-1} as the new branch name. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: workflow decision. Stress-test the rule using check-ref-format, switch, branch and update-ref responsibilities are separated. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “inside a repository, –branch first expands @{-n} previous-checkout syntax so porcelain can accept the same shorthand as switch or checkout.” Apply this procedure: Capture and inspect the printed expanded result before use. The expected mechanism is: The output is the previous checkout target when the repository history can resolve it. For the workflow decision, add one near-miss that exposes storing the literal characters @{-1} as the new branch name. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers storing the literal characters @{-1} as the new branch name.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Capture and inspect the printed expanded result before use.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from –branch expands previous-checkout shorthand?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing storing the literal characters @{-1} as the new branch name be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny science pipeline with generated refs are normalized and verified before update-ref. Include one ordinary case, one boundary and one deliberate failure caused by storing the literal characters @{-1} as the new branch name. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: inside a repository, –branch first expands @{-n} previous-checkout syntax so porcelain can accept the same shorthand as switch or checkout. It shows a trace, not only a final value. The ordinary case should demonstrate “The output is the previous checkout target when the repository history can resolve it.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Capture and inspect the printed expanded result before use. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For –branch expands previous-checkout shorthand, separate the documented Git check-ref-format 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 expanded @{-n} result can be a commit object name when that checkout was detached rather than a branch. 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 every successful expansion as a branch ref. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Check whether the result is an acceptable branch for the intended operation after expansion.
For the Previous checkout may be detached chapter on Git check-ref-format, 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 every successful expansion as a branch ref. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
previous=$(git check-ref-format --branch '@{-1}')Explained result. A successful value may identify a detached commit, so the caller must not invent a branch relationship. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: shell-safety fixture. Predict the rule using spaces, metacharacters and option-like inputs are quoted and rejected correctly. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the expanded @{-n} result can be a commit object name when that checkout was detached rather than a branch.” Apply this procedure: Check whether the result is an acceptable branch for the intended operation after expansion. The expected mechanism is: A successful value may identify a detached commit, so the caller must not invent a branch relationship. For the shell-safety fixture, add one near-miss that exposes treating every successful expansion as a branch ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: workflow decision. Contrast the rule using check-ref-format, switch, branch and update-ref responsibilities are separated. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the expanded @{-n} result can be a commit object name when that checkout was detached rather than a branch.” Apply this procedure: Check whether the result is an acceptable branch for the intended operation after expansion. The expected mechanism is: A successful value may identify a detached commit, so the caller must not invent a branch relationship. For the workflow decision, add one near-miss that exposes treating every successful expansion as a branch ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: coding assignment. Stress-test the rule using a packaging script validates a student-supplied branch name before creating it. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the expanded @{-n} result can be a commit object name when that checkout was detached rather than a branch.” Apply this procedure: Check whether the result is an acceptable branch for the intended operation after expansion. The expected mechanism is: A successful value may identify a detached commit, so the caller must not invent a branch relationship. For the coding assignment, add one near-miss that exposes treating every successful expansion as a branch ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: group website. Explain the rule using a release tool maps a safe label into refs/tags without inventing punctuation rules. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “the expanded @{-n} result can be a commit object name when that checkout was detached rather than a branch.” Apply this procedure: Check whether the result is an acceptable branch for the intended operation after expansion. The expected mechanism is: A successful value may identify a detached commit, so the caller must not invent a branch relationship. For the group website, add one near-miss that exposes treating every successful expansion as a branch ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers treating every successful expansion as a branch ref.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Check whether the result is an acceptable branch for the intended operation after expansion.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from Previous checkout may be detached?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating every successful expansion as a branch ref be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny family project with previous-checkout shorthand is tested in attached and detached states. Include one ordinary case, one boundary and one deliberate failure caused by treating every successful expansion as a branch ref. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: the expanded @{-n} result can be a commit object name when that checkout was detached rather than a branch. It shows a trace, not only a final value. The ordinary case should demonstrate “A successful value may identify a detached commit, so the caller must not invent a branch relationship.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Check whether the result is an acceptable branch for the intended operation after expansion. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Previous checkout may be detached, separate the documented Git check-ref-format 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
–normalize removes leading slashes and collapses adjacent slashes, then prints the result only if the normalized refname is valid. 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 normalize as a general slugifier for spaces and punctuation. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test examples and document exactly which slash cleanup is permitted.
For the –normalize performs a narrow cleanup chapter on Git check-ref-format, 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 normalize as a general slugifier for spaces and punctuation. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format --normalize /refs//heads/mainExplained result. The command prints refs/heads/main and exits successfully because the normalized name is valid. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: coding assignment. Contrast the rule using a packaging script validates a student-supplied branch name before creating it. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–normalize removes leading slashes and collapses adjacent slashes, then prints the result only if the normalized refname is valid.” Apply this procedure: Test examples and document exactly which slash cleanup is permitted. The expected mechanism is: The command prints refs/heads/main and exits successfully because the normalized name is valid. For the coding assignment, add one near-miss that exposes using normalize as a general slugifier for spaces and punctuation. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: group website. Stress-test the rule using a release tool maps a safe label into refs/tags without inventing punctuation rules. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–normalize removes leading slashes and collapses adjacent slashes, then prints the result only if the normalized refname is valid.” Apply this procedure: Test examples and document exactly which slash cleanup is permitted. The expected mechanism is: The command prints refs/heads/main and exits successfully because the normalized name is valid. For the group website, add one near-miss that exposes using normalize as a general slugifier for spaces and punctuation. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: CCA repository. Explain the rule using feature branches follow one readable hierarchy and reject ambiguous names. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–normalize removes leading slashes and collapses adjacent slashes, then prints the result only if the normalized refname is valid.” Apply this procedure: Test examples and document exactly which slash cleanup is permitted. The expected mechanism is: The command prints refs/heads/main and exits successfully because the normalized name is valid. For the CCA repository, add one near-miss that exposes using normalize as a general slugifier for spaces and punctuation. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: science pipeline. Transfer the rule using generated refs are normalized and verified before update-ref. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–normalize removes leading slashes and collapses adjacent slashes, then prints the result only if the normalized refname is valid.” Apply this procedure: Test examples and document exactly which slash cleanup is permitted. The expected mechanism is: The command prints refs/heads/main and exits successfully because the normalized name is valid. For the science pipeline, add one near-miss that exposes using normalize as a general slugifier for spaces and punctuation. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers using normalize as a general slugifier for spaces and punctuation.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Test examples and document exactly which slash cleanup is permitted.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from –normalize performs a narrow cleanup?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using normalize as a general slugifier for spaces and punctuation be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny refspec laboratory with one wildcard pattern is accepted only in the pattern-validation mode. Include one ordinary case, one boundary and one deliberate failure caused by using normalize as a general slugifier for spaces and punctuation. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: –normalize removes leading slashes and collapses adjacent slashes, then prints the result only if the normalized refname is valid. It shows a trace, not only a final value. The ordinary case should demonstrate “The command prints refs/heads/main and exits successfully because the normalized name is valid.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Test examples and document exactly which slash cleanup is permitted. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For –normalize performs a narrow cleanup, separate the documented Git check-ref-format 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
–allow-onelevel permits a name without multiple slash-separated components but does not waive the other refname restrictions. 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 the option as a general permissive mode. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test a clean one-level name and a one-level name with a forbidden sequence.
For the –allow-onelevel changes one rule only chapter on Git check-ref-format, 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 the option as a general permissive mode. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format --allow-onelevel TEMPExplained result. TEMP can pass the one-level rule while TEMP..old still fails. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: CCA repository. Stress-test the rule using feature branches follow one readable hierarchy and reject ambiguous names. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–allow-onelevel permits a name without multiple slash-separated components but does not waive the other refname restrictions.” Apply this procedure: Test a clean one-level name and a one-level name with a forbidden sequence. The expected mechanism is: TEMP can pass the one-level rule while TEMP..old still fails. For the CCA repository, add one near-miss that exposes treating the option as a general permissive mode. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: science pipeline. Explain the rule using generated refs are normalized and verified before update-ref. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–allow-onelevel permits a name without multiple slash-separated components but does not waive the other refname restrictions.” Apply this procedure: Test a clean one-level name and a one-level name with a forbidden sequence. The expected mechanism is: TEMP can pass the one-level rule while TEMP..old still fails. For the science pipeline, add one near-miss that exposes treating the option as a general permissive mode. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family project. Transfer the rule using previous-checkout shorthand is tested in attached and detached states. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–allow-onelevel permits a name without multiple slash-separated components but does not waive the other refname restrictions.” Apply this procedure: Test a clean one-level name and a one-level name with a forbidden sequence. The expected mechanism is: TEMP can pass the one-level rule while TEMP..old still fails. For the family project, add one near-miss that exposes treating the option as a general permissive mode. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: refspec laboratory. Predict the rule using one wildcard pattern is accepted only in the pattern-validation mode. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–allow-onelevel permits a name without multiple slash-separated components but does not waive the other refname restrictions.” Apply this procedure: Test a clean one-level name and a one-level name with a forbidden sequence. The expected mechanism is: TEMP can pass the one-level rule while TEMP..old still fails. For the refspec laboratory, add one near-miss that exposes treating the option as a general permissive mode. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers treating the option as a general permissive mode.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Test a clean one-level name and a one-level name with a forbidden sequence.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from –allow-onelevel changes one rule only?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating the option as a general permissive mode be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny shell-safety fixture with spaces, metacharacters and option-like inputs are quoted and rejected correctly. Include one ordinary case, one boundary and one deliberate failure caused by treating the option as a general permissive mode. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: –allow-onelevel permits a name without multiple slash-separated components but does not waive the other refname restrictions. It shows a trace, not only a final value. The ordinary case should demonstrate “TEMP can pass the one-level rule while TEMP..old still fails.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Test a clean one-level name and a one-level name with a forbidden sequence. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For –allow-onelevel changes one rule only, separate the documented Git check-ref-format 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
–refspec-pattern allows one asterisk in the refname pattern for refspec validation, but a second wildcard or other forbidden structure remains invalid. 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 pattern mode to approve an ordinary stored ref containing an asterisk. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Validate patterns only where a fetch or push refspec contract expects one.
For the –refspec-pattern permits one wildcard chapter on Git check-ref-format, 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 pattern mode to approve an ordinary stored ref containing an asterisk. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
git check-ref-format --refspec-pattern 'refs/heads/qa/*'Explained result. The single wildcard is accepted for the pattern-validation job and is not a literal branch name. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family project. Explain the rule using previous-checkout shorthand is tested in attached and detached states. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–refspec-pattern allows one asterisk in the refname pattern for refspec validation, but a second wildcard or other forbidden structure remains invalid.” Apply this procedure: Validate patterns only where a fetch or push refspec contract expects one. The expected mechanism is: The single wildcard is accepted for the pattern-validation job and is not a literal branch name. For the family project, add one near-miss that exposes using pattern mode to approve an ordinary stored ref containing an asterisk. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: refspec laboratory. Transfer the rule using one wildcard pattern is accepted only in the pattern-validation mode. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–refspec-pattern allows one asterisk in the refname pattern for refspec validation, but a second wildcard or other forbidden structure remains invalid.” Apply this procedure: Validate patterns only where a fetch or push refspec contract expects one. The expected mechanism is: The single wildcard is accepted for the pattern-validation job and is not a literal branch name. For the refspec laboratory, add one near-miss that exposes using pattern mode to approve an ordinary stored ref containing an asterisk. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: shell-safety fixture. Predict the rule using spaces, metacharacters and option-like inputs are quoted and rejected correctly. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–refspec-pattern allows one asterisk in the refname pattern for refspec validation, but a second wildcard or other forbidden structure remains invalid.” Apply this procedure: Validate patterns only where a fetch or push refspec contract expects one. The expected mechanism is: The single wildcard is accepted for the pattern-validation job and is not a literal branch name. For the shell-safety fixture, add one near-miss that exposes using pattern mode to approve an ordinary stored ref containing an asterisk. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: workflow decision. Contrast the rule using check-ref-format, switch, branch and update-ref responsibilities are separated. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “–refspec-pattern allows one asterisk in the refname pattern for refspec validation, but a second wildcard or other forbidden structure remains invalid.” Apply this procedure: Validate patterns only where a fetch or push refspec contract expects one. The expected mechanism is: The single wildcard is accepted for the pattern-validation job and is not a literal branch name. For the workflow decision, add one near-miss that exposes using pattern mode to approve an ordinary stored ref containing an asterisk. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers using pattern mode to approve an ordinary stored ref containing an asterisk.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Validate patterns only where a fetch or push refspec contract expects one.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from –refspec-pattern permits one wildcard?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using pattern mode to approve an ordinary stored ref containing an asterisk be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny workflow decision with check-ref-format, switch, branch and update-ref responsibilities are separated. Include one ordinary case, one boundary and one deliberate failure caused by using pattern mode to approve an ordinary stored ref containing an asterisk. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: –refspec-pattern allows one asterisk in the refname pattern for refspec validation, but a second wildcard or other forbidden structure remains invalid. It shows a trace, not only a final value. The ordinary case should demonstrate “The single wildcard is accepted for the pattern-validation job and is not a literal branch name.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Validate patterns only where a fetch or push refspec contract expects one. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For –refspec-pattern permits one wildcard, separate the documented Git check-ref-format mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 20 OF 20 . Transfer with judgment
20. Exit status and porcelain complete the decision
check-ref-format prints selected normalized or expanded values in certain modes and signals validity through exit status; the eventual branch, tag or update command still owns existence, races and policy. 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 an error message or skipping the final Git operation check. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Quote the candidate, branch on status, capture output only in output-producing modes, then invoke the appropriate porcelain safely.
For the Exit status and porcelain complete the decision chapter on Git check-ref-format, 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 an error message or skipping the final Git operation check. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
if git check-ref-format --branch "$name" >/dev/null; then
git switch -c "$name"
fiExplained result. The validator checks syntax first, while git switch performs the actual repository change and reports operational conflicts. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: shell-safety fixture. Transfer the rule using spaces, metacharacters and option-like inputs are quoted and rejected correctly. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “check-ref-format prints selected normalized or expanded values in certain modes and signals validity through exit status; the eventual branch, tag or update command still owns existence, races and policy.” Apply this procedure: Quote the candidate, branch on status, capture output only in output-producing modes, then invoke the appropriate porcelain safely. The expected mechanism is: The validator checks syntax first, while git switch performs the actual repository change and reports operational conflicts. For the shell-safety fixture, add one near-miss that exposes parsing an error message or skipping the final Git operation check. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: workflow decision. Predict the rule using check-ref-format, switch, branch and update-ref responsibilities are separated. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “check-ref-format prints selected normalized or expanded values in certain modes and signals validity through exit status; the eventual branch, tag or update command still owns existence, races and policy.” Apply this procedure: Quote the candidate, branch on status, capture output only in output-producing modes, then invoke the appropriate porcelain safely. The expected mechanism is: The validator checks syntax first, while git switch performs the actual repository change and reports operational conflicts. For the workflow decision, add one near-miss that exposes parsing an error message or skipping the final Git operation check. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: coding assignment. Contrast the rule using a packaging script validates a student-supplied branch name before creating it. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “check-ref-format prints selected normalized or expanded values in certain modes and signals validity through exit status; the eventual branch, tag or update command still owns existence, races and policy.” Apply this procedure: Quote the candidate, branch on status, capture output only in output-producing modes, then invoke the appropriate porcelain safely. The expected mechanism is: The validator checks syntax first, while git switch performs the actual repository change and reports operational conflicts. For the coding assignment, add one near-miss that exposes parsing an error message or skipping the final Git operation check. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: group website. Stress-test the rule using a release tool maps a safe label into refs/tags without inventing punctuation rules. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “check-ref-format prints selected normalized or expanded values in certain modes and signals validity through exit status; the eventual branch, tag or update command still owns existence, races and policy.” Apply this procedure: Quote the candidate, branch on status, capture output only in output-producing modes, then invoke the appropriate porcelain safely. The expected mechanism is: The validator checks syntax first, while git switch performs the actual repository change and reports operational conflicts. For the group website, add one near-miss that exposes parsing an error message or skipping the final Git operation check. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers parsing an error message or skipping the final Git operation check.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Quote the candidate, branch on status, capture output only in output-producing modes, then invoke the appropriate porcelain safely.” 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 check-ref-format syntax. For this chapter, useful prompts are: “What did you expect from Exit status and porcelain complete the decision?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing parsing an error message or skipping the final Git operation check be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny coding assignment with a packaging script validates a student-supplied branch name before creating it. Include one ordinary case, one boundary and one deliberate failure caused by parsing an error message or skipping the final Git operation check. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: check-ref-format prints selected normalized or expanded values in certain modes and signals validity through exit status; the eventual branch, tag or update command still owns existence, races and policy. It shows a trace, not only a final value. The ordinary case should demonstrate “The validator checks syntax first, while git switch performs the actual repository change and reports operational conflicts.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Quote the candidate, branch on status, capture output only in output-producing modes, then invoke the appropriate porcelain safely. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Exit status and porcelain complete the decision, separate the documented Git check-ref-format mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
Parent guide: choose the next useful step
Start with evidence, not a label such as careless. Ask for one prediction and one trace. If the first transition is wrong, rebuild the model. If the model is sound but syntax fails, practise reference use. If routine cases are correct but boundaries fail, vary ties, defaults, unsupported inputs, ownership or missing paths. If explanations transfer, move to a small project.
Keep a weekly record with four lines: concept, prediction, observed difference and next test. Stop when fatigue replaces reasoning. A smaller case tomorrow is more useful than another hour of copying tonight.
Seek specialist help when cause and effect remain invisible after examples are reduced, when accessibility or data-loss implications are unclear, or when an important repository, database or application state may be at risk. Good support should make the learner’s reasoning more independent.
Capstone practice with explained routes
1. coding assignment: model, boundary and recovery
Create a small coding assignment using a packaging script validates a student-supplied branch name before creating it. Combine “Git refs live in named hierarchies” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: branches and tags are references commonly stored under refs/heads and refs/tags, so a full ref name includes its namespace rather than only a friendly branch word. Apply: Label user branch input and stored full ref as separate fields. Verify: main is a branch-facing name while refs/heads/main is the corresponding full reference path. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
2. group website: model, boundary and recovery
Create a small group website using a release tool maps a safe label into refs/tags without inventing punctuation rules. Combine “Components cannot end with .lock” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: a refname component ending in .lock is forbidden because it conflicts with lockfile conventions used for safe reference updates. Apply: Inspect every component in a hierarchical name. Verify: The proposed ref is rejected rather than colliding conceptually with Git lock handling. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
3. CCA repository: model, boundary and recovery
Create a small CCA repository using feature branches follow one readable hierarchy and reject ambiguous names. Combine “Tilde caret and colon are revision operators” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: the characters ~, ^ and : are forbidden because Git revision and refspec expressions give them other meanings. Apply: Compare each candidate with the documented revision grammar. Verify: The caret makes the candidate invalid as a ref name rather than being treated as decoration. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
4. science pipeline: model, boundary and recovery
Create a small science pipeline using generated refs are normalized and verified before update-ref. Combine “A refname cannot end with a dot” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: a trailing dot is forbidden even when the preceding component otherwise looks readable. Apply: Test both ends of every proposed full name. Verify: The command rejects the trailing-dot refname. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
5. family project: model, boundary and recovery
Create a small family project using previous-checkout shorthand is tested in attached and detached states. Combine “Backslash is forbidden” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: a refname cannot contain backslash, avoiding platform and escape ambiguities. Apply: Always use Git ref syntax with forward slashes and quote shell input. Verify: The backslash-containing candidate is invalid. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
6. refspec laboratory: model, boundary and recovery
Create a small refspec laboratory using one wildcard pattern is accepted only in the pattern-validation mode. Combine “Previous checkout may be detached” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: the expanded @{-n} result can be a commit object name when that checkout was detached rather than a branch. Apply: Check whether the result is an acceptable branch for the intended operation after expansion. Verify: A successful value may identify a detached commit, so the caller must not invent a branch relationship. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
7. shell-safety fixture: model, boundary and recovery
Create a small shell-safety fixture using spaces, metacharacters and option-like inputs are quoted and rejected correctly. Combine “–refspec-pattern permits one wildcard” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: –refspec-pattern allows one asterisk in the refname pattern for refspec validation, but a second wildcard or other forbidden structure remains invalid. Apply: Validate patterns only where a fetch or push refspec contract expects one. Verify: The single wildcard is accepted for the pattern-validation job and is not a literal branch name. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
8. workflow decision: model, boundary and recovery
Create a small workflow decision using check-ref-format, switch, branch and update-ref responsibilities are separated. Combine “A normal full ref needs more than one component” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: without –allow-onelevel, check-ref-format requires at least one slash so the name includes a category-like component. Apply: Use –branch for branch names or prepend the intended refs namespace before full-ref validation. Verify: The namespaced ref contains the required slash and can satisfy the ordinary structural rule. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
Frequently asked questions
How long should a practice session be?
Use one complete prediction–observation–explanation cycle while attention remains good. Ten to twenty focused minutes can be enough.
Should every option or function be memorised?
No. Memorise the governing distinctions and practise retrieving the official reference. Understanding means predicting and explaining, not reciting a parameter list.
What if the result is correct but the explanation is weak?
Treat it as partial success. Ask for a trace and change one boundary. A reliable model survives controlled variation.
Is the shortest solution the best?
Not automatically. Prefer the solution whose semantics, failure modes and maintenance cost are easiest to justify for the actual project.
When should official documentation be used?
Use it whenever syntax, supported types, SQL dialect behaviour or Git version details matter. Primary documentation settles the current contract.
How can a parent help without technical expertise?
Ask what was predicted, where the first difference appeared, what evidence matters and which smaller example could isolate it.
How do we test transfer?
Change the context, vocabulary and one boundary. Require the learner to identify the invariant before using a tool.
What should be saved after practice?
Keep the corrected rule, one trace, one boundary case and the next question. Avoid storing pages of unexplained output.
Can these exercises replace backups?
No. Use disposable examples and proper backups. Learning should not endanger schoolwork, repositories or personal data.
What counts as mastery?
The learner can predict, verify, diagnose, recover and justify a choice across more than one context, while knowing when to consult the current reference.
