A folder can open like an ordinary directory while actually redirecting traversal through a Windows junction. That difference matters when a learner writes a backup scanner, deletion preview or project indexer.

Python pathlib.Path.is_junction() returns True when a concrete path points to a junction and False for other file types. The method was added in Python 3.12, and the current documentation states that only Windows supports junctions.

This guide teaches junction identity, ordinary directories, symbolic links, mount points, platform-aware tests, recursive traversal decisions and safe diagnostics without treating every redirected path as the same mechanism.

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

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

Path.is_junction asks whether the concrete path points to a Windows junction, not whether it merely names a directory. That is the invariant to preserve when names, data or surrounding project details change.

The label describes a filesystem mechanism rather than a visual folder appearance. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

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

Core worked example

from pathlib import Path
print(Path(r'C:\work\shared').is_junction())

Read the trace, not just the last line

Trace pathname, platform support, filesystem lookup and Boolean classification. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “A junction is a specific Windows path object”, separate contract from coincidence. The contract is “Path.is_junction asks whether the concrete path points to a Windows junction, not whether it merely names a directory.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Create one ordinary directory and one junction in a disposable Windows workspace.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “A junction is a specific Windows path object” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction asks whether the concrete path points to a Windows junction, not whether it merely names a directory.” should remain invariant and what observation would expose calling every directory alias a junction.

Case 2: photo-library alias check. Contrast “A junction is a specific Windows path object” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction asks whether the concrete path points to a Windows junction, not whether it merely names a directory.” should remain invariant and what observation would expose calling every directory alias a junction.

Case 3: science-data archive. Stress-test “A junction is a specific Windows path object” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction asks whether the concrete path points to a Windows junction, not whether it merely names a directory.” should remain invariant and what observation would expose calling every directory alias a junction.

Case 4: backup verification task. Explain “A junction is a specific Windows path object” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction asks whether the concrete path points to a Windows junction, not whether it merely names a directory.” should remain invariant and what observation would expose calling every directory alias a junction.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals calling every directory alias a junction.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Create one ordinary directory and one junction in a disposable Windows workspace.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “A junction is a specific Windows path object”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Path.is_junction asks whether the concrete path points to a Windows junction, not whether it merely names a directory.?”, and “Can you make a smaller example of calling every directory alias a junction?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Classify two folder-looking paths. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Use the precise filesystem category in logs and policy. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “A junction is a specific Windows path object” means the learner can predict the ordinary case, recognise calling every directory alias a junction, diagnose the earliest mistaken assumption, recover with “Create one ordinary directory and one junction in a disposable Windows workspace.” and defend this decision: Use the precise filesystem category in logs and policy. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

Path.is_junction is part of pathlib from Python 3.12 onward. That is the invariant to preserve when names, data or surrounding project details change.

API availability is a runtime-version question before it is a filesystem question. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is diagnosing AttributeError as a bad path. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

import sys
print(sys.version_info[:3])
print(hasattr(__import__('pathlib').Path, 'is_junction'))

Read the trace, not just the last line

Trace import, attribute lookup and later filesystem call separately. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “The method was added in Python 3.12”, separate contract from coincidence. The contract is “Path.is_junction is part of pathlib from Python 3.12 onward.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Record the interpreter version and feature presence before running path fixtures.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “The method was added in Python 3.12” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction is part of pathlib from Python 3.12 onward.” should remain invariant and what observation would expose diagnosing AttributeError as a bad path.

Case 2: photo-library alias check. Contrast “The method was added in Python 3.12” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction is part of pathlib from Python 3.12 onward.” should remain invariant and what observation would expose diagnosing AttributeError as a bad path.

Case 3: science-data archive. Stress-test “The method was added in Python 3.12” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction is part of pathlib from Python 3.12 onward.” should remain invariant and what observation would expose diagnosing AttributeError as a bad path.

Case 4: backup verification task. Explain “The method was added in Python 3.12” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction is part of pathlib from Python 3.12 onward.” should remain invariant and what observation would expose diagnosing AttributeError as a bad path.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals diagnosing AttributeError as a bad path.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Record the interpreter version and feature presence before running path fixtures.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “The method was added in Python 3.12”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Path.is_junction is part of pathlib from Python 3.12 onward.?”, and “Can you make a smaller example of diagnosing AttributeError as a bad path?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Write a compatibility check. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Set and test a declared Python version floor. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “The method was added in Python 3.12” means the learner can predict the ordinary case, recognise diagnosing AttributeError as a bad path, diagnose the earliest mistaken assumption, recover with “Record the interpreter version and feature presence before running path fixtures.” and defend this decision: Set and test a declared Python version floor. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

The Python documentation states that junction support is currently Windows-only. That is the invariant to preserve when names, data or surrounding project details change.

Similar navigation effects can come from different platform mechanisms. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is treating a Linux bind mount as a Windows junction. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

from pathlib import Path
print(Path('.').is_junction())

Read the trace, not just the last line

Trace operating system, supported concept and returned classification. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “Only Windows currently supports junctions”, separate contract from coincidence. The contract is “The Python documentation states that junction support is currently Windows-only.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Run the same negative fixture on the available platform and label the platform.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “Only Windows currently supports junctions” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “The Python documentation states that junction support is currently Windows-only.” should remain invariant and what observation would expose treating a Linux bind mount as a Windows junction.

Case 2: photo-library alias check. Contrast “Only Windows currently supports junctions” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “The Python documentation states that junction support is currently Windows-only.” should remain invariant and what observation would expose treating a Linux bind mount as a Windows junction.

Case 3: science-data archive. Stress-test “Only Windows currently supports junctions” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “The Python documentation states that junction support is currently Windows-only.” should remain invariant and what observation would expose treating a Linux bind mount as a Windows junction.

Case 4: backup verification task. Explain “Only Windows currently supports junctions” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “The Python documentation states that junction support is currently Windows-only.” should remain invariant and what observation would expose treating a Linux bind mount as a Windows junction.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals treating a Linux bind mount as a Windows junction.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Run the same negative fixture on the available platform and label the platform.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “Only Windows currently supports junctions”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests The Python documentation states that junction support is currently Windows-only.?”, and “Can you make a smaller example of treating a Linux bind mount as a Windows junction?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain a False result on POSIX. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Branch platform-specific work explicitly. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Only Windows currently supports junctions” means the learner can predict the ordinary case, recognise treating a Linux bind mount as a Windows junction, diagnose the earliest mistaken assumption, recover with “Run the same negative fixture on the available platform and label the platform.” and defend this decision: Branch platform-specific work explicitly. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A normal directory remains False even though programs can traverse into it. That is the invariant to preserve when names, data or surrounding project details change.

Traversal capability is broader than junction classification. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is using directory behaviour as proof of junction identity. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

from pathlib import Path
p=Path('ordinary-folder')
p.mkdir(exist_ok=True)
print(p.is_dir(), p.is_junction())

Read the trace, not just the last line

Trace creation, directory classification and junction classification. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “An ordinary directory is not a junction”, separate contract from coincidence. The contract is “A normal directory remains False even though programs can traverse into it.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Create the directory in a temporary workspace and remove it through the workspace lifecycle.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “An ordinary directory is not a junction” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “A normal directory remains False even though programs can traverse into it.” should remain invariant and what observation would expose using directory behaviour as proof of junction identity.

Case 2: photo-library alias check. Contrast “An ordinary directory is not a junction” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “A normal directory remains False even though programs can traverse into it.” should remain invariant and what observation would expose using directory behaviour as proof of junction identity.

Case 3: science-data archive. Stress-test “An ordinary directory is not a junction” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “A normal directory remains False even though programs can traverse into it.” should remain invariant and what observation would expose using directory behaviour as proof of junction identity.

Case 4: backup verification task. Explain “An ordinary directory is not a junction” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “A normal directory remains False even though programs can traverse into it.” should remain invariant and what observation would expose using directory behaviour as proof of junction identity.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals using directory behaviour as proof of junction identity.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Create the directory in a temporary workspace and remove it through the workspace lifecycle.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “An ordinary directory is not a junction”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A normal directory remains False even though programs can traverse into it.?”, and “Can you make a smaller example of using directory behaviour as proof of junction identity?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict both Booleans. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Ask the narrow classification question needed by the application. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “An ordinary directory is not a junction” means the learner can predict the ordinary case, recognise using directory behaviour as proof of junction identity, diagnose the earliest mistaken assumption, recover with “Create the directory in a temporary workspace and remove it through the workspace lifecycle.” and defend this decision: Ask the narrow classification question needed by the application. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A normal file does not satisfy the junction predicate. That is the invariant to preserve when names, data or surrounding project details change.

Predicates divide path types rather than certify generic existence. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is assuming every reparse-aware predicate identifies any path. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

from pathlib import Path
p=Path('note.txt'); p.write_text('fixture')
print(p.is_junction())

Read the trace, not just the last line

Trace file creation and the negative junction test. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “A regular file is not a junction”, separate contract from coincidence. The contract is “A normal file does not satisfy the junction predicate.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Use a temporary file beside the directory fixture.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “A regular file is not a junction” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “A normal file does not satisfy the junction predicate.” should remain invariant and what observation would expose assuming every reparse-aware predicate identifies any path.

Case 2: photo-library alias check. Contrast “A regular file is not a junction” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “A normal file does not satisfy the junction predicate.” should remain invariant and what observation would expose assuming every reparse-aware predicate identifies any path.

Case 3: science-data archive. Stress-test “A regular file is not a junction” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “A normal file does not satisfy the junction predicate.” should remain invariant and what observation would expose assuming every reparse-aware predicate identifies any path.

Case 4: backup verification task. Explain “A regular file is not a junction” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “A normal file does not satisfy the junction predicate.” should remain invariant and what observation would expose assuming every reparse-aware predicate identifies any path.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals assuming every reparse-aware predicate identifies any path.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use a temporary file beside the directory fixture.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “A regular file is not a junction”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A normal file does not satisfy the junction predicate.?”, and “Can you make a smaller example of assuming every reparse-aware predicate identifies any path?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Compare is_file and is_junction. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Combine predicates only when the decision table requires them. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “A regular file is not a junction” means the learner can predict the ordinary case, recognise assuming every reparse-aware predicate identifies any path, diagnose the earliest mistaken assumption, recover with “Use a temporary file beside the directory fixture.” and defend this decision: Combine predicates only when the decision table requires them. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A pathname that does not identify a junction must not be treated as a positive junction match. That is the invariant to preserve when names, data or surrounding project details change.

One Boolean cannot establish existence and type simultaneously. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is reading False as proof that an ordinary directory exists. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

from pathlib import Path
print(Path('definitely-missing').is_junction())

Read the trace, not just the last line

Trace missing lookup and negative classification separately from directory existence. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “A missing path is not positive evidence”, separate contract from coincidence. The contract is “A pathname that does not identify a junction must not be treated as a positive junction match.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Pair the classifier with an explicit existence or error policy where absence matters.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “A missing path is not positive evidence” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “A pathname that does not identify a junction must not be treated as a positive junction match.” should remain invariant and what observation would expose reading False as proof that an ordinary directory exists.

Case 2: photo-library alias check. Contrast “A missing path is not positive evidence” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “A pathname that does not identify a junction must not be treated as a positive junction match.” should remain invariant and what observation would expose reading False as proof that an ordinary directory exists.

Case 3: science-data archive. Stress-test “A missing path is not positive evidence” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “A pathname that does not identify a junction must not be treated as a positive junction match.” should remain invariant and what observation would expose reading False as proof that an ordinary directory exists.

Case 4: backup verification task. Explain “A missing path is not positive evidence” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “A pathname that does not identify a junction must not be treated as a positive junction match.” should remain invariant and what observation would expose reading False as proof that an ordinary directory exists.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals reading False as proof that an ordinary directory exists.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Pair the classifier with an explicit existence or error policy where absence matters.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “A missing path is not positive evidence”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A pathname that does not identify a junction must not be treated as a positive junction match.?”, and “Can you make a smaller example of reading False as proof that an ordinary directory exists?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Design a three-state report. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Preserve absence as its own application state. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “A missing path is not positive evidence” means the learner can predict the ordinary case, recognise reading False as proof that an ordinary directory exists, diagnose the earliest mistaken assumption, recover with “Pair the classifier with an explicit existence or error policy where absence matters.” and defend this decision: Preserve absence as its own application state. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

Path.is_junction and Path.is_symlink ask different filesystem questions. That is the invariant to preserve when names, data or surrounding project details change.

Windows exposes several kinds of reparse-based redirection with different semantics. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is using is_symlink as a universal redirect detector. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

print(path.is_junction(), path.is_symlink())

Read the trace, not just the last line

Trace both predicates for each fixture. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “A junction and a symbolic link are not interchangeable”, separate contract from coincidence. The contract is “Path.is_junction and Path.is_symlink ask different filesystem questions.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Create separate documented fixtures rather than renaming one mechanism.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “A junction and a symbolic link are not interchangeable” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction and Path.is_symlink ask different filesystem questions.” should remain invariant and what observation would expose using is_symlink as a universal redirect detector.

Case 2: photo-library alias check. Contrast “A junction and a symbolic link are not interchangeable” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction and Path.is_symlink ask different filesystem questions.” should remain invariant and what observation would expose using is_symlink as a universal redirect detector.

Case 3: science-data archive. Stress-test “A junction and a symbolic link are not interchangeable” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction and Path.is_symlink ask different filesystem questions.” should remain invariant and what observation would expose using is_symlink as a universal redirect detector.

Case 4: backup verification task. Explain “A junction and a symbolic link are not interchangeable” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction and Path.is_symlink ask different filesystem questions.” should remain invariant and what observation would expose using is_symlink as a universal redirect detector.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals using is_symlink as a universal redirect detector.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Create separate documented fixtures rather than renaming one mechanism.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “A junction and a symbolic link are not interchangeable”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Path.is_junction and Path.is_symlink ask different filesystem questions.?”, and “Can you make a smaller example of using is_symlink as a universal redirect detector?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Build a two-column classification table. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Keep junction and symlink policy branches explicit. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “A junction and a symbolic link are not interchangeable” means the learner can predict the ordinary case, recognise using is_symlink as a universal redirect detector, diagnose the earliest mistaken assumption, recover with “Create separate documented fixtures rather than renaming one mechanism.” and defend this decision: Keep junction and symlink policy branches explicit. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

Path.is_mount checks mount-point semantics while Path.is_junction checks the Windows junction category. That is the invariant to preserve when names, data or surrounding project details change.

Mount topology and junction identity are neighbouring, not identical, models. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is using a True result from either method as a synonym for redirected directory. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

print(path.is_mount(), path.is_junction())

Read the trace, not just the last line

Trace which predicate governs each row. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “A junction and a mount point answer different questions”, separate contract from coincidence. The contract is “Path.is_mount checks mount-point semantics while Path.is_junction checks the Windows junction category.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Test a known drive root, ordinary directory and controlled junction.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “A junction and a mount point answer different questions” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_mount checks mount-point semantics while Path.is_junction checks the Windows junction category.” should remain invariant and what observation would expose using a True result from either method as a synonym for redirected directory.

Case 2: photo-library alias check. Contrast “A junction and a mount point answer different questions” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_mount checks mount-point semantics while Path.is_junction checks the Windows junction category.” should remain invariant and what observation would expose using a True result from either method as a synonym for redirected directory.

Case 3: science-data archive. Stress-test “A junction and a mount point answer different questions” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_mount checks mount-point semantics while Path.is_junction checks the Windows junction category.” should remain invariant and what observation would expose using a True result from either method as a synonym for redirected directory.

Case 4: backup verification task. Explain “A junction and a mount point answer different questions” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_mount checks mount-point semantics while Path.is_junction checks the Windows junction category.” should remain invariant and what observation would expose using a True result from either method as a synonym for redirected directory.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals using a True result from either method as a synonym for redirected directory.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Test a known drive root, ordinary directory and controlled junction.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “A junction and a mount point answer different questions”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Path.is_mount checks mount-point semantics while Path.is_junction checks the Windows junction category.?”, and “Can you make a smaller example of using a True result from either method as a synonym for redirected directory?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain why a drive root need not be a junction. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Use is_mount for mount policy and is_junction for junction policy. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “A junction and a mount point answer different questions” means the learner can predict the ordinary case, recognise using a True result from either method as a synonym for redirected directory, diagnose the earliest mistaken assumption, recover with “Test a known drive root, ordinary directory and controlled junction.” and defend this decision: Use is_mount for mount policy and is_junction for junction policy. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

The method performs a concrete filesystem query; pathname spelling alone is insufficient. That is the invariant to preserve when names, data or surrounding project details change.

Junction identity is metadata, not filename syntax. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is searching the string for a junction-looking pattern. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

p=Path(r'C:\work\..\work\shared')
print(p.is_junction())

Read the trace, not just the last line

Trace lexical path handling and concrete lookup. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “The Path object does not classify itself lexically”, separate contract from coincidence. The contract is “The method performs a concrete filesystem query; pathname spelling alone is insufficient.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Compare two lexical spellings that reach the same controlled entry.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “The Path object does not classify itself lexically” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “The method performs a concrete filesystem query; pathname spelling alone is insufficient.” should remain invariant and what observation would expose searching the string for a junction-looking pattern.

Case 2: photo-library alias check. Contrast “The Path object does not classify itself lexically” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “The method performs a concrete filesystem query; pathname spelling alone is insufficient.” should remain invariant and what observation would expose searching the string for a junction-looking pattern.

Case 3: science-data archive. Stress-test “The Path object does not classify itself lexically” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “The method performs a concrete filesystem query; pathname spelling alone is insufficient.” should remain invariant and what observation would expose searching the string for a junction-looking pattern.

Case 4: backup verification task. Explain “The Path object does not classify itself lexically” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “The method performs a concrete filesystem query; pathname spelling alone is insufficient.” should remain invariant and what observation would expose searching the string for a junction-looking pattern.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals searching the string for a junction-looking pattern.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Compare two lexical spellings that reach the same controlled entry.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “The Path object does not classify itself lexically”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests The method performs a concrete filesystem query; pathname spelling alone is insufficient.?”, and “Can you make a smaller example of searching the string for a junction-looking pattern?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Predict from names alone. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Avoid regex-based filesystem classification. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “The Path object does not classify itself lexically” means the learner can predict the ordinary case, recognise searching the string for a junction-looking pattern, diagnose the earliest mistaken assumption, recover with “Compare two lexical spellings that reach the same controlled entry.” and defend this decision: Avoid regex-based filesystem classification. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A relative Path is resolved for the query from the process current directory. That is the invariant to preserve when names, data or surrounding project details change.

Concrete classification depends on which entry the pathname reaches. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is treating a relative path as globally stable. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

from pathlib import Path
print(Path('shared').is_junction())

Read the trace, not just the last line

Trace cwd, relative pathname and selected directory entry. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “Relative paths depend on the current working directory”, separate contract from coincidence. The contract is “A relative Path is resolved for the query from the process current directory.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Use two temporary parent folders with different shared entries.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “Relative paths depend on the current working directory” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “A relative Path is resolved for the query from the process current directory.” should remain invariant and what observation would expose treating a relative path as globally stable.

Case 2: photo-library alias check. Contrast “Relative paths depend on the current working directory” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “A relative Path is resolved for the query from the process current directory.” should remain invariant and what observation would expose treating a relative path as globally stable.

Case 3: science-data archive. Stress-test “Relative paths depend on the current working directory” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “A relative Path is resolved for the query from the process current directory.” should remain invariant and what observation would expose treating a relative path as globally stable.

Case 4: backup verification task. Explain “Relative paths depend on the current working directory” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “A relative Path is resolved for the query from the process current directory.” should remain invariant and what observation would expose treating a relative path as globally stable.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals treating a relative path as globally stable.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use two temporary parent folders with different shared entries.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “Relative paths depend on the current working directory”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A relative Path is resolved for the query from the process current directory.?”, and “Can you make a smaller example of treating a relative path as globally stable?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Run after an intentional cwd change. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

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

Mastery of “Relative paths depend on the current working directory” means the learner can predict the ordinary case, recognise treating a relative path as globally stable, diagnose the earliest mistaken assumption, recover with “Use two temporary parent folders with different shared entries.” and defend this decision: Prefer explicit roots in maintenance tools. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

PurePath models path syntax and does not offer concrete filesystem classification. That is the invariant to preserve when names, data or surrounding project details change.

Pure and concrete paths deliberately separate lexical work from I/O. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

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

Core worked example

from pathlib import PureWindowsPath
p=PureWindowsPath(r'C:\work\shared')
print(type(p).__name__)

Read the trace, not just the last line

Trace which object can perform I/O. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “PurePath cannot inspect junctions”, separate contract from coincidence. The contract is “PurePath models path syntax and does not offer concrete filesystem classification.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Use PureWindowsPath for syntax examples and Path on the target Windows system for observation.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “PurePath cannot inspect junctions” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “PurePath models path syntax and does not offer concrete filesystem classification.” should remain invariant and what observation would expose expecting a PurePath to query a live disk.

Case 2: photo-library alias check. Contrast “PurePath cannot inspect junctions” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “PurePath models path syntax and does not offer concrete filesystem classification.” should remain invariant and what observation would expose expecting a PurePath to query a live disk.

Case 3: science-data archive. Stress-test “PurePath cannot inspect junctions” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “PurePath models path syntax and does not offer concrete filesystem classification.” should remain invariant and what observation would expose expecting a PurePath to query a live disk.

Case 4: backup verification task. Explain “PurePath cannot inspect junctions” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “PurePath models path syntax and does not offer concrete filesystem classification.” should remain invariant and what observation would expose expecting a PurePath to query a live disk.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals expecting a PurePath to query a live disk.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use PureWindowsPath for syntax examples and Path on the target Windows system for observation.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “PurePath cannot inspect junctions”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests PurePath models path syntax and does not offer concrete filesystem classification.?”, and “Can you make a smaller example of expecting a PurePath to query a live disk?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Ask PureWindowsPath for is_junction. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Choose PurePath for lexical transformations and Path for classification. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “PurePath cannot inspect junctions” means the learner can predict the ordinary case, recognise expecting a PurePath to query a live disk, diagnose the earliest mistaken assumption, recover with “Use PureWindowsPath for syntax examples and Path on the target Windows system for observation.” and defend this decision: Choose PurePath for lexical transformations and Path for classification. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A .lnk shortcut is an ordinary file interpreted by shell software, not a directory junction. That is the invariant to preserve when names, data or surrounding project details change.

User-interface navigation and filesystem redirection occur at different layers. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is grouping shortcuts, symlinks and junctions under one informal word. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

shortcut=Path('project.lnk')
print(shortcut.is_junction())

Read the trace, not just the last line

Trace filename extension, file type and junction predicate. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “A Windows shortcut file is not a junction”, separate contract from coincidence. The contract is “A .lnk shortcut is an ordinary file interpreted by shell software, not a directory junction.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Create only a harmless placeholder when demonstrating the classification distinction.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “A Windows shortcut file is not a junction” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “A .lnk shortcut is an ordinary file interpreted by shell software, not a directory junction.” should remain invariant and what observation would expose grouping shortcuts, symlinks and junctions under one informal word.

Case 2: photo-library alias check. Contrast “A Windows shortcut file is not a junction” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “A .lnk shortcut is an ordinary file interpreted by shell software, not a directory junction.” should remain invariant and what observation would expose grouping shortcuts, symlinks and junctions under one informal word.

Case 3: science-data archive. Stress-test “A Windows shortcut file is not a junction” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “A .lnk shortcut is an ordinary file interpreted by shell software, not a directory junction.” should remain invariant and what observation would expose grouping shortcuts, symlinks and junctions under one informal word.

Case 4: backup verification task. Explain “A Windows shortcut file is not a junction” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “A .lnk shortcut is an ordinary file interpreted by shell software, not a directory junction.” should remain invariant and what observation would expose grouping shortcuts, symlinks and junctions under one informal word.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals grouping shortcuts, symlinks and junctions under one informal word.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Create only a harmless placeholder when demonstrating the classification distinction.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “A Windows shortcut file is not a junction”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A .lnk shortcut is an ordinary file interpreted by shell software, not a directory junction.?”, and “Can you make a smaller example of grouping shortcuts, symlinks and junctions under one informal word?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Explain why the extension is not proof. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Use mechanism names rather than the word link alone. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “A Windows shortcut file is not a junction” means the learner can predict the ordinary case, recognise grouping shortcuts, symlinks and junctions under one informal word, diagnose the earliest mistaken assumption, recover with “Create only a harmless placeholder when demonstrating the classification distinction.” and defend this decision: Use mechanism names rather than the word link alone. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

Path.is_junction detects a junction; it does not create one. That is the invariant to preserve when names, data or surrounding project details change.

Inspection methods should not be mistaken for mutation commands. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is looking for a target argument or creation side effect. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

if path.is_junction():
    print('junction detected')

Read the trace, not just the last line

Trace external fixture creation and Python observation as separate steps. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “Creation and detection are separate operations”, separate contract from coincidence. The contract is “Path.is_junction detects a junction; it does not create one.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Create any positive fixture with documented Windows tooling in a disposable directory, then detect it with Python.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “Creation and detection are separate operations” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction detects a junction; it does not create one.” should remain invariant and what observation would expose looking for a target argument or creation side effect.

Case 2: photo-library alias check. Contrast “Creation and detection are separate operations” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction detects a junction; it does not create one.” should remain invariant and what observation would expose looking for a target argument or creation side effect.

Case 3: science-data archive. Stress-test “Creation and detection are separate operations” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction detects a junction; it does not create one.” should remain invariant and what observation would expose looking for a target argument or creation side effect.

Case 4: backup verification task. Explain “Creation and detection are separate operations” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “Path.is_junction detects a junction; it does not create one.” should remain invariant and what observation would expose looking for a target argument or creation side effect.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals looking for a target argument or creation side effect.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Create any positive fixture with documented Windows tooling in a disposable directory, then detect it with Python.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “Creation and detection are separate operations”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Path.is_junction detects a junction; it does not create one.?”, and “Can you make a smaller example of looking for a target argument or creation side effect?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Call is_junction twice. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Keep setup, detection and cleanup phases distinct. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Creation and detection are separate operations” means the learner can predict the ordinary case, recognise looking for a target argument or creation side effect, diagnose the earliest mistaken assumption, recover with “Create any positive fixture with documented Windows tooling in a disposable directory, then detect it with Python.” and defend this decision: Keep setup, detection and cleanup phases distinct. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A directory walker can cross a junction into another tree unless the application deliberately fences traversal. That is the invariant to preserve when names, data or surrounding project details change.

Redirection can expand scope beyond the visible starting tree. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is recursing first and checking boundaries later. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

for child in root.iterdir():
    if child.is_junction():
        print('review boundary', child)

Read the trace, not just the last line

Trace current entry, classification, policy and next path. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “Recursive walkers need an explicit junction policy”, separate contract from coincidence. The contract is “A directory walker can cross a junction into another tree unless the application deliberately fences traversal.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Use a shallow disposable tree and record every proposed descent before acting.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “Recursive walkers need an explicit junction policy” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “A directory walker can cross a junction into another tree unless the application deliberately fences traversal.” should remain invariant and what observation would expose recursing first and checking boundaries later.

Case 2: photo-library alias check. Contrast “Recursive walkers need an explicit junction policy” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “A directory walker can cross a junction into another tree unless the application deliberately fences traversal.” should remain invariant and what observation would expose recursing first and checking boundaries later.

Case 3: science-data archive. Stress-test “Recursive walkers need an explicit junction policy” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “A directory walker can cross a junction into another tree unless the application deliberately fences traversal.” should remain invariant and what observation would expose recursing first and checking boundaries later.

Case 4: backup verification task. Explain “Recursive walkers need an explicit junction policy” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “A directory walker can cross a junction into another tree unless the application deliberately fences traversal.” should remain invariant and what observation would expose recursing first and checking boundaries later.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals recursing first and checking boundaries later.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use a shallow disposable tree and record every proposed descent before acting.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “Recursive walkers need an explicit junction policy”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A directory walker can cross a junction into another tree unless the application deliberately fences traversal.?”, and “Can you make a smaller example of recursing first and checking boundaries later?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Design stop and allow modes. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Default destructive tools to the smallest reviewed scope. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Recursive walkers need an explicit junction policy” means the learner can predict the ordinary case, recognise recursing first and checking boundaries later, diagnose the earliest mistaken assumption, recover with “Use a shallow disposable tree and record every proposed descent before acting.” and defend this decision: Default destructive tools to the smallest reviewed scope. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

Detecting a junction does not by itself decide whether its target belongs in a backup. That is the invariant to preserve when names, data or surrounding project details change.

Ownership, target scope and duplicate handling require additional evidence. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is turning one predicate into a complete backup strategy. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

kind='junction' if p.is_junction() else 'other'
print(kind)

Read the trace, not just the last line

Trace classification, target policy and planned operation. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “Backup tools must distinguish identity from policy”, separate contract from coincidence. The contract is “Detecting a junction does not by itself decide whether its target belongs in a backup.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Write a decision table before copying any files.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “Backup tools must distinguish identity from policy” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “Detecting a junction does not by itself decide whether its target belongs in a backup.” should remain invariant and what observation would expose turning one predicate into a complete backup strategy.

Case 2: photo-library alias check. Contrast “Backup tools must distinguish identity from policy” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “Detecting a junction does not by itself decide whether its target belongs in a backup.” should remain invariant and what observation would expose turning one predicate into a complete backup strategy.

Case 3: science-data archive. Stress-test “Backup tools must distinguish identity from policy” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “Detecting a junction does not by itself decide whether its target belongs in a backup.” should remain invariant and what observation would expose turning one predicate into a complete backup strategy.

Case 4: backup verification task. Explain “Backup tools must distinguish identity from policy” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “Detecting a junction does not by itself decide whether its target belongs in a backup.” should remain invariant and what observation would expose turning one predicate into a complete backup strategy.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals turning one predicate into a complete backup strategy.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Write a decision table before copying any files.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “Backup tools must distinguish identity from policy”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Detecting a junction does not by itself decide whether its target belongs in a backup.?”, and “Can you make a smaller example of turning one predicate into a complete backup strategy?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Evaluate a junction inside the source tree. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

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

Mastery of “Backup tools must distinguish identity from policy” means the learner can predict the ordinary case, recognise turning one predicate into a complete backup strategy, diagnose the earliest mistaken assumption, recover with “Write a decision table before copying any files.” and defend this decision: Separate observation from permission to traverse. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A junction classification can trigger a review before a recursive delete chooses its scope. That is the invariant to preserve when names, data or surrounding project details change.

Removal semantics vary by platform and operation. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is using the guard as proof that every deletion API behaves identically. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

if candidate.is_junction():
    raise RuntimeError('review junction before deletion')

Read the trace, not just the last line

Trace candidate, predicate, guard and zero-mutation outcome. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “Deletion previews should stop before target assumptions”, separate contract from coincidence. The contract is “A junction classification can trigger a review before a recursive delete chooses its scope.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Perform only dry-run listing in the learning fixture.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “Deletion previews should stop before target assumptions” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “A junction classification can trigger a review before a recursive delete chooses its scope.” should remain invariant and what observation would expose using the guard as proof that every deletion API behaves identically.

Case 2: photo-library alias check. Contrast “Deletion previews should stop before target assumptions” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “A junction classification can trigger a review before a recursive delete chooses its scope.” should remain invariant and what observation would expose using the guard as proof that every deletion API behaves identically.

Case 3: science-data archive. Stress-test “Deletion previews should stop before target assumptions” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “A junction classification can trigger a review before a recursive delete chooses its scope.” should remain invariant and what observation would expose using the guard as proof that every deletion API behaves identically.

Case 4: backup verification task. Explain “Deletion previews should stop before target assumptions” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “A junction classification can trigger a review before a recursive delete chooses its scope.” should remain invariant and what observation would expose using the guard as proof that every deletion API behaves identically.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals using the guard as proof that every deletion API behaves identically.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Perform only dry-run listing in the learning fixture.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “Deletion previews should stop before target assumptions”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A junction classification can trigger a review before a recursive delete chooses its scope.?”, and “Can you make a smaller example of using the guard as proof that every deletion API behaves identically?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Write a deletion preview report. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Use platform documentation for any real removal operation. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Deletion previews should stop before target assumptions” means the learner can predict the ordinary case, recognise using the guard as proof that every deletion API behaves identically, diagnose the earliest mistaken assumption, recover with “Perform only dry-run listing in the learning fixture.” and defend this decision: Use platform documentation for any real removal operation. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A positive junction fixture cannot be validated on a platform that does not support Windows junctions. That is the invariant to preserve when names, data or surrounding project details change.

A mock can test branching code but not operating-system metadata. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is mocking a Boolean and calling the filesystem contract tested. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

import os, pytest
pytestmark=pytest.mark.skipif(os.name!='nt', reason='Windows junction fixture')

Read the trace, not just the last line

Trace platform gate, fixture capability and assertion layer. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “Non-Windows tests should skip positive assertions honestly”, separate contract from coincidence. The contract is “A positive junction fixture cannot be validated on a platform that does not support Windows junctions.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Separate pure decision tests from Windows integration tests.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “Non-Windows tests should skip positive assertions honestly” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “A positive junction fixture cannot be validated on a platform that does not support Windows junctions.” should remain invariant and what observation would expose mocking a Boolean and calling the filesystem contract tested.

Case 2: photo-library alias check. Contrast “Non-Windows tests should skip positive assertions honestly” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “A positive junction fixture cannot be validated on a platform that does not support Windows junctions.” should remain invariant and what observation would expose mocking a Boolean and calling the filesystem contract tested.

Case 3: science-data archive. Stress-test “Non-Windows tests should skip positive assertions honestly” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “A positive junction fixture cannot be validated on a platform that does not support Windows junctions.” should remain invariant and what observation would expose mocking a Boolean and calling the filesystem contract tested.

Case 4: backup verification task. Explain “Non-Windows tests should skip positive assertions honestly” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “A positive junction fixture cannot be validated on a platform that does not support Windows junctions.” should remain invariant and what observation would expose mocking a Boolean and calling the filesystem contract tested.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals mocking a Boolean and calling the filesystem contract tested.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Separate pure decision tests from Windows integration tests.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “Non-Windows tests should skip positive assertions honestly”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A positive junction fixture cannot be validated on a platform that does not support Windows junctions.?”, and “Can you make a smaller example of mocking a Boolean and calling the filesystem contract tested?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Plan CI coverage. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

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

Mastery of “Non-Windows tests should skip positive assertions honestly” means the learner can predict the ordinary case, recognise mocking a Boolean and calling the filesystem contract tested, diagnose the earliest mistaken assumption, recover with “Separate pure decision tests from Windows integration tests.” and defend this decision: Match test claims to observed layers. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

A useful report records Python version, operating system and the safely labelled path role. That is the invariant to preserve when names, data or surrounding project details change.

Diagnostics can be specific without exposing a pupil name or home directory. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is publishing full private filesystem paths to gain context. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

import os, sys
print(sys.version_info[:3], os.name)

Read the trace, not just the last line

Trace runtime facts and classification without sensitive path text. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “Version and platform belong in diagnostics”, separate contract from coincidence. The contract is “A useful report records Python version, operating system and the safely labelled path role.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Use synthetic labels and redacted roots.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “Version and platform belong in diagnostics” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “A useful report records Python version, operating system and the safely labelled path role.” should remain invariant and what observation would expose publishing full private filesystem paths to gain context.

Case 2: photo-library alias check. Contrast “Version and platform belong in diagnostics” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “A useful report records Python version, operating system and the safely labelled path role.” should remain invariant and what observation would expose publishing full private filesystem paths to gain context.

Case 3: science-data archive. Stress-test “Version and platform belong in diagnostics” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “A useful report records Python version, operating system and the safely labelled path role.” should remain invariant and what observation would expose publishing full private filesystem paths to gain context.

Case 4: backup verification task. Explain “Version and platform belong in diagnostics” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “A useful report records Python version, operating system and the safely labelled path role.” should remain invariant and what observation would expose publishing full private filesystem paths to gain context.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals publishing full private filesystem paths to gain context.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Use synthetic labels and redacted roots.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “Version and platform belong in diagnostics”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests A useful report records Python version, operating system and the safely labelled path role.?”, and “Can you make a smaller example of publishing full private filesystem paths to gain context?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Write a privacy-safe failure record. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

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

Mastery of “Version and platform belong in diagnostics” means the learner can predict the ordinary case, recognise publishing full private filesystem paths to gain context, diagnose the earliest mistaken assumption, recover with “Use synthetic labels and redacted roots.” and defend this decision: Collect only evidence needed for repair. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

Filesystem state can change after is_junction returns. That is the invariant to preserve when names, data or surrounding project details change.

Time-of-check and time-of-use are separate events. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is treating a check as a permanent security guarantee. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

was_junction=path.is_junction()
# state may change before a later operation

Read the trace, not just the last line

Trace check time and later use time. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “Repeated classification is not a frozen guarantee”, separate contract from coincidence. The contract is “Filesystem state can change after is_junction returns.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “Keep learning examples single-process and minimise the gap before a related safe action.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “Repeated classification is not a frozen guarantee” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “Filesystem state can change after is_junction returns.” should remain invariant and what observation would expose treating a check as a permanent security guarantee.

Case 2: photo-library alias check. Contrast “Repeated classification is not a frozen guarantee” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “Filesystem state can change after is_junction returns.” should remain invariant and what observation would expose treating a check as a permanent security guarantee.

Case 3: science-data archive. Stress-test “Repeated classification is not a frozen guarantee” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “Filesystem state can change after is_junction returns.” should remain invariant and what observation would expose treating a check as a permanent security guarantee.

Case 4: backup verification task. Explain “Repeated classification is not a frozen guarantee” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “Filesystem state can change after is_junction returns.” should remain invariant and what observation would expose treating a check as a permanent security guarantee.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals treating a check as a permanent security guarantee.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: Keep learning examples single-process and minimise the gap before a related safe action.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “Repeated classification is not a frozen guarantee”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests Filesystem state can change after is_junction returns.?”, and “Can you make a smaller example of treating a check as a permanent security guarantee?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Describe a retargeting race conceptually. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Use stronger platform primitives for high-stakes guarantees. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Repeated classification is not a frozen guarantee” means the learner can predict the ordinary case, recognise treating a check as a permanent security guarantee, diagnose the earliest mistaken assumption, recover with “Keep learning examples single-process and minimise the gap before a related safe action.” and defend this decision: Use stronger platform primitives for high-stakes guarantees. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

is_junction, is_symlink, is_mount, is_dir and exists each answer a different question. That is the invariant to preserve when names, data or surrounding project details change.

Accurate tools keep neighbouring concepts separate. The useful question is not “Which line should I copy?” but “Which state, value or rendering decision does this operation control?” Answering that question prevents a correct-looking result from hiding a wrong mental model.

The most revealing near-miss is using one predicate as a universal path classifier. A learner should predict the result first, run the smallest safe case, label the observation and explain the earliest point where the prediction diverges. This turns an error into evidence rather than a verdict on ability.

Core worked example

checks={'junction':p.is_junction(),'symlink':p.is_symlink(),'mount':p.is_mount(),'dir':p.is_dir()}

Read the trace, not just the last line

Trace reader job to documented predicate and boundary. Write the trace as a sequence of labelled states. For Python pathlib.Path.is_junction, inspect resolved pathnames, stat identities, exception types and before-and-after directory listings; a single final value can hide the mechanism that produced it.

For “Choose the path predicate by reader job”, separate contract from coincidence. The contract is “is_junction, is_symlink, is_mount, is_dir and exists each answer a different question.” and comes from the primary specification or manual. Coincidence is what happened on one machine, font, filesystem or repository. Record both, then use “State the policy question before selecting predicates.” to decide whether another observation challenges the model or merely reflects the environment.

Four purposeful transfer cases

Case 1: homework export guard. Model “Choose the path predicate by reader job” with an input document, two path spellings and a proposed output. Before touching a tool, state which part of the case corresponds to the input, why “is_junction, is_symlink, is_mount, is_dir and exists each answer a different question.” should remain invariant and what observation would expose using one predicate as a universal path classifier.

Case 2: photo-library alias check. Contrast “Choose the path predicate by reader job” with original files, hard-link aliases and independent copies. Before touching a tool, state which part of the case corresponds to the input, why “is_junction, is_symlink, is_mount, is_dir and exists each answer a different question.” should remain invariant and what observation would expose using one predicate as a universal path classifier.

Case 3: science-data archive. Stress-test “Choose the path predicate by reader job” with raw readings, a symlinked working folder and a missing target. Before touching a tool, state which part of the case corresponds to the input, why “is_junction, is_symlink, is_mount, is_dir and exists each answer a different question.” should remain invariant and what observation would expose using one predicate as a universal path classifier.

Case 4: backup verification task. Explain “Choose the path predicate by reader job” with source directories, mounted destinations and privacy-safe diagnostics. Before touching a tool, state which part of the case corresponds to the input, why “is_junction, is_symlink, is_mount, is_dir and exists each answer a different question.” should remain invariant and what observation would expose using one predicate as a universal path classifier.

Diagnostic route

• Model check: draw or list the exact values, objects, paths, characters or repository states before the operation.
• Boundary check: construct the smallest safe input that reveals using one predicate as a universal path classifier.
• Evidence check: distinguish a displayed result from ownership, caching, consumption, font behaviour or object type.
• Repair check: State the policy question before selecting predicates.
• Transfer check: repeat the rule in a second context and name what remains unchanged.

A parent does not need to memorise Python pathlib.Path.is_junction to support “Choose the path predicate by reader job”. Useful prompts are: “What did you expect?”, “Which state changed first?”, “What evidence tests is_junction, is_symlink, is_mount, is_dir and exists each answer a different question.?”, and “Can you make a smaller example of using one predicate as a universal path classifier?” These questions keep ownership with the learner while making the reasoning visible.

Practice with an explained answer

Task. Choose predicates for a traversal boundary report. Write the prediction before running anything. Include one ordinary case and one boundary case, then explain the difference in two causal sentences.

Decision and transfer

Prefer the narrowest documented classifier that proves the needed fact. Prefer the choice whose semantics and failure modes are easiest to explain for the actual job. Shorter syntax is useful only when it preserves that clarity.

Mastery of “Choose the path predicate by reader job” means the learner can predict the ordinary case, recognise using one predicate as a universal path classifier, diagnose the earliest mistaken assumption, recover with “State the policy question before selecting predicates.” and defend this decision: Prefer the narrowest documented classifier that proves the needed fact. Once that causal chain is stable, continue to the next chapter rather than adding repetitions of the same surface exercise.

Previous section · Contents · Next section

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

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

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

1. Classify three paths

Compare an ordinary directory, file and controlled junction. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

2. Set a version floor

Record the Python version and feature availability. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

3. Separate neighbouring predicates

Build a junction, symlink, mount and directory table. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

4. Fence a directory walk

Stop or log before crossing a junction. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

5. Write a deletion preview

Report the boundary without mutating anything. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

6. Design Windows integration coverage

Separate mocks, portable negatives and Windows positives. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

7. Protect private paths

Create a useful report with synthetic labels. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

8. Choose the correct classifier

Defend one predicate set for four path-management jobs. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Frequently asked questions

How long should a practice session be?

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

Should every option or method be memorised?

No. For Python pathlib.Path.is_junction, memorise governing distinctions and practise retrieving the primary reference. Understanding means predicting and explaining, not reciting a parameter list.

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

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

Is the shortest solution the best?

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

When should the official reference be used?

Use it whenever Python pathlib.Path.is_junction syntax, supported values, version behaviour or implementation boundaries matter. The primary source settles the current contract.

How can a parent help without technical expertise?

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

How do we test transfer?

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

What should be saved after practice?

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

Can these exercises replace backups?

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

What counts as mastery?

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

Primary and supporting references

• Primary technical source for Python pathlib.Path.is_junction
• eduKatePunggol: How Studying Works

Return to contents