PUNGGOL TUITION · PRACTICAL MASTERY GUIDE

If a learner subclasses PurePath and metadata disappears after using /, parent or relative_to(), the surprise is a design clue rather than random behaviour. Python supplies with_segments() as the central derivative-path hook.

The core rule is concise: with_segments(*pathsegments) creates a same-type path from supplied segments and is called whenever a derivative path is constructed. A subclass can override it to pass session or domain context into those derivatives; the method was added in Python 3.12.

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

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

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

Choose a reading route

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

Start from the model: Chapters 1–4. Begin with The derivative-path factory and continue in order to The Python 3.12 boundary.

Diagnose a confusing result: Chapters 5–8. Begin with Why subclasses override it and continue in order to The parents sequence.

Build reliable examples: Chapters 9–12. Begin with relative_to propagation and continue in order to with_stem propagation.

Transfer to real work: Chapters 13–16. Begin with POSIX flavour stays POSIX and continue in order to Constructor-signature traps.

Decide and teach: Chapters 17–20. Begin with Copying several metadata fields and continue in order to Subclass or wrapper decision.

Open the full 20-chapter index

1. 1. The derivative-path factory
2. 2. Combining supplied segments
3. 3. Same-type preservation
4. 4. The Python 3.12 boundary
5. 5. Why subclasses override it
6. 6. Slash-join propagation
7. 7. Parent propagation
8. 8. The parents sequence
9. 9. relative_to propagation
10. 10. with_name propagation
11. 11. with_suffix propagation
12. 12. with_stem propagation
13. 13. POSIX flavour stays POSIX
14. 14. Windows flavour stays Windows
15. 15. Immutability and identity
16. 16. Constructor-signature traps
17. 17. Copying several metadata fields
18. 18. Validation belongs in the constructor
19. 19. Table-driven derivative tests
20. 20. Subclass or wrapper decision

CHAPTER 1 OF 20 · Back to contents

1. The derivative-path factory

The short answer: The derivative-path factory is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: PurePath.with_segments(*pathsegments) creates a new path of the same type from the supplied segments.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “PurePath.with_segments(*pathsegments) creates a new path of the same type from the supplied segments.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

from pathlib import PurePosixPath
p=PurePosixPath('/school/work')
print(type(p.with_segments('/school','notes.txt')).__name__)

Expected result and reasoning. Python 3.12+ prints PurePosixPath because the result keeps the path type. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Reading the method as an in-place editor hides that path objects are immutable. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for the derivative-path factory
• Variable to hold constant: the surrounding setup, so the comparison isolates the derivative-path factory.
• Variable to change: compare object identity as well as string value
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a homework archive. Transfer the derivative-path factory into a homework archive. Preserve the governing rule—PurePath.with_segments(*pathsegments) creates a new path of the same type from the supplied segments.—while identifying what changes in this setting. The derivative-path factory is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PurePath.with_segments(*pathsegments) creates a new path of the same type from the supplied segments.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a source-tree helper. Transfer the derivative-path factory into a source-tree helper. Preserve the governing rule—PurePath.with_segments(*pathsegments) creates a new path of the same type from the supplied segments.—while identifying what changes in this setting. The derivative-path factory is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PurePath.with_segments(*pathsegments) creates a new path of the same type from the supplied segments.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a Windows family computer. Transfer the derivative-path factory into a Windows family computer. Preserve the governing rule—PurePath.with_segments(*pathsegments) creates a new path of the same type from the supplied segments.—while identifying what changes in this setting. The derivative-path factory is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PurePath.with_segments(*pathsegments) creates a new path of the same type from the supplied segments.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a packaging script. Transfer the derivative-path factory into a packaging script. Preserve the governing rule—PurePath.with_segments(*pathsegments) creates a new path of the same type from the supplied segments.—while identifying what changes in this setting. The derivative-path factory is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PurePath.with_segments(*pathsegments) creates a new path of the same type from the supplied segments.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for the derivative-path factory, predict the result, then compare object identity as well as string value. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. Python 3.12+ prints PurePosixPath because the result keeps the path type. The contrast follows from this rule: PurePath.with_segments(*pathsegments) creates a new path of the same type from the supplied segments. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Contents · Full contents · Next: Combining supplied segments →

CHAPTER 2 OF 20 · Back to contents

2. Combining supplied segments

The short answer: Combining supplied segments is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: The method combines every supplied path segment using the path flavour’s normal construction rules.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “The method combines every supplied path segment using the path flavour’s normal construction rules.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

from pathlib import PurePosixPath
p=PurePosixPath('.')
print(p.with_segments('/a','b','c.txt'))

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

Near miss. Assuming segments are concatenated as raw text ignores anchors and separators. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for combining supplied segments
• Variable to hold constant: the surrounding setup, so the comparison isolates combining supplied segments.
• Variable to change: replace the first segment with a relative a
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a cross-platform class project. Transfer combining supplied segments into a cross-platform class project. Preserve the governing rule—The method combines every supplied path segment using the path flavour’s normal construction rules.—while identifying what changes in this setting. Combining supplied segments is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The method combines every supplied path segment using the path flavour’s normal construction rules.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a metadata-aware path library. Transfer combining supplied segments into a metadata-aware path library. Preserve the governing rule—The method combines every supplied path segment using the path flavour’s normal construction rules.—while identifying what changes in this setting. Combining supplied segments is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The method combines every supplied path segment using the path flavour’s normal construction rules.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a school-managed laptop. Transfer combining supplied segments into a school-managed laptop. Preserve the governing rule—The method combines every supplied path segment using the path flavour’s normal construction rules.—while identifying what changes in this setting. Combining supplied segments is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The method combines every supplied path segment using the path flavour’s normal construction rules.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a code-review checklist. Transfer combining supplied segments into a code-review checklist. Preserve the governing rule—The method combines every supplied path segment using the path flavour’s normal construction rules.—while identifying what changes in this setting. Combining supplied segments is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The method combines every supplied path segment using the path flavour’s normal construction rules.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for combining supplied segments, predict the result, then replace the first segment with a relative a. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The result is /a/b/c.txt. The contrast follows from this rule: The method combines every supplied path segment using the path flavour’s normal construction rules. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: The derivative-path factory · Full contents · Next: Same-type preservation →

CHAPTER 3 OF 20 · Back to contents

3. Same-type preservation

The short answer: Same-type preservation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: The returned derivative is an instance of the original path class, including an appropriate subclass.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “The returned derivative is an instance of the original path class, including an appropriate subclass.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

from pathlib import PurePosixPath
class SchoolPath(PurePosixPath): pass
p=SchoolPath('/a')
print(type(p.with_segments('/b')).__name__)

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

Near miss. Converting through str and PurePath discards the subclass. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for same-type preservation
• Variable to hold constant: the surrounding setup, so the comparison isolates same-type preservation.
• Variable to change: compare with PurePosixPath(str(p))
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a source-tree helper. Transfer same-type preservation into a source-tree helper. Preserve the governing rule—The returned derivative is an instance of the original path class, including an appropriate subclass.—while identifying what changes in this setting. Same-type preservation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The returned derivative is an instance of the original path class, including an appropriate subclass.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a Windows family computer. Transfer same-type preservation into a Windows family computer. Preserve the governing rule—The returned derivative is an instance of the original path class, including an appropriate subclass.—while identifying what changes in this setting. Same-type preservation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The returned derivative is an instance of the original path class, including an appropriate subclass.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a packaging script. Transfer same-type preservation into a packaging script. Preserve the governing rule—The returned derivative is an instance of the original path class, including an appropriate subclass.—while identifying what changes in this setting. Same-type preservation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The returned derivative is an instance of the original path class, including an appropriate subclass.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a homework archive. Transfer same-type preservation into a homework archive. Preserve the governing rule—The returned derivative is an instance of the original path class, including an appropriate subclass.—while identifying what changes in this setting. Same-type preservation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The returned derivative is an instance of the original path class, including an appropriate subclass.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for same-type preservation, predict the result, then compare with PurePosixPath(str(p)). Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The result type is SchoolPath. The contrast follows from this rule: The returned derivative is an instance of the original path class, including an appropriate subclass. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: Combining supplied segments · Full contents · Next: The Python 3.12 boundary →

CHAPTER 4 OF 20 · Back to contents

4. The Python 3.12 boundary

The short answer: The Python 3.12 boundary is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: PurePath.with_segments() was added in Python 3.12 and older interpreters do not provide the method.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “PurePath.with_segments() was added in Python 3.12 and older interpreters do not provide the method.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

import sys
from pathlib import PurePath
print(sys.version_info[:2], hasattr(PurePath('.'),'with_segments'))

Expected result and reasoning. A Python 3.12+ runtime reports True for the attribute check. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Catching AttributeError and silently changing behaviour hides a compatibility failure. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for the python 3.12 boundary
• Variable to hold constant: the surrounding setup, so the comparison isolates the python 3.12 boundary.
• Variable to change: run the guard in the project test matrix
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a metadata-aware path library. Transfer the python 3.12 boundary into a metadata-aware path library. Preserve the governing rule—PurePath.with_segments() was added in Python 3.12 and older interpreters do not provide the method.—while identifying what changes in this setting. The Python 3.12 boundary is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PurePath.with_segments() was added in Python 3.12 and older interpreters do not provide the method.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a school-managed laptop. Transfer the python 3.12 boundary into a school-managed laptop. Preserve the governing rule—PurePath.with_segments() was added in Python 3.12 and older interpreters do not provide the method.—while identifying what changes in this setting. The Python 3.12 boundary is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PurePath.with_segments() was added in Python 3.12 and older interpreters do not provide the method.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a code-review checklist. Transfer the python 3.12 boundary into a code-review checklist. Preserve the governing rule—PurePath.with_segments() was added in Python 3.12 and older interpreters do not provide the method.—while identifying what changes in this setting. The Python 3.12 boundary is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PurePath.with_segments() was added in Python 3.12 and older interpreters do not provide the method.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a cross-platform class project. Transfer the python 3.12 boundary into a cross-platform class project. Preserve the governing rule—PurePath.with_segments() was added in Python 3.12 and older interpreters do not provide the method.—while identifying what changes in this setting. The Python 3.12 boundary is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PurePath.with_segments() was added in Python 3.12 and older interpreters do not provide the method.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for the python 3.12 boundary, predict the result, then run the guard in the project test matrix. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. A Python 3.12+ runtime reports True for the attribute check. The contrast follows from this rule: PurePath.with_segments() was added in Python 3.12 and older interpreters do not provide the method. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: Same-type preservation · Full contents · Next: Why subclasses override it →

CHAPTER 5 OF 20 · Back to contents

5. Why subclasses override it

The short answer: Why subclasses override it is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: A subclass overrides with_segments() when derivative paths must receive extra constructor information.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “A subclass overrides with_segments() when derivative paths must receive extra constructor information.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

from pathlib import PurePosixPath
class MyPath(PurePosixPath):
 def __init__(self,*parts,session_id):
  super().__init__(*parts); self.session_id=session_id
 def with_segments(self,*parts):
  return type(self)(*parts,session_id=self.session_id)

Expected result and reasoning. The override centralises propagation of session_id into every derivative. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Patching metadata onto selected results misses derivative operations elsewhere. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for why subclasses override it
• Variable to hold constant: the surrounding setup, so the comparison isolates why subclasses override it.
• Variable to change: add a second metadata field and preserve it deliberately
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a Windows family computer. Transfer why subclasses override it into a Windows family computer. Preserve the governing rule—A subclass overrides with_segments() when derivative paths must receive extra constructor information.—while identifying what changes in this setting. Why subclasses override it is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A subclass overrides with_segments() when derivative paths must receive extra constructor information.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a packaging script. Transfer why subclasses override it into a packaging script. Preserve the governing rule—A subclass overrides with_segments() when derivative paths must receive extra constructor information.—while identifying what changes in this setting. Why subclasses override it is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A subclass overrides with_segments() when derivative paths must receive extra constructor information.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a homework archive. Transfer why subclasses override it into a homework archive. Preserve the governing rule—A subclass overrides with_segments() when derivative paths must receive extra constructor information.—while identifying what changes in this setting. Why subclasses override it is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A subclass overrides with_segments() when derivative paths must receive extra constructor information.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a source-tree helper. Transfer why subclasses override it into a source-tree helper. Preserve the governing rule—A subclass overrides with_segments() when derivative paths must receive extra constructor information.—while identifying what changes in this setting. Why subclasses override it is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A subclass overrides with_segments() when derivative paths must receive extra constructor information.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for why subclasses override it, predict the result, then add a second metadata field and preserve it deliberately. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The override centralises propagation of session_id into every derivative. The contrast follows from this rule: A subclass overrides with_segments() when derivative paths must receive extra constructor information. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: The Python 3.12 boundary · Full contents · Next: Slash-join propagation →

CHAPTER 6 OF 20 · Back to contents

6. Slash-join propagation

The short answer: Slash-join propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: The / operator creates a derivative through the subclass’s with_segments() route.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “The / operator creates a derivative through the subclass’s with_segments() route.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

p=MyPath('/school',session_id='PGL-52')
q=p/'notes.txt'
print(q,q.session_id)

Expected result and reasoning. The verified Python 3.12.14 fixture prints /school/notes.txt PGL-52. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Overriding only __truediv__ treats one symptom instead of the common derivative factory. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for slash-join propagation
• Variable to hold constant: the surrounding setup, so the comparison isolates slash-join propagation.
• Variable to change: join two additional segments
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a school-managed laptop. Transfer slash-join propagation into a school-managed laptop. Preserve the governing rule—The / operator creates a derivative through the subclass’s with_segments() route.—while identifying what changes in this setting. Slash-join propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The / operator creates a derivative through the subclass’s with_segments() route.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a code-review checklist. Transfer slash-join propagation into a code-review checklist. Preserve the governing rule—The / operator creates a derivative through the subclass’s with_segments() route.—while identifying what changes in this setting. Slash-join propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The / operator creates a derivative through the subclass’s with_segments() route.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a cross-platform class project. Transfer slash-join propagation into a cross-platform class project. Preserve the governing rule—The / operator creates a derivative through the subclass’s with_segments() route.—while identifying what changes in this setting. Slash-join propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The / operator creates a derivative through the subclass’s with_segments() route.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a metadata-aware path library. Transfer slash-join propagation into a metadata-aware path library. Preserve the governing rule—The / operator creates a derivative through the subclass’s with_segments() route.—while identifying what changes in this setting. Slash-join propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The / operator creates a derivative through the subclass’s with_segments() route.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for slash-join propagation, predict the result, then join two additional segments. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The verified Python 3.12.14 fixture prints /school/notes.txt PGL-52. The contrast follows from this rule: The / operator creates a derivative through the subclass’s with_segments() route. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: Why subclasses override it · Full contents · Next: Parent propagation →

CHAPTER 7 OF 20 · Back to contents

7. Parent propagation

The short answer: Parent propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: The parent property creates a derivative and therefore can carry subclass metadata through with_segments().. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “The parent property creates a derivative and therefore can carry subclass metadata through with_segments().”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

p=MyPath('/school/projects/report.txt',session_id='PGL-52')
print(p.parent,p.parent.session_id)

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

Near miss. Assuming a property merely exposes stored text misses that it constructs a new object. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for parent propagation
• Variable to hold constant: the surrounding setup, so the comparison isolates parent propagation.
• Variable to change: compare id(p) and id(p.parent)
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a packaging script. Transfer parent propagation into a packaging script. Preserve the governing rule—The parent property creates a derivative and therefore can carry subclass metadata through with_segments().—while identifying what changes in this setting. Parent propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The parent property creates a derivative and therefore can carry subclass metadata through with_segments().”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a homework archive. Transfer parent propagation into a homework archive. Preserve the governing rule—The parent property creates a derivative and therefore can carry subclass metadata through with_segments().—while identifying what changes in this setting. Parent propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The parent property creates a derivative and therefore can carry subclass metadata through with_segments().”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a source-tree helper. Transfer parent propagation into a source-tree helper. Preserve the governing rule—The parent property creates a derivative and therefore can carry subclass metadata through with_segments().—while identifying what changes in this setting. Parent propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The parent property creates a derivative and therefore can carry subclass metadata through with_segments().”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a Windows family computer. Transfer parent propagation into a Windows family computer. Preserve the governing rule—The parent property creates a derivative and therefore can carry subclass metadata through with_segments().—while identifying what changes in this setting. Parent propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “The parent property creates a derivative and therefore can carry subclass metadata through with_segments().”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for parent propagation, predict the result, then compare id(p) and id(p.parent). Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The verified fixture prints /school/projects PGL-52. The contrast follows from this rule: The parent property creates a derivative and therefore can carry subclass metadata through with_segments(). The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: Slash-join propagation · Full contents · Next: The parents sequence →

CHAPTER 8 OF 20 · Back to contents

8. The parents sequence

The short answer: The parents sequence is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: Members obtained from parents are derivative paths and should obey the same metadata policy.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “Members obtained from parents are derivative paths and should obey the same metadata policy.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

p=MyPath('/a/b/c.txt',session_id='S1')
for x in p.parents: print(x,x.session_id)

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

Near miss. Testing only parent once can miss a propagation error at deeper ancestry. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for the parents sequence
• Variable to hold constant: the surrounding setup, so the comparison isolates the parents sequence.
• Variable to change: assert the metadata for all ancestors
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a code-review checklist. Transfer the parents sequence into a code-review checklist. Preserve the governing rule—Members obtained from parents are derivative paths and should obey the same metadata policy.—while identifying what changes in this setting. The parents sequence is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Members obtained from parents are derivative paths and should obey the same metadata policy.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a cross-platform class project. Transfer the parents sequence into a cross-platform class project. Preserve the governing rule—Members obtained from parents are derivative paths and should obey the same metadata policy.—while identifying what changes in this setting. The parents sequence is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Members obtained from parents are derivative paths and should obey the same metadata policy.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a metadata-aware path library. Transfer the parents sequence into a metadata-aware path library. Preserve the governing rule—Members obtained from parents are derivative paths and should obey the same metadata policy.—while identifying what changes in this setting. The parents sequence is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Members obtained from parents are derivative paths and should obey the same metadata policy.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a school-managed laptop. Transfer the parents sequence into a school-managed laptop. Preserve the governing rule—Members obtained from parents are derivative paths and should obey the same metadata policy.—while identifying what changes in this setting. The parents sequence is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Members obtained from parents are derivative paths and should obey the same metadata policy.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for the parents sequence, predict the result, then assert the metadata for all ancestors. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. Each ancestor is a MyPath carrying S1. The contrast follows from this rule: Members obtained from parents are derivative paths and should obey the same metadata policy. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: Parent propagation · Full contents · Next: relative_to propagation →

CHAPTER 9 OF 20 · Back to contents

9. relative_to propagation

The short answer: relative_to propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: relative_to() returns a new relative derivative and uses with_segments() for the subclass result.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “relative_to() returns a new relative derivative and uses with_segments() for the subclass result.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

p=MyPath('/school/projects/report.txt',session_id='PGL-52')
q=p.relative_to('/school')
print(q,q.session_id)

Expected result and reasoning. The verified fixture prints projects/report.txt PGL-52. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Treating relative_to as string deletion loses flavour and subclass semantics. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for relative_to propagation
• Variable to hold constant: the surrounding setup, so the comparison isolates relative_to propagation.
• Variable to change: use an incompatible base and inspect the exception separately
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a homework archive. Transfer relative_to propagation into a homework archive. Preserve the governing rule—relative_to() returns a new relative derivative and uses with_segments() for the subclass result.—while identifying what changes in this setting. relative_to propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “relative_to() returns a new relative derivative and uses with_segments() for the subclass result.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a source-tree helper. Transfer relative_to propagation into a source-tree helper. Preserve the governing rule—relative_to() returns a new relative derivative and uses with_segments() for the subclass result.—while identifying what changes in this setting. relative_to propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “relative_to() returns a new relative derivative and uses with_segments() for the subclass result.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a Windows family computer. Transfer relative_to propagation into a Windows family computer. Preserve the governing rule—relative_to() returns a new relative derivative and uses with_segments() for the subclass result.—while identifying what changes in this setting. relative_to propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “relative_to() returns a new relative derivative and uses with_segments() for the subclass result.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a packaging script. Transfer relative_to propagation into a packaging script. Preserve the governing rule—relative_to() returns a new relative derivative and uses with_segments() for the subclass result.—while identifying what changes in this setting. relative_to propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “relative_to() returns a new relative derivative and uses with_segments() for the subclass result.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for relative_to propagation, predict the result, then use an incompatible base and inspect the exception separately. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The verified fixture prints projects/report.txt PGL-52. The contrast follows from this rule: relative_to() returns a new relative derivative and uses with_segments() for the subclass result. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: The parents sequence · Full contents · Next: with_name propagation →

CHAPTER 10 OF 20 · Back to contents

10. with_name propagation

The short answer: with_name propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: with_name() changes the final name while the derivative retains subclass context through the hook.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “with_name() changes the final name while the derivative retains subclass context through the hook.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

p=MyPath('/school/report.txt',session_id='S2')
print(p.with_name('notes.md').session_id)

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

Near miss. Reconstructing manually from parent/name can duplicate path rules. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for with_name propagation
• Variable to hold constant: the surrounding setup, so the comparison isolates with_name propagation.
• Variable to change: rename to another valid leaf name
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a cross-platform class project. Transfer with_name propagation into a cross-platform class project. Preserve the governing rule—with_name() changes the final name while the derivative retains subclass context through the hook.—while identifying what changes in this setting. with_name propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_name() changes the final name while the derivative retains subclass context through the hook.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a metadata-aware path library. Transfer with_name propagation into a metadata-aware path library. Preserve the governing rule—with_name() changes the final name while the derivative retains subclass context through the hook.—while identifying what changes in this setting. with_name propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_name() changes the final name while the derivative retains subclass context through the hook.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a school-managed laptop. Transfer with_name propagation into a school-managed laptop. Preserve the governing rule—with_name() changes the final name while the derivative retains subclass context through the hook.—while identifying what changes in this setting. with_name propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_name() changes the final name while the derivative retains subclass context through the hook.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a code-review checklist. Transfer with_name propagation into a code-review checklist. Preserve the governing rule—with_name() changes the final name while the derivative retains subclass context through the hook.—while identifying what changes in this setting. with_name propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_name() changes the final name while the derivative retains subclass context through the hook.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for with_name propagation, predict the result, then rename to another valid leaf name. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The result retains S2. The contrast follows from this rule: with_name() changes the final name while the derivative retains subclass context through the hook. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: relative_to propagation · Full contents · Next: with_suffix propagation →

CHAPTER 11 OF 20 · Back to contents

11. with_suffix propagation

The short answer: with_suffix propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: with_suffix() creates a derivative with a changed suffix and preserved extra state.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “with_suffix() creates a derivative with a changed suffix and preserved extra state.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

p=MyPath('/school/report.txt',session_id='S3')
q=p.with_suffix('.pdf')
print(q,q.session_id)

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

Near miss. Mutating the original is impossible because pure paths are immutable. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for with_suffix propagation
• Variable to hold constant: the surrounding setup, so the comparison isolates with_suffix propagation.
• Variable to change: print both p and q
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a source-tree helper. Transfer with_suffix propagation into a source-tree helper. Preserve the governing rule—with_suffix() creates a derivative with a changed suffix and preserved extra state.—while identifying what changes in this setting. with_suffix propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_suffix() creates a derivative with a changed suffix and preserved extra state.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a Windows family computer. Transfer with_suffix propagation into a Windows family computer. Preserve the governing rule—with_suffix() creates a derivative with a changed suffix and preserved extra state.—while identifying what changes in this setting. with_suffix propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_suffix() creates a derivative with a changed suffix and preserved extra state.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a packaging script. Transfer with_suffix propagation into a packaging script. Preserve the governing rule—with_suffix() creates a derivative with a changed suffix and preserved extra state.—while identifying what changes in this setting. with_suffix propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_suffix() creates a derivative with a changed suffix and preserved extra state.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a homework archive. Transfer with_suffix propagation into a homework archive. Preserve the governing rule—with_suffix() creates a derivative with a changed suffix and preserved extra state.—while identifying what changes in this setting. with_suffix propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_suffix() creates a derivative with a changed suffix and preserved extra state.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for with_suffix propagation, predict the result, then print both p and q. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The verified fixture prints /school/report.pdf S3. The contrast follows from this rule: with_suffix() creates a derivative with a changed suffix and preserved extra state. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: with_name propagation · Full contents · Next: with_stem propagation →

CHAPTER 12 OF 20 · Back to contents

12. with_stem propagation

The short answer: with_stem propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: with_stem() derives a renamed path and should preserve subclass metadata through the same policy.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “with_stem() derives a renamed path and should preserve subclass metadata through the same policy.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

p=MyPath('/school/report.txt',session_id='S4')
q=p.with_stem('final')
print(q,q.session_id)

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

Near miss. Calling string replace can change directory text accidentally. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for with_stem propagation
• Variable to hold constant: the surrounding setup, so the comparison isolates with_stem propagation.
• Variable to change: use a filename containing repeated report text
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a metadata-aware path library. Transfer with_stem propagation into a metadata-aware path library. Preserve the governing rule—with_stem() derives a renamed path and should preserve subclass metadata through the same policy.—while identifying what changes in this setting. with_stem propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_stem() derives a renamed path and should preserve subclass metadata through the same policy.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a school-managed laptop. Transfer with_stem propagation into a school-managed laptop. Preserve the governing rule—with_stem() derives a renamed path and should preserve subclass metadata through the same policy.—while identifying what changes in this setting. with_stem propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_stem() derives a renamed path and should preserve subclass metadata through the same policy.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a code-review checklist. Transfer with_stem propagation into a code-review checklist. Preserve the governing rule—with_stem() derives a renamed path and should preserve subclass metadata through the same policy.—while identifying what changes in this setting. with_stem propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_stem() derives a renamed path and should preserve subclass metadata through the same policy.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a cross-platform class project. Transfer with_stem propagation into a cross-platform class project. Preserve the governing rule—with_stem() derives a renamed path and should preserve subclass metadata through the same policy.—while identifying what changes in this setting. with_stem propagation is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_stem() derives a renamed path and should preserve subclass metadata through the same policy.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for with_stem propagation, predict the result, then use a filename containing repeated report text. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The verified fixture prints /school/final.txt S4. The contrast follows from this rule: with_stem() derives a renamed path and should preserve subclass metadata through the same policy. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: with_suffix propagation · Full contents · Next: POSIX flavour stays POSIX →

CHAPTER 13 OF 20 · Back to contents

13. POSIX flavour stays POSIX

The short answer: POSIX flavour stays POSIX is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: PurePosixPath derivatives keep POSIX lexical rules even on a non-POSIX host.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “PurePosixPath derivatives keep POSIX lexical rules even on a non-POSIX host.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

from pathlib import PurePosixPath
p=PurePosixPath('/a')
print(type(p.with_segments('/b')).__name__)

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

Near miss. Letting the host choose Path changes the modelling question. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for posix flavour stays posix
• Variable to hold constant: the surrounding setup, so the comparison isolates posix flavour stays posix.
• Variable to change: compare with PureWindowsPath
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a Windows family computer. Transfer posix flavour stays posix into a Windows family computer. Preserve the governing rule—PurePosixPath derivatives keep POSIX lexical rules even on a non-POSIX host.—while identifying what changes in this setting. POSIX flavour stays POSIX is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PurePosixPath derivatives keep POSIX lexical rules even on a non-POSIX host.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a packaging script. Transfer posix flavour stays posix into a packaging script. Preserve the governing rule—PurePosixPath derivatives keep POSIX lexical rules even on a non-POSIX host.—while identifying what changes in this setting. POSIX flavour stays POSIX is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PurePosixPath derivatives keep POSIX lexical rules even on a non-POSIX host.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a homework archive. Transfer posix flavour stays posix into a homework archive. Preserve the governing rule—PurePosixPath derivatives keep POSIX lexical rules even on a non-POSIX host.—while identifying what changes in this setting. POSIX flavour stays POSIX is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PurePosixPath derivatives keep POSIX lexical rules even on a non-POSIX host.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a source-tree helper. Transfer posix flavour stays posix into a source-tree helper. Preserve the governing rule—PurePosixPath derivatives keep POSIX lexical rules even on a non-POSIX host.—while identifying what changes in this setting. POSIX flavour stays POSIX is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PurePosixPath derivatives keep POSIX lexical rules even on a non-POSIX host.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for posix flavour stays posix, predict the result, then compare with PureWindowsPath. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The result remains PurePosixPath. The contrast follows from this rule: PurePosixPath derivatives keep POSIX lexical rules even on a non-POSIX host. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: with_stem propagation · Full contents · Next: Windows flavour stays Windows →

CHAPTER 14 OF 20 · Back to contents

14. Windows flavour stays Windows

The short answer: Windows flavour stays Windows is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: PureWindowsPath derivatives retain Windows drive and separator semantics lexically.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “PureWindowsPath derivatives retain Windows drive and separator semantics lexically.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

from pathlib import PureWindowsPath
p=PureWindowsPath('C:/School')
print(p.with_segments('C:/School','work.txt'))

Expected result and reasoning. The result is a PureWindowsPath spelling for C:\School\work.txt. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Testing a Windows pure path with POSIX assumptions confuses flavour with host filesystem. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for windows flavour stays windows
• Variable to hold constant: the surrounding setup, so the comparison isolates windows flavour stays windows.
• Variable to change: try a UNC-style first segment
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a school-managed laptop. Transfer windows flavour stays windows into a school-managed laptop. Preserve the governing rule—PureWindowsPath derivatives retain Windows drive and separator semantics lexically.—while identifying what changes in this setting. Windows flavour stays Windows is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PureWindowsPath derivatives retain Windows drive and separator semantics lexically.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a code-review checklist. Transfer windows flavour stays windows into a code-review checklist. Preserve the governing rule—PureWindowsPath derivatives retain Windows drive and separator semantics lexically.—while identifying what changes in this setting. Windows flavour stays Windows is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PureWindowsPath derivatives retain Windows drive and separator semantics lexically.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a cross-platform class project. Transfer windows flavour stays windows into a cross-platform class project. Preserve the governing rule—PureWindowsPath derivatives retain Windows drive and separator semantics lexically.—while identifying what changes in this setting. Windows flavour stays Windows is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PureWindowsPath derivatives retain Windows drive and separator semantics lexically.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a metadata-aware path library. Transfer windows flavour stays windows into a metadata-aware path library. Preserve the governing rule—PureWindowsPath derivatives retain Windows drive and separator semantics lexically.—while identifying what changes in this setting. Windows flavour stays Windows is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “PureWindowsPath derivatives retain Windows drive and separator semantics lexically.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for windows flavour stays windows, predict the result, then try a UNC-style first segment. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The result is a PureWindowsPath spelling for C:\School\work.txt. The contrast follows from this rule: PureWindowsPath derivatives retain Windows drive and separator semantics lexically. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: POSIX flavour stays POSIX · Full contents · Next: Immutability and identity →

CHAPTER 15 OF 20 · Back to contents

15. Immutability and identity

The short answer: Immutability and identity is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: with_segments() returns a new object; it does not mutate the receiver.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “with_segments() returns a new object; it does not mutate the receiver.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

from pathlib import PurePath
p=PurePath('a')
q=p.with_segments('b')
print(p,q,p is q)

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

Near miss. Seeing the same class and assuming the same object obscures immutable value semantics. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for immutability and identity
• Variable to hold constant: the surrounding setup, so the comparison isolates immutability and identity.
• Variable to change: create the same spelling twice and compare equality and identity
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a packaging script. Transfer immutability and identity into a packaging script. Preserve the governing rule—with_segments() returns a new object; it does not mutate the receiver.—while identifying what changes in this setting. Immutability and identity is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_segments() returns a new object; it does not mutate the receiver.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a homework archive. Transfer immutability and identity into a homework archive. Preserve the governing rule—with_segments() returns a new object; it does not mutate the receiver.—while identifying what changes in this setting. Immutability and identity is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_segments() returns a new object; it does not mutate the receiver.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a source-tree helper. Transfer immutability and identity into a source-tree helper. Preserve the governing rule—with_segments() returns a new object; it does not mutate the receiver.—while identifying what changes in this setting. Immutability and identity is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_segments() returns a new object; it does not mutate the receiver.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a Windows family computer. Transfer immutability and identity into a Windows family computer. Preserve the governing rule—with_segments() returns a new object; it does not mutate the receiver.—while identifying what changes in this setting. Immutability and identity is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_segments() returns a new object; it does not mutate the receiver.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for immutability and identity, predict the result, then create the same spelling twice and compare equality and identity. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. Python 3.12+ prints a b False. The contrast follows from this rule: with_segments() returns a new object; it does not mutate the receiver. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: Windows flavour stays Windows · Full contents · Next: Constructor-signature traps →

CHAPTER 16 OF 20 · Back to contents

16. Constructor-signature traps

The short answer: Constructor-signature traps is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: An extra required subclass constructor argument must be supplied by an override or derivative construction can fail.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “An extra required subclass constructor argument must be supplied by an override or derivative construction can fail.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

from pathlib import PurePosixPath
class NeedsKey(PurePosixPath):
 def __init__(self,*p,key): super().__init__(*p); self.key=key
x=NeedsKey('/a',key='K')
# x.parent needs a propagation policy

Expected result and reasoning. Without a suitable with_segments() override, derivative construction cannot satisfy the required keyword-only argument. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. A happy initial construction does not prove derivative operations work. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for constructor-signature traps
• Variable to hold constant: the surrounding setup, so the comparison isolates constructor-signature traps.
• Variable to change: add the official-style override and retest parent
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a code-review checklist. Transfer constructor-signature traps into a code-review checklist. Preserve the governing rule—An extra required subclass constructor argument must be supplied by an override or derivative construction can fail.—while identifying what changes in this setting. Constructor-signature traps is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “An extra required subclass constructor argument must be supplied by an override or derivative construction can fail.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a cross-platform class project. Transfer constructor-signature traps into a cross-platform class project. Preserve the governing rule—An extra required subclass constructor argument must be supplied by an override or derivative construction can fail.—while identifying what changes in this setting. Constructor-signature traps is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “An extra required subclass constructor argument must be supplied by an override or derivative construction can fail.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a metadata-aware path library. Transfer constructor-signature traps into a metadata-aware path library. Preserve the governing rule—An extra required subclass constructor argument must be supplied by an override or derivative construction can fail.—while identifying what changes in this setting. Constructor-signature traps is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “An extra required subclass constructor argument must be supplied by an override or derivative construction can fail.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a school-managed laptop. Transfer constructor-signature traps into a school-managed laptop. Preserve the governing rule—An extra required subclass constructor argument must be supplied by an override or derivative construction can fail.—while identifying what changes in this setting. Constructor-signature traps is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “An extra required subclass constructor argument must be supplied by an override or derivative construction can fail.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for constructor-signature traps, predict the result, then add the official-style override and retest parent. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. Without a suitable with_segments() override, derivative construction cannot satisfy the required keyword-only argument. The contrast follows from this rule: An extra required subclass constructor argument must be supplied by an override or derivative construction can fail. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: Immutability and identity · Full contents · Next: Copying several metadata fields →

CHAPTER 17 OF 20 · Back to contents

17. Copying several metadata fields

The short answer: Copying several metadata fields is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: A deliberate override can propagate several immutable context fields in one place.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “A deliberate override can propagate several immutable context fields in one place.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

def with_segments(self,*parts):
 return type(self)(*parts,session_id=self.session_id,cohort=self.cohort)

Expected result and reasoning. Every derivative receives both fields when the constructor accepts them. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Copying __dict__ blindly can transfer caches or mutable state that should not propagate. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for copying several metadata fields
• Variable to hold constant: the surrounding setup, so the comparison isolates copying several metadata fields.
• Variable to change: document and test the propagation allow-list
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a homework archive. Transfer copying several metadata fields into a homework archive. Preserve the governing rule—A deliberate override can propagate several immutable context fields in one place.—while identifying what changes in this setting. Copying several metadata fields is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A deliberate override can propagate several immutable context fields in one place.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a source-tree helper. Transfer copying several metadata fields into a source-tree helper. Preserve the governing rule—A deliberate override can propagate several immutable context fields in one place.—while identifying what changes in this setting. Copying several metadata fields is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A deliberate override can propagate several immutable context fields in one place.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a Windows family computer. Transfer copying several metadata fields into a Windows family computer. Preserve the governing rule—A deliberate override can propagate several immutable context fields in one place.—while identifying what changes in this setting. Copying several metadata fields is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A deliberate override can propagate several immutable context fields in one place.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a packaging script. Transfer copying several metadata fields into a packaging script. Preserve the governing rule—A deliberate override can propagate several immutable context fields in one place.—while identifying what changes in this setting. Copying several metadata fields is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “A deliberate override can propagate several immutable context fields in one place.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for copying several metadata fields, predict the result, then document and test the propagation allow-list. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. Every derivative receives both fields when the constructor accepts them. The contrast follows from this rule: A deliberate override can propagate several immutable context fields in one place. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: Constructor-signature traps · Full contents · Next: Validation belongs in the constructor →

CHAPTER 18 OF 20 · Back to contents

18. Validation belongs in the constructor

The short answer: Validation belongs in the constructor is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: with_segments() should reuse the subclass constructor’s validation instead of bypassing it.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “with_segments() should reuse the subclass constructor’s validation instead of bypassing it.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

def with_segments(self,*parts):
 return type(self)(*parts,session_id=self.session_id)

Expected result and reasoning. A derivative is checked by the same constructor contract as the original. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Using object.__new__ to skip validation creates inconsistent instances. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for validation belongs in the constructor
• Variable to hold constant: the surrounding setup, so the comparison isolates validation belongs in the constructor.
• Variable to change: write a negative constructor test
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a cross-platform class project. Transfer validation belongs in the constructor into a cross-platform class project. Preserve the governing rule—with_segments() should reuse the subclass constructor’s validation instead of bypassing it.—while identifying what changes in this setting. Validation belongs in the constructor is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_segments() should reuse the subclass constructor’s validation instead of bypassing it.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a metadata-aware path library. Transfer validation belongs in the constructor into a metadata-aware path library. Preserve the governing rule—with_segments() should reuse the subclass constructor’s validation instead of bypassing it.—while identifying what changes in this setting. Validation belongs in the constructor is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_segments() should reuse the subclass constructor’s validation instead of bypassing it.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a school-managed laptop. Transfer validation belongs in the constructor into a school-managed laptop. Preserve the governing rule—with_segments() should reuse the subclass constructor’s validation instead of bypassing it.—while identifying what changes in this setting. Validation belongs in the constructor is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_segments() should reuse the subclass constructor’s validation instead of bypassing it.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a code-review checklist. Transfer validation belongs in the constructor into a code-review checklist. Preserve the governing rule—with_segments() should reuse the subclass constructor’s validation instead of bypassing it.—while identifying what changes in this setting. Validation belongs in the constructor is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “with_segments() should reuse the subclass constructor’s validation instead of bypassing it.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for validation belongs in the constructor, predict the result, then write a negative constructor test. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. A derivative is checked by the same constructor contract as the original. The contrast follows from this rule: with_segments() should reuse the subclass constructor’s validation instead of bypassing it. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: Copying several metadata fields · Full contents · Next: Table-driven derivative tests →

CHAPTER 19 OF 20 · Back to contents

19. Table-driven derivative tests

The short answer: Table-driven derivative tests is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: Test a propagation invariant across join, parent, relative_to, with_name, with_suffix and with_stem.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “Test a propagation invariant across join, parent, relative_to, with_name, with_suffix and with_stem.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

ops=[lambda p:p/'x',lambda p:p.parent,lambda p:p.with_suffix('.md')]
for op in ops: assert op(p).session_id==p.session_id

Expected result and reasoning. The assertions pass for every covered derivative operation. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. One example proves only one route and may miss a future regression. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for table-driven derivative tests
• Variable to hold constant: the surrounding setup, so the comparison isolates table-driven derivative tests.
• Variable to change: add every promised operation to the table
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a source-tree helper. Transfer table-driven derivative tests into a source-tree helper. Preserve the governing rule—Test a propagation invariant across join, parent, relative_to, with_name, with_suffix and with_stem.—while identifying what changes in this setting. Table-driven derivative tests is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Test a propagation invariant across join, parent, relative_to, with_name, with_suffix and with_stem.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a Windows family computer. Transfer table-driven derivative tests into a Windows family computer. Preserve the governing rule—Test a propagation invariant across join, parent, relative_to, with_name, with_suffix and with_stem.—while identifying what changes in this setting. Table-driven derivative tests is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Test a propagation invariant across join, parent, relative_to, with_name, with_suffix and with_stem.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a packaging script. Transfer table-driven derivative tests into a packaging script. Preserve the governing rule—Test a propagation invariant across join, parent, relative_to, with_name, with_suffix and with_stem.—while identifying what changes in this setting. Table-driven derivative tests is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Test a propagation invariant across join, parent, relative_to, with_name, with_suffix and with_stem.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a homework archive. Transfer table-driven derivative tests into a homework archive. Preserve the governing rule—Test a propagation invariant across join, parent, relative_to, with_name, with_suffix and with_stem.—while identifying what changes in this setting. Table-driven derivative tests is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Test a propagation invariant across join, parent, relative_to, with_name, with_suffix and with_stem.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for table-driven derivative tests, predict the result, then add every promised operation to the table. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. The assertions pass for every covered derivative operation. The contrast follows from this rule: Test a propagation invariant across join, parent, relative_to, with_name, with_suffix and with_stem. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: Validation belongs in the constructor · Full contents · Next: Subclass or wrapper decision →

CHAPTER 20 OF 20 · Back to contents

20. Subclass or wrapper decision

The short answer: Subclass or wrapper decision is a decision about the feature’s documented contract, not a cue to copy a longer snippet. The governing rule is: Subclass PurePath only when path-like behaviour and derivative propagation are central; otherwise composition may be clearer.. This is the sentence a learner should be able to say before touching a keyboard. It turns a vague topic into a testable model and gives a parent or tutor something precise to listen for.

The platform applies the rule “Subclass PurePath only when path-like behaviour and derivative propagation are central; otherwise composition may be clearer.”. A minimal fixture makes the relevant input and observation visible while keeping unrelated project state out of the explanation. That mechanism matters because superficially similar examples can produce different results. A reliable explanation names the relevant object, identifies the operation performed on it, and states when the decision is made. “It works” is not enough; mastery means predicting the result and explaining why a nearby example behaves differently.

Worked example: predict before running

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

class Submission:
 def __init__(self,path,session_id): self.path=PurePosixPath(path); self.session_id=session_id

Expected result and reasoning. A wrapper keeps domain metadata separate when it need not follow every PurePath method. The important evidence is not merely the printed value or exit status. It is the connection between that evidence and the rule above. Say the chain aloud: input → relevant rule → operation → observable result. If a learner cannot supply the middle two links, the right response is to revisit the model rather than add more examples.

Near miss. Subclassing for convenience can expose a larger behavioural surface than the project needs. This is tempting because it uses a familiar word or visual resemblance. Correct it by changing only one variable at a time and comparing the two cases side by side. A good contrast preserves everything except the feature named in the rule.

Diagnostic route when the answer is wrong

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

• Evidence to collect: the exact input, environment version, observed result and the rule for subclass or wrapper decision
• Variable to hold constant: the surrounding setup, so the comparison isolates subclass or wrapper decision.
• Variable to change: compare the public API of the subclass and wrapper
• Explanation standard: name the rule, not merely the successful command or copied syntax.

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

Four transfer cases

Transfer case 1: a metadata-aware path library. Transfer subclass or wrapper decision into a metadata-aware path library. Preserve the governing rule—Subclass PurePath only when path-like behaviour and derivative propagation are central; otherwise composition may be clearer.—while identifying what changes in this setting. Subclass or wrapper decision is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Subclass PurePath only when path-like behaviour and derivative propagation are central; otherwise composition may be clearer.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 2: a school-managed laptop. Transfer subclass or wrapper decision into a school-managed laptop. Preserve the governing rule—Subclass PurePath only when path-like behaviour and derivative propagation are central; otherwise composition may be clearer.—while identifying what changes in this setting. Subclass or wrapper decision is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Subclass PurePath only when path-like behaviour and derivative propagation are central; otherwise composition may be clearer.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 3: a code-review checklist. Transfer subclass or wrapper decision into a code-review checklist. Preserve the governing rule—Subclass PurePath only when path-like behaviour and derivative propagation are central; otherwise composition may be clearer.—while identifying what changes in this setting. Subclass or wrapper decision is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Subclass PurePath only when path-like behaviour and derivative propagation are central; otherwise composition may be clearer.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Transfer case 4: a cross-platform class project. Transfer subclass or wrapper decision into a cross-platform class project. Preserve the governing rule—Subclass PurePath only when path-like behaviour and derivative propagation are central; otherwise composition may be clearer.—while identifying what changes in this setting. Subclass or wrapper decision is a decision about the feature’s documented contract, not a cue to copy a longer snippet. Record the input, prediction, observation and version so a disagreement becomes a diagnosable case rather than a guess. Start by naming the observable evidence, then apply the chapter rule “Subclass PurePath only when path-like behaviour and derivative propagation are central; otherwise composition may be clearer.”. Do not jump straight to a command or syntax change. First predict the outcome, perform the smallest safe check, and compare the result with that prediction. This makes the case useful beyond the immediate exercise: the learner is practising a decision process, not memorising a one-off answer. If the result differs, record what changed—platform, input shape, repository state, document tree, or evaluation order—before revising the model.

Practice, pause point, and explained answer

Task. Rebuild the example for subclass or wrapper decision, predict the result, then compare the public API of the subclass and wrapper. Explain both outcomes without trial and error. Before checking anything, write (1) the predicted result, (2) the rule that justifies it, and (3) one nearby variation that should change the result. A complete response should be understandable to someone who has not seen the example.

Explained answer. A wrapper keeps domain metadata separate when it need not follow every PurePath method. The contrast follows from this rule: Subclass PurePath only when path-like behaviour and derivative propagation are central; otherwise composition may be clearer. The reasoning earns more attention than the final value. If the learner reached the correct result by guessing, repeat the task with the variation they proposed. If they can predict both cases and explain the contrast, the idea is beginning to transfer.

Parent and tutor decision point

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

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

← Previous: Table-driven derivative tests · Full contents · Parent guide →

Parent guide: what mastery looks like

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

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

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

Capstone practice with explained routes

Capstone 1: Rebuild the smallest trustworthy fixture

Scenario. Create a disposable Python fixture that demonstrates same-type derivative path construction without unrelated project code.

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

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

Capstone 2: Diagnose a believable wrong explanation

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

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

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

Capstone 3: Handle a version boundary

Scenario. Two environments produce different observations.

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

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

Capstone 4: Design a parent check-in

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

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

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

Capstone 5: Transfer into a larger project

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

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

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

Capstone 6: Write a regression check

Scenario. The behaviour must remain understood after an update.

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

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

Capstone 7: Explain a limitation honestly

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

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

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

Capstone 8: Choose the right tool

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

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

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

Frequently asked questions

Is Python pathlib.PurePath.with_segments mainly a syntax topic?

No. Syntax is the handle. Mastery means stating the contract, predicting a boundary case, collecting the right evidence and choosing a different tool when the contract does not fit.

How long should one practice session be?

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

Should every edge case be memorised?

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

What can a non-specialist parent ask?

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

When is copying an example useful?

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

How do we separate setup errors from concept errors?

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

Should practice start inside a large project?

Not initially. Begin in a disposable directory, tiny script or isolated page. Transfer the verified rule only after the smallest case is understood.

What belongs in revision notes?

Keep the rule in one sentence, the smallest successful example, a near miss, observed output, environment version and one diagnostic question.

What if two computers disagree?

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

When should the learner move on?

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

References and verification notes

Primary technical source: Official Python pathlib documentation. The Python documentation states that with_segments() combines the supplied segments, returns a new same-type path, is called for derivative construction, can be overridden to propagate subclass information and was added in Python 3.12.

The worked examples were checked with CPython 3.12.14 with a PurePosixPath subclass carrying session_id; the fixture verified propagation through slash join, parent, relative_to, with_name, with_suffix and with_stem. The checks confirm the specific examples in this guide; they do not promise identical behaviour on an older version, a different operating system, a different browser implementation, or a repository with different state. Keep the version and environment with the saved fixture.

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