When a learner can reproduce a familiar example but a small variation causes confusion, the problem is usually an incomplete model rather than a lack of effort. The fastest useful response is to expose the hidden state and test one boundary at a time.
Python weakref lets one part of a program observe or index an object without becoming an owner that keeps the object alive. Mastery means distinguishing identity from ownership, calling a weak reference safely, preventing callbacks from capturing the referent, choosing among WeakValueDictionary, WeakKeyDictionary, WeakSet, WeakMethod and finalize, and using ordinary strong references whenever the relationship is genuinely responsible for the object’s lifetime. This guide begins with that mechanism, then develops it through worked traces, deliberate mistakes, explained practice and transfer decisions.
The aim is independent reasoning. A learner should be able to predict behaviour, locate the earliest wrong assumption, use a safe diagnostic procedure and defend a design choice in a new project.
Punggol families can use the guide in short sessions around homework, CCAs and rest. The activities are proposed learning exercises, not claims about a physical branch, timetable, class size, fee, school relationship or guaranteed result.
Use disposable data and repositories, preserve backups, and check version-sensitive details against the official source. Current documentation settles a technical contract; observation and explanation turn that contract into usable knowledge.
Find your next learning step
Choose the route that matches the present difficulty. Use the complete index for a systematic course.
Build the model
Chapters 1-4 . Begin here, then continue after the learner can predict, verify and explain.
Use the core tools
Chapters 5-8 . Begin here, then continue after the learner can predict, verify and explain.
Handle boundaries
Chapters 9-12 . Begin here, then continue after the learner can predict, verify and explain.
Debug and verify
Chapters 13-16 . Begin here, then continue after the learner can predict, verify and explain.
Transfer with judgment
Chapters 17-20 . Begin here, then continue after the learner can predict, verify and explain.
Open the full chapter index . Jump to capstone practice . Use the How Studying Works hub . Read the official documentation
Complete chapter index
Chapters 1-4 . Build the model
Chapters 5-8 . Use the core tools
Chapters 9-12 . Handle boundaries
Chapters 13-16 . Debug and verify
weakref.ref creates a reference that does not increase the referent’s strong-reference count and therefore does not decide its lifetime. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is calling a weak reference a smaller strong reference. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Draw every strong owner first, then add the weak observer and remove one strong edge at a time.
For the A weak reference observes without owning chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on calling a weak reference a smaller strong reference. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
import weakref
class Note: pass
note=Note(); handle=weakref.ref(note)Explained result. handle can observe note while note is alive, but handle alone will not preserve the Note instance. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: revision cache. Predict the rule using parsed study notes reused only while another owner still needs them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.ref creates a reference that does not increase the referent’s strong-reference count and therefore does not decide its lifetime.” Apply this procedure: Draw every strong owner first, then add the weak observer and remove one strong edge at a time. The expected mechanism is: handle can observe note while note is alive, but handle alone will not preserve the Note instance. For the revision cache, add one near-miss that exposes calling a weak reference a smaller strong reference. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: family photo index. Contrast the rule using metadata records pointing to images without owning their lifetime. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.ref creates a reference that does not increase the referent’s strong-reference count and therefore does not decide its lifetime.” Apply this procedure: Draw every strong owner first, then add the weak observer and remove one strong edge at a time. The expected mechanism is: handle can observe note while note is alive, but handle alone will not preserve the Note instance. For the family photo index, add one near-miss that exposes calling a weak reference a smaller strong reference. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: CCA roster. Stress-test the rule using temporary participant objects indexed without creating a hidden retention leak. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.ref creates a reference that does not increase the referent’s strong-reference count and therefore does not decide its lifetime.” Apply this procedure: Draw every strong owner first, then add the weak observer and remove one strong edge at a time. The expected mechanism is: handle can observe note while note is alive, but handle alone will not preserve the Note instance. For the CCA roster, add one near-miss that exposes calling a weak reference a smaller strong reference. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: science model. Explain the rule using large simulation objects watched through diagnostic handles. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.ref creates a reference that does not increase the referent’s strong-reference count and therefore does not decide its lifetime.” Apply this procedure: Draw every strong owner first, then add the weak observer and remove one strong edge at a time. The expected mechanism is: handle can observe note while note is alive, but handle alone will not preserve the Note instance. For the science model, add one near-miss that exposes calling a weak reference a smaller strong reference. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers calling a weak reference a smaller strong reference.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Draw every strong owner first, then add the weak observer and remove one strong edge at a time.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from A weak reference observes without owning?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing calling a weak reference a smaller strong reference be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny resource receipt with cleanup intent recorded without a callback retaining the resource. Include one ordinary case, one boundary and one deliberate failure caused by calling a weak reference a smaller strong reference. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: weakref.ref creates a reference that does not increase the referent’s strong-reference count and therefore does not decide its lifetime. It shows a trace, not only a final value. The ordinary case should demonstrate “handle can observe note while note is alive, but handle alone will not preserve the Note instance.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Draw every strong owner first, then add the weak observer and remove one strong edge at a time. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For A weak reference observes without owning, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
class instances and several built-in types support weak references, while common built-ins such as list, dict, tuple and int have important restrictions documented by the runtime. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is assuming every Python value accepts weakref.ref. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Probe the exact runtime type in a disposable example and treat TypeError as a type-capability boundary.
For the Only weak-referenceable objects can be targets chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming every Python value accepts weakref.ref. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
import weakref
weakref.ref([])Explained result. A plain list raises TypeError rather than silently becoming weakly referenced. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: CCA roster. Contrast the rule using temporary participant objects indexed without creating a hidden retention leak. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “class instances and several built-in types support weak references, while common built-ins such as list, dict, tuple and int have important restrictions documented by the runtime.” Apply this procedure: Probe the exact runtime type in a disposable example and treat TypeError as a type-capability boundary. The expected mechanism is: A plain list raises TypeError rather than silently becoming weakly referenced. For the CCA roster, add one near-miss that exposes assuming every Python value accepts weakref.ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: science model. Stress-test the rule using large simulation objects watched through diagnostic handles. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “class instances and several built-in types support weak references, while common built-ins such as list, dict, tuple and int have important restrictions documented by the runtime.” Apply this procedure: Probe the exact runtime type in a disposable example and treat TypeError as a type-capability boundary. The expected mechanism is: A plain list raises TypeError rather than silently becoming weakly referenced. For the science model, add one near-miss that exposes assuming every Python value accepts weakref.ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: event listeners. Explain the rule using bound methods observed without preserving abandoned screens. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “class instances and several built-in types support weak references, while common built-ins such as list, dict, tuple and int have important restrictions documented by the runtime.” Apply this procedure: Probe the exact runtime type in a disposable example and treat TypeError as a type-capability boundary. The expected mechanism is: A plain list raises TypeError rather than silently becoming weakly referenced. For the event listeners, add one near-miss that exposes assuming every Python value accepts weakref.ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: resource receipt. Transfer the rule using cleanup intent recorded without a callback retaining the resource. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “class instances and several built-in types support weak references, while common built-ins such as list, dict, tuple and int have important restrictions documented by the runtime.” Apply this procedure: Probe the exact runtime type in a disposable example and treat TypeError as a type-capability boundary. The expected mechanism is: A plain list raises TypeError rather than silently becoming weakly referenced. For the resource receipt, add one near-miss that exposes assuming every Python value accepts weakref.ref. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers assuming every Python value accepts weakref.ref.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Probe the exact runtime type in a disposable example and treat TypeError as a type-capability boundary.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from Only weak-referenceable objects can be targets?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming every Python value accepts weakref.ref be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny identity laboratory with equal and identical objects traced before and after collection. Include one ordinary case, one boundary and one deliberate failure caused by assuming every Python value accepts weakref.ref. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: class instances and several built-in types support weak references, while common built-ins such as list, dict, tuple and int have important restrictions documented by the runtime. It shows a trace, not only a final value. The ordinary case should demonstrate “A plain list raises TypeError rather than silently becoming weakly referenced.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Probe the exact runtime type in a disposable example and treat TypeError as a type-capability boundary. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Only weak-referenceable objects can be targets, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
a weak reference object is callable and returns the live referent, or None after the referent is no longer alive. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is testing handle is not None and confusing the weakref object with its referent. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Call the weak reference once and branch on that returned value.
For the Calling ref returns the object or None chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on testing handle is not None and confusing the weakref object with its referent. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
obj=handle()
if obj is not None: print(obj)Explained result. The local obj becomes a temporary strong reference for the work inside this branch. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: event listeners. Stress-test the rule using bound methods observed without preserving abandoned screens. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a weak reference object is callable and returns the live referent, or None after the referent is no longer alive.” Apply this procedure: Call the weak reference once and branch on that returned value. The expected mechanism is: The local obj becomes a temporary strong reference for the work inside this branch. For the event listeners, add one near-miss that exposes testing handle is not None and confusing the weakref object with its referent. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: resource receipt. Explain the rule using cleanup intent recorded without a callback retaining the resource. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a weak reference object is callable and returns the live referent, or None after the referent is no longer alive.” Apply this procedure: Call the weak reference once and branch on that returned value. The expected mechanism is: The local obj becomes a temporary strong reference for the work inside this branch. For the resource receipt, add one near-miss that exposes testing handle is not None and confusing the weakref object with its referent. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: identity laboratory. Transfer the rule using equal and identical objects traced before and after collection. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a weak reference object is callable and returns the live referent, or None after the referent is no longer alive.” Apply this procedure: Call the weak reference once and branch on that returned value. The expected mechanism is: The local obj becomes a temporary strong reference for the work inside this branch. For the identity laboratory, add one near-miss that exposes testing handle is not None and confusing the weakref object with its referent. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: concurrency fixture. Predict the rule using one-call dereferencing used while another task can release ownership. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a weak reference object is callable and returns the live referent, or None after the referent is no longer alive.” Apply this procedure: Call the weak reference once and branch on that returned value. The expected mechanism is: The local obj becomes a temporary strong reference for the work inside this branch. For the concurrency fixture, add one near-miss that exposes testing handle is not None and confusing the weakref object with its referent. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers testing handle is not None and confusing the weakref object with its referent.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Call the weak reference once and branch on that returned value.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from Calling ref returns the object or None?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing testing handle is not None and confusing the weakref object with its referent be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny concurrency fixture with one-call dereferencing used while another task can release ownership. Include one ordinary case, one boundary and one deliberate failure caused by testing handle is not None and confusing the weakref object with its referent. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: a weak reference object is callable and returns the live referent, or None after the referent is no longer alive. It shows a trace, not only a final value. The ordinary case should demonstrate “The local obj becomes a temporary strong reference for the work inside this branch.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Call the weak reference once and branch on that returned value. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Calling ref returns the object or None, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
checking handle() and then calling handle() again permits the referent to disappear between the two calls in threaded code. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is using a separate liveness test before retrieval. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Assign handle() once, test the assigned object and keep it only for the smallest necessary scope.
For the One-call dereferencing closes a race window chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using a separate liveness test before retrieval. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
obj=handle()
if obj is None: returnExplained result. The successful call both tests liveness and obtains the temporary strong owner used next. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: identity laboratory. Explain the rule using equal and identical objects traced before and after collection. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “checking handle() and then calling handle() again permits the referent to disappear between the two calls in threaded code.” Apply this procedure: Assign handle() once, test the assigned object and keep it only for the smallest necessary scope. The expected mechanism is: The successful call both tests liveness and obtains the temporary strong owner used next. For the identity laboratory, add one near-miss that exposes using a separate liveness test before retrieval. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: concurrency fixture. Transfer the rule using one-call dereferencing used while another task can release ownership. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “checking handle() and then calling handle() again permits the referent to disappear between the two calls in threaded code.” Apply this procedure: Assign handle() once, test the assigned object and keep it only for the smallest necessary scope. The expected mechanism is: The successful call both tests liveness and obtains the temporary strong owner used next. For the concurrency fixture, add one near-miss that exposes using a separate liveness test before retrieval. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: revision cache. Predict the rule using parsed study notes reused only while another owner still needs them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “checking handle() and then calling handle() again permits the referent to disappear between the two calls in threaded code.” Apply this procedure: Assign handle() once, test the assigned object and keep it only for the smallest necessary scope. The expected mechanism is: The successful call both tests liveness and obtains the temporary strong owner used next. For the revision cache, add one near-miss that exposes using a separate liveness test before retrieval. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: family photo index. Contrast the rule using metadata records pointing to images without owning their lifetime. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “checking handle() and then calling handle() again permits the referent to disappear between the two calls in threaded code.” Apply this procedure: Assign handle() once, test the assigned object and keep it only for the smallest necessary scope. The expected mechanism is: The successful call both tests liveness and obtains the temporary strong owner used next. For the family photo index, add one near-miss that exposes using a separate liveness test before retrieval. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers using a separate liveness test before retrieval.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Assign handle() once, test the assigned object and keep it only for the smallest necessary scope.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from One-call dereferencing closes a race window?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using a separate liveness test before retrieval be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny revision cache with parsed study notes reused only while another owner still needs them. Include one ordinary case, one boundary and one deliberate failure caused by using a separate liveness test before retrieval. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: checking handle() and then calling handle() again permits the referent to disappear between the two calls in threaded code. It shows a trace, not only a final value. The ordinary case should demonstrate “The successful call both tests liveness and obtains the temporary strong owner used next.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Assign handle() once, test the assigned object and keep it only for the smallest necessary scope. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For One-call dereferencing closes a race window, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 5 OF 20 . Use the core tools
5. A callback observes finalization without the referent
weakref.ref can receive a callback that is invoked with the weak reference when the referent is about to be finalized, after the referent is unavailable. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is trying to recover the dying object from callback_handle(). It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Pass only independent identifiers or state to the callback and expect callback_handle() to return None.
For the A callback observes finalization without the referent chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on trying to recover the dying object from callback_handle(). Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
events=[]
handle=weakref.ref(note,lambda r: events.append('gone'))Explained result. The callback records disappearance; it is not a last chance to use note. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: revision cache. Transfer the rule using parsed study notes reused only while another owner still needs them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.ref can receive a callback that is invoked with the weak reference when the referent is about to be finalized, after the referent is unavailable.” Apply this procedure: Pass only independent identifiers or state to the callback and expect callback_handle() to return None. The expected mechanism is: The callback records disappearance; it is not a last chance to use note. For the revision cache, add one near-miss that exposes trying to recover the dying object from callback_handle(). The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: family photo index. Predict the rule using metadata records pointing to images without owning their lifetime. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.ref can receive a callback that is invoked with the weak reference when the referent is about to be finalized, after the referent is unavailable.” Apply this procedure: Pass only independent identifiers or state to the callback and expect callback_handle() to return None. The expected mechanism is: The callback records disappearance; it is not a last chance to use note. For the family photo index, add one near-miss that exposes trying to recover the dying object from callback_handle(). The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: CCA roster. Contrast the rule using temporary participant objects indexed without creating a hidden retention leak. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.ref can receive a callback that is invoked with the weak reference when the referent is about to be finalized, after the referent is unavailable.” Apply this procedure: Pass only independent identifiers or state to the callback and expect callback_handle() to return None. The expected mechanism is: The callback records disappearance; it is not a last chance to use note. For the CCA roster, add one near-miss that exposes trying to recover the dying object from callback_handle(). The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: science model. Stress-test the rule using large simulation objects watched through diagnostic handles. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.ref can receive a callback that is invoked with the weak reference when the referent is about to be finalized, after the referent is unavailable.” Apply this procedure: Pass only independent identifiers or state to the callback and expect callback_handle() to return None. The expected mechanism is: The callback records disappearance; it is not a last chance to use note. For the science model, add one near-miss that exposes trying to recover the dying object from callback_handle(). The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers trying to recover the dying object from callback_handle().
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Pass only independent identifiers or state to the callback and expect callback_handle() to return None.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from A callback observes finalization without the referent?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing trying to recover the dying object from callback_handle() be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny family photo index with metadata records pointing to images without owning their lifetime. Include one ordinary case, one boundary and one deliberate failure caused by trying to recover the dying object from callback_handle(). Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: weakref.ref can receive a callback that is invoked with the weak reference when the referent is about to be finalized, after the referent is unavailable. It shows a trace, not only a final value. The ordinary case should demonstrate “The callback records disappearance; it is not a last chance to use note.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Pass only independent identifiers or state to the callback and expect callback_handle() to return None. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For A callback observes finalization without the referent, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 6 OF 20 . Use the core tools
6. Callback exceptions do not propagate to the caller
exceptions raised by a weakref callback are written to standard error and handled like exceptions from __del__, not delivered through the operation that released the final owner. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is using callback failure as an application control-flow signal. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Keep callbacks tiny, catch expected failures locally and test their observable side effects.
For the Callback exceptions do not propagate to the caller chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using callback failure as an application control-flow signal. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
def on_gone(ref):
try: audit()
except OSError as exc: log(exc)Explained result. The callback handles its own recoverable error instead of promising propagation to unrelated code. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: CCA roster. Predict the rule using temporary participant objects indexed without creating a hidden retention leak. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “exceptions raised by a weakref callback are written to standard error and handled like exceptions from __del__, not delivered through the operation that released the final owner.” Apply this procedure: Keep callbacks tiny, catch expected failures locally and test their observable side effects. The expected mechanism is: The callback handles its own recoverable error instead of promising propagation to unrelated code. For the CCA roster, add one near-miss that exposes using callback failure as an application control-flow signal. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: science model. Contrast the rule using large simulation objects watched through diagnostic handles. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “exceptions raised by a weakref callback are written to standard error and handled like exceptions from __del__, not delivered through the operation that released the final owner.” Apply this procedure: Keep callbacks tiny, catch expected failures locally and test their observable side effects. The expected mechanism is: The callback handles its own recoverable error instead of promising propagation to unrelated code. For the science model, add one near-miss that exposes using callback failure as an application control-flow signal. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: event listeners. Stress-test the rule using bound methods observed without preserving abandoned screens. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “exceptions raised by a weakref callback are written to standard error and handled like exceptions from __del__, not delivered through the operation that released the final owner.” Apply this procedure: Keep callbacks tiny, catch expected failures locally and test their observable side effects. The expected mechanism is: The callback handles its own recoverable error instead of promising propagation to unrelated code. For the event listeners, add one near-miss that exposes using callback failure as an application control-flow signal. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: resource receipt. Explain the rule using cleanup intent recorded without a callback retaining the resource. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “exceptions raised by a weakref callback are written to standard error and handled like exceptions from __del__, not delivered through the operation that released the final owner.” Apply this procedure: Keep callbacks tiny, catch expected failures locally and test their observable side effects. The expected mechanism is: The callback handles its own recoverable error instead of promising propagation to unrelated code. For the resource receipt, add one near-miss that exposes using callback failure as an application control-flow signal. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers using callback failure as an application control-flow signal.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Keep callbacks tiny, catch expected failures locally and test their observable side effects.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from Callback exceptions do not propagate to the caller?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using callback failure as an application control-flow signal be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny CCA roster with temporary participant objects indexed without creating a hidden retention leak. Include one ordinary case, one boundary and one deliberate failure caused by using callback failure as an application control-flow signal. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: exceptions raised by a weakref callback are written to standard error and handled like exceptions from __del__, not delivered through the operation that released the final owner. It shows a trace, not only a final value. The ordinary case should demonstrate “The callback handles its own recoverable error instead of promising propagation to unrelated code.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Keep callbacks tiny, catch expected failures locally and test their observable side effects. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Callback exceptions do not propagate to the caller, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 7 OF 20 . Use the core tools
7. Callbacks run from newest registration to oldest
when several weak references to one object have callbacks, the most recently registered callback is invoked first. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is depending on creation order as if callbacks were a durable workflow engine. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Record registration order and make every callback independently safe and idempotent.
For the Callbacks run from newest registration to oldest chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on depending on creation order as if callbacks were a durable workflow engine. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
a=weakref.ref(note,lambda r: log('old'))
b=weakref.ref(note,lambda r: log('new'))Explained result. If both weakref objects remain alive, new is observed before old when note is finalized. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: event listeners. Contrast the rule using bound methods observed without preserving abandoned screens. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “when several weak references to one object have callbacks, the most recently registered callback is invoked first.” Apply this procedure: Record registration order and make every callback independently safe and idempotent. The expected mechanism is: If both weakref objects remain alive, new is observed before old when note is finalized. For the event listeners, add one near-miss that exposes depending on creation order as if callbacks were a durable workflow engine. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: resource receipt. Stress-test the rule using cleanup intent recorded without a callback retaining the resource. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “when several weak references to one object have callbacks, the most recently registered callback is invoked first.” Apply this procedure: Record registration order and make every callback independently safe and idempotent. The expected mechanism is: If both weakref objects remain alive, new is observed before old when note is finalized. For the resource receipt, add one near-miss that exposes depending on creation order as if callbacks were a durable workflow engine. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: identity laboratory. Explain the rule using equal and identical objects traced before and after collection. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “when several weak references to one object have callbacks, the most recently registered callback is invoked first.” Apply this procedure: Record registration order and make every callback independently safe and idempotent. The expected mechanism is: If both weakref objects remain alive, new is observed before old when note is finalized. For the identity laboratory, add one near-miss that exposes depending on creation order as if callbacks were a durable workflow engine. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: concurrency fixture. Transfer the rule using one-call dereferencing used while another task can release ownership. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “when several weak references to one object have callbacks, the most recently registered callback is invoked first.” Apply this procedure: Record registration order and make every callback independently safe and idempotent. The expected mechanism is: If both weakref objects remain alive, new is observed before old when note is finalized. For the concurrency fixture, add one near-miss that exposes depending on creation order as if callbacks were a durable workflow engine. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers depending on creation order as if callbacks were a durable workflow engine.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Record registration order and make every callback independently safe and idempotent.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from Callbacks run from newest registration to oldest?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing depending on creation order as if callbacks were a durable workflow engine be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny science model with large simulation objects watched through diagnostic handles. Include one ordinary case, one boundary and one deliberate failure caused by depending on creation order as if callbacks were a durable workflow engine. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: when several weak references to one object have callbacks, the most recently registered callback is invoked first. It shows a trace, not only a final value. The ordinary case should demonstrate “If both weakref objects remain alive, new is observed before old when note is finalized.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Record registration order and make every callback independently safe and idempotent. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Callbacks run from newest registration to oldest, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
a closure, bound method or argument that strongly references the target can keep it alive and defeat the weak relationship. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is writing lambda r: target.close() and expecting target to disappear. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Inspect closure cells and callback arguments for a path back to the target.
For the A callback must not capture the referent chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on writing lambda r: target.close() and expecting target to disappear. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
token=note.id
handle=weakref.ref(note,lambda r,t=token: log(t))Explained result. The callback retains only an independent token, not the Note instance. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: identity laboratory. Stress-test the rule using equal and identical objects traced before and after collection. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a closure, bound method or argument that strongly references the target can keep it alive and defeat the weak relationship.” Apply this procedure: Inspect closure cells and callback arguments for a path back to the target. The expected mechanism is: The callback retains only an independent token, not the Note instance. For the identity laboratory, add one near-miss that exposes writing lambda r: target.close() and expecting target to disappear. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: concurrency fixture. Explain the rule using one-call dereferencing used while another task can release ownership. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a closure, bound method or argument that strongly references the target can keep it alive and defeat the weak relationship.” Apply this procedure: Inspect closure cells and callback arguments for a path back to the target. The expected mechanism is: The callback retains only an independent token, not the Note instance. For the concurrency fixture, add one near-miss that exposes writing lambda r: target.close() and expecting target to disappear. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: revision cache. Transfer the rule using parsed study notes reused only while another owner still needs them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a closure, bound method or argument that strongly references the target can keep it alive and defeat the weak relationship.” Apply this procedure: Inspect closure cells and callback arguments for a path back to the target. The expected mechanism is: The callback retains only an independent token, not the Note instance. For the revision cache, add one near-miss that exposes writing lambda r: target.close() and expecting target to disappear. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: family photo index. Predict the rule using metadata records pointing to images without owning their lifetime. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a closure, bound method or argument that strongly references the target can keep it alive and defeat the weak relationship.” Apply this procedure: Inspect closure cells and callback arguments for a path back to the target. The expected mechanism is: The callback retains only an independent token, not the Note instance. For the family photo index, add one near-miss that exposes writing lambda r: target.close() and expecting target to disappear. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers writing lambda r: target.close() and expecting target to disappear.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Inspect closure cells and callback arguments for a path back to the target.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from A callback must not capture the referent?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing writing lambda r: target.close() and expecting target to disappear be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny event listeners with bound methods observed without preserving abandoned screens. Include one ordinary case, one boundary and one deliberate failure caused by writing lambda r: target.close() and expecting target to disappear. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: a closure, bound method or argument that strongly references the target can keep it alive and defeat the weak relationship. It shows a trace, not only a final value. The ordinary case should demonstrate “The callback retains only an independent token, not the Note instance.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Inspect closure cells and callback arguments for a path back to the target. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For A callback must not capture the referent, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
weakref.proxy offers transparent-looking attribute access while the target lives and raises ReferenceError after collection. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is treating a proxy as proof the object remains available across a long operation. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Catch ReferenceError only at a boundary that can recover, or prefer explicit ref() when absence is normal.
For the proxy forwards access but can fail later chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on treating a proxy as proof the object remains available across a long operation. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
view=weakref.proxy(note)
print(view.title)Explained result. Attribute access reaches the live target, but the proxy does not become an owner. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: revision cache. Explain the rule using parsed study notes reused only while another owner still needs them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.proxy offers transparent-looking attribute access while the target lives and raises ReferenceError after collection.” Apply this procedure: Catch ReferenceError only at a boundary that can recover, or prefer explicit ref() when absence is normal. The expected mechanism is: Attribute access reaches the live target, but the proxy does not become an owner. For the revision cache, add one near-miss that exposes treating a proxy as proof the object remains available across a long operation. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: family photo index. Transfer the rule using metadata records pointing to images without owning their lifetime. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.proxy offers transparent-looking attribute access while the target lives and raises ReferenceError after collection.” Apply this procedure: Catch ReferenceError only at a boundary that can recover, or prefer explicit ref() when absence is normal. The expected mechanism is: Attribute access reaches the live target, but the proxy does not become an owner. For the family photo index, add one near-miss that exposes treating a proxy as proof the object remains available across a long operation. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: CCA roster. Predict the rule using temporary participant objects indexed without creating a hidden retention leak. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.proxy offers transparent-looking attribute access while the target lives and raises ReferenceError after collection.” Apply this procedure: Catch ReferenceError only at a boundary that can recover, or prefer explicit ref() when absence is normal. The expected mechanism is: Attribute access reaches the live target, but the proxy does not become an owner. For the CCA roster, add one near-miss that exposes treating a proxy as proof the object remains available across a long operation. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: science model. Contrast the rule using large simulation objects watched through diagnostic handles. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.proxy offers transparent-looking attribute access while the target lives and raises ReferenceError after collection.” Apply this procedure: Catch ReferenceError only at a boundary that can recover, or prefer explicit ref() when absence is normal. The expected mechanism is: Attribute access reaches the live target, but the proxy does not become an owner. For the science model, add one near-miss that exposes treating a proxy as proof the object remains available across a long operation. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers treating a proxy as proof the object remains available across a long operation.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Catch ReferenceError only at a boundary that can recover, or prefer explicit ref() when absence is normal.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from proxy forwards access but can fail later?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating a proxy as proof the object remains available across a long operation be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny resource receipt with cleanup intent recorded without a callback retaining the resource. Include one ordinary case, one boundary and one deliberate failure caused by treating a proxy as proof the object remains available across a long operation. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: weakref.proxy offers transparent-looking attribute access while the target lives and raises ReferenceError after collection. It shows a trace, not only a final value. The ordinary case should demonstrate “Attribute access reaches the live target, but the proxy does not become an owner.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Catch ReferenceError only at a boundary that can recover, or prefer explicit ref() when absence is normal. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For proxy forwards access but can fail later, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
weak-reference proxy objects are not hashable even when their referents are hashable, avoiding unstable dictionary-key behaviour. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is putting a proxy into a set as a lifetime-independent identity. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Store a stable identifier or a weak reference with a documented hash policy instead.
For the Proxies are deliberately unhashable chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on putting a proxy into a set as a lifetime-independent identity. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
hash(weakref.proxy(note))Explained result. The operation raises TypeError rather than promising a hash whose target may vanish. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: CCA roster. Transfer the rule using temporary participant objects indexed without creating a hidden retention leak. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weak-reference proxy objects are not hashable even when their referents are hashable, avoiding unstable dictionary-key behaviour.” Apply this procedure: Store a stable identifier or a weak reference with a documented hash policy instead. The expected mechanism is: The operation raises TypeError rather than promising a hash whose target may vanish. For the CCA roster, add one near-miss that exposes putting a proxy into a set as a lifetime-independent identity. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: science model. Predict the rule using large simulation objects watched through diagnostic handles. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weak-reference proxy objects are not hashable even when their referents are hashable, avoiding unstable dictionary-key behaviour.” Apply this procedure: Store a stable identifier or a weak reference with a documented hash policy instead. The expected mechanism is: The operation raises TypeError rather than promising a hash whose target may vanish. For the science model, add one near-miss that exposes putting a proxy into a set as a lifetime-independent identity. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: event listeners. Contrast the rule using bound methods observed without preserving abandoned screens. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weak-reference proxy objects are not hashable even when their referents are hashable, avoiding unstable dictionary-key behaviour.” Apply this procedure: Store a stable identifier or a weak reference with a documented hash policy instead. The expected mechanism is: The operation raises TypeError rather than promising a hash whose target may vanish. For the event listeners, add one near-miss that exposes putting a proxy into a set as a lifetime-independent identity. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: resource receipt. Stress-test the rule using cleanup intent recorded without a callback retaining the resource. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weak-reference proxy objects are not hashable even when their referents are hashable, avoiding unstable dictionary-key behaviour.” Apply this procedure: Store a stable identifier or a weak reference with a documented hash policy instead. The expected mechanism is: The operation raises TypeError rather than promising a hash whose target may vanish. For the resource receipt, add one near-miss that exposes putting a proxy into a set as a lifetime-independent identity. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers putting a proxy into a set as a lifetime-independent identity.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Store a stable identifier or a weak reference with a documented hash policy instead.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from Proxies are deliberately unhashable?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing putting a proxy into a set as a lifetime-independent identity be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny identity laboratory with equal and identical objects traced before and after collection. Include one ordinary case, one boundary and one deliberate failure caused by putting a proxy into a set as a lifetime-independent identity. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: weak-reference proxy objects are not hashable even when their referents are hashable, avoiding unstable dictionary-key behaviour. It shows a trace, not only a final value. The ordinary case should demonstrate “The operation raises TypeError rather than promising a hash whose target may vanish.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Store a stable identifier or a weak reference with a documented hash policy instead. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Proxies are deliberately unhashable, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 11 OF 20 . Handle boundaries
11. WeakValueDictionary keeps values only while owned elsewhere
WeakValueDictionary maps ordinary keys to weakly held values and removes an entry when its value has no remaining strong owner. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is using the container as the only storage for a result that must persist. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Keep an explicit owner for required values and treat the weak dictionary as an opportunistic cache.
For the WeakValueDictionary keeps values only while owned elsewhere chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using the container as the only storage for a result that must persist. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
cache=weakref.WeakValueDictionary()
cache['chapter']=noteExplained result. The chapter entry can disappear after all strong references to note are released. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: event listeners. Predict the rule using bound methods observed without preserving abandoned screens. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakValueDictionary maps ordinary keys to weakly held values and removes an entry when its value has no remaining strong owner.” Apply this procedure: Keep an explicit owner for required values and treat the weak dictionary as an opportunistic cache. The expected mechanism is: The chapter entry can disappear after all strong references to note are released. For the event listeners, add one near-miss that exposes using the container as the only storage for a result that must persist. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: resource receipt. Contrast the rule using cleanup intent recorded without a callback retaining the resource. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakValueDictionary maps ordinary keys to weakly held values and removes an entry when its value has no remaining strong owner.” Apply this procedure: Keep an explicit owner for required values and treat the weak dictionary as an opportunistic cache. The expected mechanism is: The chapter entry can disappear after all strong references to note are released. For the resource receipt, add one near-miss that exposes using the container as the only storage for a result that must persist. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: identity laboratory. Stress-test the rule using equal and identical objects traced before and after collection. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakValueDictionary maps ordinary keys to weakly held values and removes an entry when its value has no remaining strong owner.” Apply this procedure: Keep an explicit owner for required values and treat the weak dictionary as an opportunistic cache. The expected mechanism is: The chapter entry can disappear after all strong references to note are released. For the identity laboratory, add one near-miss that exposes using the container as the only storage for a result that must persist. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: concurrency fixture. Explain the rule using one-call dereferencing used while another task can release ownership. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakValueDictionary maps ordinary keys to weakly held values and removes an entry when its value has no remaining strong owner.” Apply this procedure: Keep an explicit owner for required values and treat the weak dictionary as an opportunistic cache. The expected mechanism is: The chapter entry can disappear after all strong references to note are released. For the concurrency fixture, add one near-miss that exposes using the container as the only storage for a result that must persist. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers using the container as the only storage for a result that must persist.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Keep an explicit owner for required values and treat the weak dictionary as an opportunistic cache.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from WeakValueDictionary keeps values only while owned elsewhere?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using the container as the only storage for a result that must persist be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny concurrency fixture with one-call dereferencing used while another task can release ownership. Include one ordinary case, one boundary and one deliberate failure caused by using the container as the only storage for a result that must persist. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: WeakValueDictionary maps ordinary keys to weakly held values and removes an entry when its value has no remaining strong owner. It shows a trace, not only a final value. The ordinary case should demonstrate “The chapter entry can disappear after all strong references to note are released.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Keep an explicit owner for required values and treat the weak dictionary as an opportunistic cache. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For WeakValueDictionary keeps values only while owned elsewhere, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
WeakKeyDictionary weakly holds keys while values remain ordinary strong values associated with those live keys. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is assuming an equal replacement key always replaces the stored key identity. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test equal-but-distinct keys and inspect keys() before and after deleting the original.
For the WeakKeyDictionary does not own its keys chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming an equal replacement key always replaces the stored key identity. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
metadata=weakref.WeakKeyDictionary()
metadata[note]={'seen':True}Explained result. The metadata follows the lifetime of the actual stored key object rather than creating ownership of it. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: identity laboratory. Contrast the rule using equal and identical objects traced before and after collection. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakKeyDictionary weakly holds keys while values remain ordinary strong values associated with those live keys.” Apply this procedure: Test equal-but-distinct keys and inspect keys() before and after deleting the original. The expected mechanism is: The metadata follows the lifetime of the actual stored key object rather than creating ownership of it. For the identity laboratory, add one near-miss that exposes assuming an equal replacement key always replaces the stored key identity. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: concurrency fixture. Stress-test the rule using one-call dereferencing used while another task can release ownership. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakKeyDictionary weakly holds keys while values remain ordinary strong values associated with those live keys.” Apply this procedure: Test equal-but-distinct keys and inspect keys() before and after deleting the original. The expected mechanism is: The metadata follows the lifetime of the actual stored key object rather than creating ownership of it. For the concurrency fixture, add one near-miss that exposes assuming an equal replacement key always replaces the stored key identity. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: revision cache. Explain the rule using parsed study notes reused only while another owner still needs them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakKeyDictionary weakly holds keys while values remain ordinary strong values associated with those live keys.” Apply this procedure: Test equal-but-distinct keys and inspect keys() before and after deleting the original. The expected mechanism is: The metadata follows the lifetime of the actual stored key object rather than creating ownership of it. For the revision cache, add one near-miss that exposes assuming an equal replacement key always replaces the stored key identity. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: family photo index. Transfer the rule using metadata records pointing to images without owning their lifetime. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakKeyDictionary weakly holds keys while values remain ordinary strong values associated with those live keys.” Apply this procedure: Test equal-but-distinct keys and inspect keys() before and after deleting the original. The expected mechanism is: The metadata follows the lifetime of the actual stored key object rather than creating ownership of it. For the family photo index, add one near-miss that exposes assuming an equal replacement key always replaces the stored key identity. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers assuming an equal replacement key always replaces the stored key identity.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Test equal-but-distinct keys and inspect keys() before and after deleting the original.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from WeakKeyDictionary does not own its keys?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming an equal replacement key always replaces the stored key identity be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny revision cache with parsed study notes reused only while another owner still needs them. Include one ordinary case, one boundary and one deliberate failure caused by assuming an equal replacement key always replaces the stored key identity. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: WeakKeyDictionary weakly holds keys while values remain ordinary strong values associated with those live keys. It shows a trace, not only a final value. The ordinary case should demonstrate “The metadata follows the lifetime of the actual stored key object rather than creating ownership of it.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Test equal-but-distinct keys and inspect keys() before and after deleting the original. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For WeakKeyDictionary does not own its keys, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
WeakSet stores weak references to its elements, so membership vanishes when an element has no strong owner elsewhere. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is using WeakSet as a registry that promises every participant will remain available. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use it for observation or deduplication of live objects, not durable enrolment.
For the WeakSet tracks membership without retention chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using WeakSet as a registry that promises every participant will remain available. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
live=weakref.WeakSet([note])
assert note in liveExplained result. The assertion describes current liveness; it is not a persistence guarantee. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: revision cache. Stress-test the rule using parsed study notes reused only while another owner still needs them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakSet stores weak references to its elements, so membership vanishes when an element has no strong owner elsewhere.” Apply this procedure: Use it for observation or deduplication of live objects, not durable enrolment. The expected mechanism is: The assertion describes current liveness; it is not a persistence guarantee. For the revision cache, add one near-miss that exposes using WeakSet as a registry that promises every participant will remain available. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: family photo index. Explain the rule using metadata records pointing to images without owning their lifetime. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakSet stores weak references to its elements, so membership vanishes when an element has no strong owner elsewhere.” Apply this procedure: Use it for observation or deduplication of live objects, not durable enrolment. The expected mechanism is: The assertion describes current liveness; it is not a persistence guarantee. For the family photo index, add one near-miss that exposes using WeakSet as a registry that promises every participant will remain available. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: CCA roster. Transfer the rule using temporary participant objects indexed without creating a hidden retention leak. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakSet stores weak references to its elements, so membership vanishes when an element has no strong owner elsewhere.” Apply this procedure: Use it for observation or deduplication of live objects, not durable enrolment. The expected mechanism is: The assertion describes current liveness; it is not a persistence guarantee. For the CCA roster, add one near-miss that exposes using WeakSet as a registry that promises every participant will remain available. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: science model. Predict the rule using large simulation objects watched through diagnostic handles. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakSet stores weak references to its elements, so membership vanishes when an element has no strong owner elsewhere.” Apply this procedure: Use it for observation or deduplication of live objects, not durable enrolment. The expected mechanism is: The assertion describes current liveness; it is not a persistence guarantee. For the science model, add one near-miss that exposes using WeakSet as a registry that promises every participant will remain available. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers using WeakSet as a registry that promises every participant will remain available.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Use it for observation or deduplication of live objects, not durable enrolment.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from WeakSet tracks membership without retention?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using WeakSet as a registry that promises every participant will remain available be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny family photo index with metadata records pointing to images without owning their lifetime. Include one ordinary case, one boundary and one deliberate failure caused by using WeakSet as a registry that promises every participant will remain available. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: WeakSet stores weak references to its elements, so membership vanishes when an element has no strong owner elsewhere. It shows a trace, not only a final value. The ordinary case should demonstrate “The assertion describes current liveness; it is not a persistence guarantee.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use it for observation or deduplication of live objects, not durable enrolment. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For WeakSet tracks membership without retention, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 14 OF 20 . Debug and verify
14. WeakMethod represents an ephemeral bound method
WeakMethod recreates a bound method while both its instance and original function live, avoiding the immediate death of an ordinary weak reference to a temporary bound-method object. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is using weakref.ref(obj.method) and expecting later calls to succeed. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compare an ordinary ref to a bound method with WeakMethod in the same fixture.
For the WeakMethod represents an ephemeral bound method chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using weakref.ref(obj.method) and expecting later calls to succeed. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
callback=weakref.WeakMethod(listener.on_event)
method=callback()Explained result. method is callable while listener lives and becomes None after the required object or function disappears. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: CCA roster. Explain the rule using temporary participant objects indexed without creating a hidden retention leak. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakMethod recreates a bound method while both its instance and original function live, avoiding the immediate death of an ordinary weak reference to a temporary bound-method object.” Apply this procedure: Compare an ordinary ref to a bound method with WeakMethod in the same fixture. The expected mechanism is: method is callable while listener lives and becomes None after the required object or function disappears. For the CCA roster, add one near-miss that exposes using weakref.ref(obj.method) and expecting later calls to succeed. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: science model. Transfer the rule using large simulation objects watched through diagnostic handles. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakMethod recreates a bound method while both its instance and original function live, avoiding the immediate death of an ordinary weak reference to a temporary bound-method object.” Apply this procedure: Compare an ordinary ref to a bound method with WeakMethod in the same fixture. The expected mechanism is: method is callable while listener lives and becomes None after the required object or function disappears. For the science model, add one near-miss that exposes using weakref.ref(obj.method) and expecting later calls to succeed. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: event listeners. Predict the rule using bound methods observed without preserving abandoned screens. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakMethod recreates a bound method while both its instance and original function live, avoiding the immediate death of an ordinary weak reference to a temporary bound-method object.” Apply this procedure: Compare an ordinary ref to a bound method with WeakMethod in the same fixture. The expected mechanism is: method is callable while listener lives and becomes None after the required object or function disappears. For the event listeners, add one near-miss that exposes using weakref.ref(obj.method) and expecting later calls to succeed. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: resource receipt. Contrast the rule using cleanup intent recorded without a callback retaining the resource. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “WeakMethod recreates a bound method while both its instance and original function live, avoiding the immediate death of an ordinary weak reference to a temporary bound-method object.” Apply this procedure: Compare an ordinary ref to a bound method with WeakMethod in the same fixture. The expected mechanism is: method is callable while listener lives and becomes None after the required object or function disappears. For the resource receipt, add one near-miss that exposes using weakref.ref(obj.method) and expecting later calls to succeed. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers using weakref.ref(obj.method) and expecting later calls to succeed.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Compare an ordinary ref to a bound method with WeakMethod in the same fixture.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from WeakMethod represents an ephemeral bound method?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using weakref.ref(obj.method) and expecting later calls to succeed be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny CCA roster with temporary participant objects indexed without creating a hidden retention leak. Include one ordinary case, one boundary and one deliberate failure caused by using weakref.ref(obj.method) and expecting later calls to succeed. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: WeakMethod recreates a bound method while both its instance and original function live, avoiding the immediate death of an ordinary weak reference to a temporary bound-method object. It shows a trace, not only a final value. The ordinary case should demonstrate “method is callable while listener lives and becomes None after the required object or function disappears.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Compare an ordinary ref to a bound method with WeakMethod in the same fixture. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For WeakMethod represents an ephemeral bound method, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
weakref.finalize returns a finalizer object that survives until its watched object is collected, simplifying cleanup registration compared with retaining a bare weakref callback. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is assuming finalize keeps the watched object alive. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Drop the watched object while keeping only the finalizer and observe alive before and after collection.
For the finalize keeps the finalizer alive chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming finalize keeps the watched object alive. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
fin=weakref.finalize(note,log,'note released')
assert fin.aliveExplained result. The finalizer remains registered without becoming a strong owner of note. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: event listeners. Transfer the rule using bound methods observed without preserving abandoned screens. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.finalize returns a finalizer object that survives until its watched object is collected, simplifying cleanup registration compared with retaining a bare weakref callback.” Apply this procedure: Drop the watched object while keeping only the finalizer and observe alive before and after collection. The expected mechanism is: The finalizer remains registered without becoming a strong owner of note. For the event listeners, add one near-miss that exposes assuming finalize keeps the watched object alive. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: resource receipt. Predict the rule using cleanup intent recorded without a callback retaining the resource. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.finalize returns a finalizer object that survives until its watched object is collected, simplifying cleanup registration compared with retaining a bare weakref callback.” Apply this procedure: Drop the watched object while keeping only the finalizer and observe alive before and after collection. The expected mechanism is: The finalizer remains registered without becoming a strong owner of note. For the resource receipt, add one near-miss that exposes assuming finalize keeps the watched object alive. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: identity laboratory. Contrast the rule using equal and identical objects traced before and after collection. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.finalize returns a finalizer object that survives until its watched object is collected, simplifying cleanup registration compared with retaining a bare weakref callback.” Apply this procedure: Drop the watched object while keeping only the finalizer and observe alive before and after collection. The expected mechanism is: The finalizer remains registered without becoming a strong owner of note. For the identity laboratory, add one near-miss that exposes assuming finalize keeps the watched object alive. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: concurrency fixture. Stress-test the rule using one-call dereferencing used while another task can release ownership. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weakref.finalize returns a finalizer object that survives until its watched object is collected, simplifying cleanup registration compared with retaining a bare weakref callback.” Apply this procedure: Drop the watched object while keeping only the finalizer and observe alive before and after collection. The expected mechanism is: The finalizer remains registered without becoming a strong owner of note. For the concurrency fixture, add one near-miss that exposes assuming finalize keeps the watched object alive. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers assuming finalize keeps the watched object alive.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Drop the watched object while keeping only the finalizer and observe alive before and after collection.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from finalize keeps the finalizer alive?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming finalize keeps the watched object alive be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny science model with large simulation objects watched through diagnostic handles. Include one ordinary case, one boundary and one deliberate failure caused by assuming finalize keeps the watched object alive. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: weakref.finalize returns a finalizer object that survives until its watched object is collected, simplifying cleanup registration compared with retaining a bare weakref callback. It shows a trace, not only a final value. The ordinary case should demonstrate “The finalizer remains registered without becoming a strong owner of note.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Drop the watched object while keeping only the finalizer and observe alive before and after collection. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For finalize keeps the finalizer alive, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 16 OF 20 . Debug and verify
16. Finalizer arguments must not retain the object
func, args and kwargs held by finalize must not contain a bound method of the watched object or another strong path back to it. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is registering weakref.finalize(obj,obj.close) and preventing collection. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use an external function with independent cleanup data such as a path or token.
For the Finalizer arguments must not retain the object chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on registering weakref.finalize(obj,obj.close) and preventing collection. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
path=note.temp_path
fin=weakref.finalize(note,remove_temp,path)Explained result. The cleanup data survives while the Note instance remains collectable. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: identity laboratory. Predict the rule using equal and identical objects traced before and after collection. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “func, args and kwargs held by finalize must not contain a bound method of the watched object or another strong path back to it.” Apply this procedure: Use an external function with independent cleanup data such as a path or token. The expected mechanism is: The cleanup data survives while the Note instance remains collectable. For the identity laboratory, add one near-miss that exposes registering weakref.finalize(obj,obj.close) and preventing collection. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: concurrency fixture. Contrast the rule using one-call dereferencing used while another task can release ownership. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “func, args and kwargs held by finalize must not contain a bound method of the watched object or another strong path back to it.” Apply this procedure: Use an external function with independent cleanup data such as a path or token. The expected mechanism is: The cleanup data survives while the Note instance remains collectable. For the concurrency fixture, add one near-miss that exposes registering weakref.finalize(obj,obj.close) and preventing collection. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: revision cache. Stress-test the rule using parsed study notes reused only while another owner still needs them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “func, args and kwargs held by finalize must not contain a bound method of the watched object or another strong path back to it.” Apply this procedure: Use an external function with independent cleanup data such as a path or token. The expected mechanism is: The cleanup data survives while the Note instance remains collectable. For the revision cache, add one near-miss that exposes registering weakref.finalize(obj,obj.close) and preventing collection. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: family photo index. Explain the rule using metadata records pointing to images without owning their lifetime. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “func, args and kwargs held by finalize must not contain a bound method of the watched object or another strong path back to it.” Apply this procedure: Use an external function with independent cleanup data such as a path or token. The expected mechanism is: The cleanup data survives while the Note instance remains collectable. For the family photo index, add one near-miss that exposes registering weakref.finalize(obj,obj.close) and preventing collection. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers registering weakref.finalize(obj,obj.close) and preventing collection.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Use an external function with independent cleanup data such as a path or token.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from Finalizer arguments must not retain the object?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing registering weakref.finalize(obj,obj.close) and preventing collection be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny event listeners with bound methods observed without preserving abandoned screens. Include one ordinary case, one boundary and one deliberate failure caused by registering weakref.finalize(obj,obj.close) and preventing collection. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: func, args and kwargs held by finalize must not contain a bound method of the watched object or another strong path back to it. It shows a trace, not only a final value. The ordinary case should demonstrate “The cleanup data survives while the Note instance remains collectable.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use an external function with independent cleanup data such as a path or token. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Finalizer arguments must not retain the object, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 17 OF 20 . Transfer with judgment
17. A finalizer can be called, detached or inspected
a live finalizer is callable at most once, detach can return its registered parts while disabling it, and peek observes parts without disabling. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is calling cleanup manually and then assuming automatic cleanup will repeat. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Assert alive around call, detach or peek and test the one-shot contract.
For the A finalizer can be called, detached or inspected chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on calling cleanup manually and then assuming automatic cleanup will repeat. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
if fin.alive:
fin()Explained result. The explicit call runs the callback once and marks the finalizer dead. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: revision cache. Contrast the rule using parsed study notes reused only while another owner still needs them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a live finalizer is callable at most once, detach can return its registered parts while disabling it, and peek observes parts without disabling.” Apply this procedure: Assert alive around call, detach or peek and test the one-shot contract. The expected mechanism is: The explicit call runs the callback once and marks the finalizer dead. For the revision cache, add one near-miss that exposes calling cleanup manually and then assuming automatic cleanup will repeat. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: family photo index. Stress-test the rule using metadata records pointing to images without owning their lifetime. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a live finalizer is callable at most once, detach can return its registered parts while disabling it, and peek observes parts without disabling.” Apply this procedure: Assert alive around call, detach or peek and test the one-shot contract. The expected mechanism is: The explicit call runs the callback once and marks the finalizer dead. For the family photo index, add one near-miss that exposes calling cleanup manually and then assuming automatic cleanup will repeat. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: CCA roster. Explain the rule using temporary participant objects indexed without creating a hidden retention leak. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a live finalizer is callable at most once, detach can return its registered parts while disabling it, and peek observes parts without disabling.” Apply this procedure: Assert alive around call, detach or peek and test the one-shot contract. The expected mechanism is: The explicit call runs the callback once and marks the finalizer dead. For the CCA roster, add one near-miss that exposes calling cleanup manually and then assuming automatic cleanup will repeat. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: science model. Transfer the rule using large simulation objects watched through diagnostic handles. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “a live finalizer is callable at most once, detach can return its registered parts while disabling it, and peek observes parts without disabling.” Apply this procedure: Assert alive around call, detach or peek and test the one-shot contract. The expected mechanism is: The explicit call runs the callback once and marks the finalizer dead. For the science model, add one near-miss that exposes calling cleanup manually and then assuming automatic cleanup will repeat. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers calling cleanup manually and then assuming automatic cleanup will repeat.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Assert alive around call, detach or peek and test the one-shot contract.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from A finalizer can be called, detached or inspected?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing calling cleanup manually and then assuming automatic cleanup will repeat be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny resource receipt with cleanup intent recorded without a callback retaining the resource. Include one ordinary case, one boundary and one deliberate failure caused by calling cleanup manually and then assuming automatic cleanup will repeat. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: a live finalizer is callable at most once, detach can return its registered parts while disabling it, and peek observes parts without disabling. It shows a trace, not only a final value. The ordinary case should demonstrate “The explicit call runs the callback once and marks the finalizer dead.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Assert alive around call, detach or peek and test the one-shot contract. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For A finalizer can be called, detached or inspected, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
live finalizers with atexit enabled run at normal interpreter exit in reverse creation order, while setting atexit false opts one finalizer out. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is using interpreter shutdown order as the primary correctness path. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Make normal cleanup explicit and treat exit-time execution only as a fallback.
For the Exit-time behaviour is a policy choice chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using interpreter shutdown order as the primary correctness path. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
fin.atexit=FalseExplained result. This finalizer will not be invoked merely because the interpreter exits normally. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: CCA roster. Stress-test the rule using temporary participant objects indexed without creating a hidden retention leak. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “live finalizers with atexit enabled run at normal interpreter exit in reverse creation order, while setting atexit false opts one finalizer out.” Apply this procedure: Make normal cleanup explicit and treat exit-time execution only as a fallback. The expected mechanism is: This finalizer will not be invoked merely because the interpreter exits normally. For the CCA roster, add one near-miss that exposes using interpreter shutdown order as the primary correctness path. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: science model. Explain the rule using large simulation objects watched through diagnostic handles. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “live finalizers with atexit enabled run at normal interpreter exit in reverse creation order, while setting atexit false opts one finalizer out.” Apply this procedure: Make normal cleanup explicit and treat exit-time execution only as a fallback. The expected mechanism is: This finalizer will not be invoked merely because the interpreter exits normally. For the science model, add one near-miss that exposes using interpreter shutdown order as the primary correctness path. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: event listeners. Transfer the rule using bound methods observed without preserving abandoned screens. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “live finalizers with atexit enabled run at normal interpreter exit in reverse creation order, while setting atexit false opts one finalizer out.” Apply this procedure: Make normal cleanup explicit and treat exit-time execution only as a fallback. The expected mechanism is: This finalizer will not be invoked merely because the interpreter exits normally. For the event listeners, add one near-miss that exposes using interpreter shutdown order as the primary correctness path. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: resource receipt. Predict the rule using cleanup intent recorded without a callback retaining the resource. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “live finalizers with atexit enabled run at normal interpreter exit in reverse creation order, while setting atexit false opts one finalizer out.” Apply this procedure: Make normal cleanup explicit and treat exit-time execution only as a fallback. The expected mechanism is: This finalizer will not be invoked merely because the interpreter exits normally. For the resource receipt, add one near-miss that exposes using interpreter shutdown order as the primary correctness path. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers using interpreter shutdown order as the primary correctness path.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Make normal cleanup explicit and treat exit-time execution only as a fallback.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from Exit-time behaviour is a policy choice?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using interpreter shutdown order as the primary correctness path be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny identity laboratory with equal and identical objects traced before and after collection. Include one ordinary case, one boundary and one deliberate failure caused by using interpreter shutdown order as the primary correctness path. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: live finalizers with atexit enabled run at normal interpreter exit in reverse creation order, while setting atexit false opts one finalizer out. It shows a trace, not only a final value. The ordinary case should demonstrate “This finalizer will not be invoked merely because the interpreter exits normally.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Make normal cleanup explicit and treat exit-time execution only as a fallback. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Exit-time behaviour is a policy choice, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 19 OF 20 . Transfer with judgment
19. Hash and equality need deliberate tests
weak references can mirror referent equality while referents live, and hashing has lifecycle-sensitive rules including TypeError when first computed after death. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is using weakrefs as interchangeable permanent identity tokens. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compute identity and hash expectations while live, release the referents and test the documented post-death cases separately.
For the Hash and equality need deliberate tests chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using weakrefs as interchangeable permanent identity tokens. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
h=hash(handle)
del noteExplained result. A hash computed while the referent lived remains available; relying on first-time hashing after death is invalid. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: event listeners. Explain the rule using bound methods observed without preserving abandoned screens. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weak references can mirror referent equality while referents live, and hashing has lifecycle-sensitive rules including TypeError when first computed after death.” Apply this procedure: Compute identity and hash expectations while live, release the referents and test the documented post-death cases separately. The expected mechanism is: A hash computed while the referent lived remains available; relying on first-time hashing after death is invalid. For the event listeners, add one near-miss that exposes using weakrefs as interchangeable permanent identity tokens. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: resource receipt. Transfer the rule using cleanup intent recorded without a callback retaining the resource. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weak references can mirror referent equality while referents live, and hashing has lifecycle-sensitive rules including TypeError when first computed after death.” Apply this procedure: Compute identity and hash expectations while live, release the referents and test the documented post-death cases separately. The expected mechanism is: A hash computed while the referent lived remains available; relying on first-time hashing after death is invalid. For the resource receipt, add one near-miss that exposes using weakrefs as interchangeable permanent identity tokens. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: identity laboratory. Predict the rule using equal and identical objects traced before and after collection. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weak references can mirror referent equality while referents live, and hashing has lifecycle-sensitive rules including TypeError when first computed after death.” Apply this procedure: Compute identity and hash expectations while live, release the referents and test the documented post-death cases separately. The expected mechanism is: A hash computed while the referent lived remains available; relying on first-time hashing after death is invalid. For the identity laboratory, add one near-miss that exposes using weakrefs as interchangeable permanent identity tokens. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: concurrency fixture. Contrast the rule using one-call dereferencing used while another task can release ownership. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weak references can mirror referent equality while referents live, and hashing has lifecycle-sensitive rules including TypeError when first computed after death.” Apply this procedure: Compute identity and hash expectations while live, release the referents and test the documented post-death cases separately. The expected mechanism is: A hash computed while the referent lived remains available; relying on first-time hashing after death is invalid. For the concurrency fixture, add one near-miss that exposes using weakrefs as interchangeable permanent identity tokens. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers using weakrefs as interchangeable permanent identity tokens.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Compute identity and hash expectations while live, release the referents and test the documented post-death cases separately.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from Hash and equality need deliberate tests?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using weakrefs as interchangeable permanent identity tokens be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny concurrency fixture with one-call dereferencing used while another task can release ownership. Include one ordinary case, one boundary and one deliberate failure caused by using weakrefs as interchangeable permanent identity tokens. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: weak references can mirror referent equality while referents live, and hashing has lifecycle-sensitive rules including TypeError when first computed after death. It shows a trace, not only a final value. The ordinary case should demonstrate “A hash computed while the referent lived remains available; relying on first-time hashing after death is invalid.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Compute identity and hash expectations while live, release the referents and test the documented post-death cases separately. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Hash and equality need deliberate tests, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
CHAPTER 20 OF 20 . Transfer with judgment
20. Weak references belong to auxiliary relationships
weak references are clearest for caches, observers and metadata where disappearance is acceptable; real owners should use strong references and explicit lifecycle APIs. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is using weakref to hide an unresolved ownership decision. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Write the ownership sentence before choosing ref, proxy, a weak container or finalize.
For the Weak references belong to auxiliary relationships chapter on Python weakref, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using weakref to hide an unresolved ownership decision. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
# Owner: document model; observer: thumbnail cacheExplained result. The design names who keeps the object alive and what the observer does when it is gone. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: identity laboratory. Transfer the rule using equal and identical objects traced before and after collection. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weak references are clearest for caches, observers and metadata where disappearance is acceptable; real owners should use strong references and explicit lifecycle APIs.” Apply this procedure: Write the ownership sentence before choosing ref, proxy, a weak container or finalize. The expected mechanism is: The design names who keeps the object alive and what the observer does when it is gone. For the identity laboratory, add one near-miss that exposes using weakref to hide an unresolved ownership decision. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 2: concurrency fixture. Predict the rule using one-call dereferencing used while another task can release ownership. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weak references are clearest for caches, observers and metadata where disappearance is acceptable; real owners should use strong references and explicit lifecycle APIs.” Apply this procedure: Write the ownership sentence before choosing ref, proxy, a weak container or finalize. The expected mechanism is: The design names who keeps the object alive and what the observer does when it is gone. For the concurrency fixture, add one near-miss that exposes using weakref to hide an unresolved ownership decision. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: revision cache. Contrast the rule using parsed study notes reused only while another owner still needs them. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weak references are clearest for caches, observers and metadata where disappearance is acceptable; real owners should use strong references and explicit lifecycle APIs.” Apply this procedure: Write the ownership sentence before choosing ref, proxy, a weak container or finalize. The expected mechanism is: The design names who keeps the object alive and what the observer does when it is gone. For the revision cache, add one near-miss that exposes using weakref to hide an unresolved ownership decision. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 4: family photo index. Stress-test the rule using metadata records pointing to images without owning their lifetime. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “weak references are clearest for caches, observers and metadata where disappearance is acceptable; real owners should use strong references and explicit lifecycle APIs.” Apply this procedure: Write the ownership sentence before choosing ref, proxy, a weak container or finalize. The expected mechanism is: The design names who keeps the object alive and what the observer does when it is gone. For the family photo index, add one near-miss that exposes using weakref to hide an unresolved ownership decision. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Diagnostic route
- Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
- Boundary check: create the smallest input that triggers using weakref to hide an unresolved ownership decision.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Write the ownership sentence before choosing ref, proxy, a weak container or finalize.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final Python weakref syntax. For this chapter, useful prompts are: “What did you expect from Weak references belong to auxiliary relationships?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using weakref to hide an unresolved ownership decision be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny revision cache with parsed study notes reused only while another owner still needs them. Include one ordinary case, one boundary and one deliberate failure caused by using weakref to hide an unresolved ownership decision. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: weak references are clearest for caches, observers and metadata where disappearance is acceptable; real owners should use strong references and explicit lifecycle APIs. It shows a trace, not only a final value. The ordinary case should demonstrate “The design names who keeps the object alive and what the observer does when it is gone.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Write the ownership sentence before choosing ref, proxy, a weak container or finalize. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Weak references belong to auxiliary relationships, separate the documented Python weakref mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
Parent guide: choose the next useful step
Start with evidence, not a label such as careless. Ask for one prediction and one trace. If the first transition is wrong, rebuild the model. If the model is sound but syntax fails, practise reference use. If routine cases are correct but boundaries fail, vary ties, defaults, unsupported inputs, ownership or missing paths. If explanations transfer, move to a small project.
Keep a weekly record with four lines: concept, prediction, observed difference and next test. Stop when fatigue replaces reasoning. A smaller case tomorrow is more useful than another hour of copying tonight.
Seek specialist help when cause and effect remain invisible after examples are reduced, when accessibility or data-loss implications are unclear, or when an important repository, database or application state may be at risk. Good support should make the learner’s reasoning more independent.
Capstone practice with explained routes
1. revision cache: model, boundary and recovery
Create a small revision cache using parsed study notes reused only while another owner still needs them. Combine “A weak reference observes without owning” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: weakref.ref creates a reference that does not increase the referent’s strong-reference count and therefore does not decide its lifetime. Apply: Draw every strong owner first, then add the weak observer and remove one strong edge at a time. Verify: handle can observe note while note is alive, but handle alone will not preserve the Note instance. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
2. family photo index: model, boundary and recovery
Create a small family photo index using metadata records pointing to images without owning their lifetime. Combine “One-call dereferencing closes a race window” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: checking handle() and then calling handle() again permits the referent to disappear between the two calls in threaded code. Apply: Assign handle() once, test the assigned object and keep it only for the smallest necessary scope. Verify: The successful call both tests liveness and obtains the temporary strong owner used next. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
3. CCA roster: model, boundary and recovery
Create a small CCA roster using temporary participant objects indexed without creating a hidden retention leak. Combine “Callbacks run from newest registration to oldest” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: when several weak references to one object have callbacks, the most recently registered callback is invoked first. Apply: Record registration order and make every callback independently safe and idempotent. Verify: If both weakref objects remain alive, new is observed before old when note is finalized. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
4. science model: model, boundary and recovery
Create a small science model using large simulation objects watched through diagnostic handles. Combine “Proxies are deliberately unhashable” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: weak-reference proxy objects are not hashable even when their referents are hashable, avoiding unstable dictionary-key behaviour. Apply: Store a stable identifier or a weak reference with a documented hash policy instead. Verify: The operation raises TypeError rather than promising a hash whose target may vanish. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
5. event listeners: model, boundary and recovery
Create a small event listeners using bound methods observed without preserving abandoned screens. Combine “WeakSet tracks membership without retention” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: WeakSet stores weak references to its elements, so membership vanishes when an element has no strong owner elsewhere. Apply: Use it for observation or deduplication of live objects, not durable enrolment. Verify: The assertion describes current liveness; it is not a persistence guarantee. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
6. resource receipt: model, boundary and recovery
Create a small resource receipt using cleanup intent recorded without a callback retaining the resource. Combine “Finalizer arguments must not retain the object” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: func, args and kwargs held by finalize must not contain a bound method of the watched object or another strong path back to it. Apply: Use an external function with independent cleanup data such as a path or token. Verify: The cleanup data survives while the Note instance remains collectable. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
7. identity laboratory: model, boundary and recovery
Create a small identity laboratory using equal and identical objects traced before and after collection. Combine “Hash and equality need deliberate tests” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: weak references can mirror referent equality while referents live, and hashing has lifecycle-sensitive rules including TypeError when first computed after death. Apply: Compute identity and hash expectations while live, release the referents and test the documented post-death cases separately. Verify: A hash computed while the referent lived remains available; relying on first-time hashing after death is invalid. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
8. concurrency fixture: model, boundary and recovery
Create a small concurrency fixture using one-call dereferencing used while another task can release ownership. Combine “Only weak-referenceable objects can be targets” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: class instances and several built-in types support weak references, while common built-ins such as list, dict, tuple and int have important restrictions documented by the runtime. Apply: Probe the exact runtime type in a disposable example and treat TypeError as a type-capability boundary. Verify: A plain list raises TypeError rather than silently becoming weakly referenced. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.
Frequently asked questions
How long should a practice session be?
Use one complete prediction–observation–explanation cycle while attention remains good. Ten to twenty focused minutes can be enough.
Should every option or function be memorised?
No. Memorise the governing distinctions and practise retrieving the official reference. Understanding means predicting and explaining, not reciting a parameter list.
What if the result is correct but the explanation is weak?
Treat it as partial success. Ask for a trace and change one boundary. A reliable model survives controlled variation.
Is the shortest solution the best?
Not automatically. Prefer the solution whose semantics, failure modes and maintenance cost are easiest to justify for the actual project.
When should official documentation be used?
Use it whenever syntax, supported types, SQL dialect behaviour or Git version details matter. Primary documentation settles the current contract.
How can a parent help without technical expertise?
Ask what was predicted, where the first difference appeared, what evidence matters and which smaller example could isolate it.
How do we test transfer?
Change the context, vocabulary and one boundary. Require the learner to identify the invariant before using a tool.
What should be saved after practice?
Keep the corrected rule, one trace, one boundary case and the next question. Avoid storing pages of unexplained output.
Can these exercises replace backups?
No. Use disposable examples and proper backups. Learning should not endanger schoolwork, repositories or personal data.
What counts as mastery?
The learner can predict, verify, diagnose, recover and justify a choice across more than one context, while knowing when to consult the current reference.
