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.
JavaScript Intl.supportedValuesOf() returns the implementation-supported canonical identifiers for one recognised internationalisation key: calendar, collation, currency, numberingSystem, timeZone or unit. It helps build capability-aware choices and tests, but it does not tell us which option is culturally appropriate for one user, whether a currency is current legal tender, or whether application data exists. Mastery means joining runtime capability with locale, product and user policy instead of turning one array into a false guarantee. 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
Intl.supportedValuesOf takes one key and returns identifiers the current implementation supports for that category. 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 it as a formatter or translator. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Request one key and label the result as capability data.
For the The method reports supported identifiers chapter on JavaScript Intl.supportedValuesOf(), 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 it as a formatter or translator. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
console.log(Intl.supportedValuesOf('calendar').slice(0,5));Explained result. The output is an array of supported calendar identifiers, not formatted dates. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family calendar. Predict the rule using offering supported calendars while keeping a sensible default. 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 “Intl.supportedValuesOf takes one key and returns identifiers the current implementation supports for that category.” Apply this procedure: Request one key and label the result as capability data. The expected mechanism is: The output is an array of supported calendar identifiers, not formatted dates. For the family calendar, add one near-miss that exposes treating it as a formatter or translator. 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: school timetable. Contrast the rule using validating a chosen IANA time-zone identifier. 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 “Intl.supportedValuesOf takes one key and returns identifiers the current implementation supports for that category.” Apply this procedure: Request one key and label the result as capability data. The expected mechanism is: The output is an array of supported calendar identifiers, not formatted dates. For the school timetable, add one near-miss that exposes treating it as a formatter or translator. 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 budget. Stress-test the rule using separating currency-code support from current exchange data. 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 “Intl.supportedValuesOf takes one key and returns identifiers the current implementation supports for that category.” Apply this procedure: Request one key and label the result as capability data. The expected mechanism is: The output is an array of supported calendar identifiers, not formatted dates. For the CCA budget, add one near-miss that exposes treating it as a formatter or translator. 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 converter. Explain the rule using building a unit picker from standard identifiers. 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 “Intl.supportedValuesOf takes one key and returns identifiers the current implementation supports for that category.” Apply this procedure: Request one key and label the result as capability data. The expected mechanism is: The output is an array of supported calendar identifiers, not formatted dates. For the science converter, add one near-miss that exposes treating it as a formatter or translator. 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 it as a formatter or translator.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Request one key and label the result as capability data.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from The method reports supported identifiers?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating it as a formatter or translator be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny sorting tool with understanding supported collations and locale relevance. Include one ordinary case, one boundary and one deliberate failure caused by treating it as a formatter or translator. 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: Intl.supportedValuesOf takes one key and returns identifiers the current implementation supports for that category. It shows a trace, not only a final value. The ordinary case should demonstrate “The output is an array of supported calendar identifiers, not formatted dates.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Request one key and label the result as capability data. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For The method reports supported identifiers, separate the documented JavaScript Intl.supportedValuesOf() 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
Call it on Intl itself; no NumberFormat, Locale or other formatter instance is constructed. 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 new Intl.supportedValuesOf or calling it from a formatter. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Check the owning object and function type.
For the It is a static Intl method chapter on JavaScript Intl.supportedValuesOf(), 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 new Intl.supportedValuesOf or calling it from a formatter. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
console.log(typeof Intl.supportedValuesOf);Explained result. A supporting runtime prints function. 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 budget. Contrast the rule using separating currency-code support from current exchange data. 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 “Call it on Intl itself; no NumberFormat, Locale or other formatter instance is constructed.” Apply this procedure: Check the owning object and function type. The expected mechanism is: A supporting runtime prints function. For the CCA budget, add one near-miss that exposes writing new Intl.supportedValuesOf or calling it from a formatter. 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 converter. Stress-test the rule using building a unit picker from standard identifiers. 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 “Call it on Intl itself; no NumberFormat, Locale or other formatter instance is constructed.” Apply this procedure: Check the owning object and function type. The expected mechanism is: A supporting runtime prints function. For the science converter, add one near-miss that exposes writing new Intl.supportedValuesOf or calling it from a formatter. 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: reading app. Explain the rule using checking numbering systems without guessing language needs. 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 “Call it on Intl itself; no NumberFormat, Locale or other formatter instance is constructed.” Apply this procedure: Check the owning object and function type. The expected mechanism is: A supporting runtime prints function. For the reading app, add one near-miss that exposes writing new Intl.supportedValuesOf or calling it from a formatter. 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: sorting tool. Transfer the rule using understanding supported collations and locale relevance. 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 “Call it on Intl itself; no NumberFormat, Locale or other formatter instance is constructed.” Apply this procedure: Check the owning object and function type. The expected mechanism is: A supporting runtime prints function. For the sorting tool, add one near-miss that exposes writing new Intl.supportedValuesOf or calling it from a formatter. 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 new Intl.supportedValuesOf or calling it from a formatter.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Check the owning object and function type.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from It is a static Intl method?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing writing new Intl.supportedValuesOf or calling it from a formatter be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny test laboratory with checking keys, fresh arrays, canonical spelling and invalid input. Include one ordinary case, one boundary and one deliberate failure caused by writing new Intl.supportedValuesOf or calling it from a formatter. 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: Call it on Intl itself; no NumberFormat, Locale or other formatter instance is constructed. It shows a trace, not only a final value. The ordinary case should demonstrate “A supporting runtime prints function.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Check the owning object and function type. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For It is a static Intl method, separate the documented JavaScript Intl.supportedValuesOf() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
The standard keys are calendar, collation, currency, numberingSystem, timeZone and unit. 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 inventing plural key names such as currencies or timeZones. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Keep key names in a closed application constant.
For the Only six keys are recognised chapter on JavaScript Intl.supportedValuesOf(), 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 inventing plural key names such as currencies or timeZones. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const keys=['calendar','collation','currency','numberingSystem','timeZone','unit'];Explained result. Each exact singular spelling selects one identifier category. 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: reading app. Stress-test the rule using checking numbering systems without guessing language needs. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The standard keys are calendar, collation, currency, numberingSystem, timeZone and unit.” Apply this procedure: Keep key names in a closed application constant. The expected mechanism is: Each exact singular spelling selects one identifier category. For the reading app, add one near-miss that exposes inventing plural key names such as currencies or timeZones. 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: sorting tool. Explain the rule using understanding supported collations and locale relevance. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The standard keys are calendar, collation, currency, numberingSystem, timeZone and unit.” Apply this procedure: Keep key names in a closed application constant. The expected mechanism is: Each exact singular spelling selects one identifier category. For the sorting tool, add one near-miss that exposes inventing plural key names such as currencies or timeZones. 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: test laboratory. Transfer the rule using checking keys, fresh arrays, canonical spelling and invalid input. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The standard keys are calendar, collation, currency, numberingSystem, timeZone and unit.” Apply this procedure: Keep key names in a closed application constant. The expected mechanism is: Each exact singular spelling selects one identifier category. For the test laboratory, add one near-miss that exposes inventing plural key names such as currencies or timeZones. 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: design review. Predict the rule using combining runtime support, catalogue support and user preference. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The standard keys are calendar, collation, currency, numberingSystem, timeZone and unit.” Apply this procedure: Keep key names in a closed application constant. The expected mechanism is: Each exact singular spelling selects one identifier category. For the design review, add one near-miss that exposes inventing plural key names such as currencies or timeZones. 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 inventing plural key names such as currencies or timeZones.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Keep key names in a closed application constant.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from Only six keys are recognised?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing inventing plural key names such as currencies or timeZones be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny design review with combining runtime support, catalogue support and user preference. Include one ordinary case, one boundary and one deliberate failure caused by inventing plural key names such as currencies or timeZones. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The standard keys are calendar, collation, currency, numberingSystem, timeZone and unit. It shows a trace, not only a final value. The ordinary case should demonstrate “Each exact singular spelling selects one identifier category.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Keep key names in a closed application constant. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Only six keys are recognised, separate the documented JavaScript Intl.supportedValuesOf() 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
An unsupported key is a programming error rather than an empty capability set. 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 an empty result to detect a misspelled key. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Catch RangeError at a configuration boundary and fix the caller.
For the Unknown keys throw RangeError chapter on JavaScript Intl.supportedValuesOf(), 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 an empty result to detect a misspelled key. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
try{Intl.supportedValuesOf('currencies')}catch(e){console.log(e.name)}Explained result. The misspelling produces RangeError. 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: test laboratory. Explain the rule using checking keys, fresh arrays, canonical spelling and invalid input. 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 “An unsupported key is a programming error rather than an empty capability set.” Apply this procedure: Catch RangeError at a configuration boundary and fix the caller. The expected mechanism is: The misspelling produces RangeError. For the test laboratory, add one near-miss that exposes using an empty result to detect a misspelled key. 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: design review. Transfer the rule using combining runtime support, catalogue support and user preference. 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 “An unsupported key is a programming error rather than an empty capability set.” Apply this procedure: Catch RangeError at a configuration boundary and fix the caller. The expected mechanism is: The misspelling produces RangeError. For the design review, add one near-miss that exposes using an empty result to detect a misspelled key. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family calendar. Predict the rule using offering supported calendars while keeping a sensible default. 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 “An unsupported key is a programming error rather than an empty capability set.” Apply this procedure: Catch RangeError at a configuration boundary and fix the caller. The expected mechanism is: The misspelling produces RangeError. For the family calendar, add one near-miss that exposes using an empty result to detect a misspelled key. 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: school timetable. Contrast the rule using validating a chosen IANA time-zone identifier. 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 “An unsupported key is a programming error rather than an empty capability set.” Apply this procedure: Catch RangeError at a configuration boundary and fix the caller. The expected mechanism is: The misspelling produces RangeError. For the school timetable, add one near-miss that exposes using an empty result to detect a misspelled key. 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 an empty result to detect a misspelled key.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Catch RangeError at a configuration boundary and fix the caller.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from Unknown keys throw RangeError?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using an empty result to detect a misspelled key be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny family calendar with offering supported calendars while keeping a sensible default. Include one ordinary case, one boundary and one deliberate failure caused by using an empty result to detect a misspelled key. 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: An unsupported key is a programming error rather than an empty capability set. It shows a trace, not only a final value. The ordinary case should demonstrate “The misspelling produces RangeError.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Catch RangeError at a configuration boundary and fix the caller. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Unknown keys throw RangeError, separate the documented JavaScript Intl.supportedValuesOf() 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
Each call returns a separate mutable Array, so changing one caller copy does not rewrite the implementation registry. 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 mutating a result and assuming future calls share the change. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compare identity and mutate only a local copy.
For the The result is a fresh array chapter on JavaScript Intl.supportedValuesOf(), 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 mutating a result and assuming future calls share the change. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const a=Intl.supportedValuesOf('unit'); const b=Intl.supportedValuesOf('unit'); console.log(a===b);Explained result. The identity comparison is false. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family calendar. Transfer the rule using offering supported calendars while keeping a sensible default. 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 “Each call returns a separate mutable Array, so changing one caller copy does not rewrite the implementation registry.” Apply this procedure: Compare identity and mutate only a local copy. The expected mechanism is: The identity comparison is false. For the family calendar, add one near-miss that exposes mutating a result and assuming future calls share the change. 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: school timetable. Predict the rule using validating a chosen IANA time-zone identifier. 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 “Each call returns a separate mutable Array, so changing one caller copy does not rewrite the implementation registry.” Apply this procedure: Compare identity and mutate only a local copy. The expected mechanism is: The identity comparison is false. For the school timetable, add one near-miss that exposes mutating a result and assuming future calls share the change. 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 budget. Contrast the rule using separating currency-code support from current exchange data. 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 “Each call returns a separate mutable Array, so changing one caller copy does not rewrite the implementation registry.” Apply this procedure: Compare identity and mutate only a local copy. The expected mechanism is: The identity comparison is false. For the CCA budget, add one near-miss that exposes mutating a result and assuming future calls share the change. 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 converter. Stress-test the rule using building a unit picker from standard identifiers. 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 “Each call returns a separate mutable Array, so changing one caller copy does not rewrite the implementation registry.” Apply this procedure: Compare identity and mutate only a local copy. The expected mechanism is: The identity comparison is false. For the science converter, add one near-miss that exposes mutating a result and assuming future calls share the change. 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 mutating a result and assuming future calls share the change.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Compare identity and mutate only a local copy.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from The result is a fresh array?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing mutating a result and assuming future calls share the change be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny school timetable with validating a chosen IANA time-zone identifier. Include one ordinary case, one boundary and one deliberate failure caused by mutating a result and assuming future calls share the change. 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: Each call returns a separate mutable Array, so changing one caller copy does not rewrite the implementation registry. It shows a trace, not only a final value. The ordinary case should demonstrate “The identity comparison is false.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Compare identity and mutate only a local copy. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For The result is a fresh array, separate the documented JavaScript Intl.supportedValuesOf() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
The returned list uses canonical identifiers without duplicate entries for the same supported value. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is adding case variants or aliases as separate capabilities. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Check set size and preserve canonical spellings internally.
For the Values are unique canonical strings chapter on JavaScript Intl.supportedValuesOf(), 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 adding case variants or aliases as separate capabilities. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const a=Intl.supportedValuesOf('calendar'); console.log(a.length===new Set(a).size);Explained result. A conforming list contains no duplicate strings. 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 budget. Predict the rule using separating currency-code support from current exchange data. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The returned list uses canonical identifiers without duplicate entries for the same supported value.” Apply this procedure: Check set size and preserve canonical spellings internally. The expected mechanism is: A conforming list contains no duplicate strings. For the CCA budget, add one near-miss that exposes adding case variants or aliases as separate capabilities. 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 converter. Contrast the rule using building a unit picker from standard identifiers. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The returned list uses canonical identifiers without duplicate entries for the same supported value.” Apply this procedure: Check set size and preserve canonical spellings internally. The expected mechanism is: A conforming list contains no duplicate strings. For the science converter, add one near-miss that exposes adding case variants or aliases as separate capabilities. 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: reading app. Stress-test the rule using checking numbering systems without guessing language needs. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The returned list uses canonical identifiers without duplicate entries for the same supported value.” Apply this procedure: Check set size and preserve canonical spellings internally. The expected mechanism is: A conforming list contains no duplicate strings. For the reading app, add one near-miss that exposes adding case variants or aliases as separate capabilities. 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: sorting tool. Explain the rule using understanding supported collations and locale relevance. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The returned list uses canonical identifiers without duplicate entries for the same supported value.” Apply this procedure: Check set size and preserve canonical spellings internally. The expected mechanism is: A conforming list contains no duplicate strings. For the sorting tool, add one near-miss that exposes adding case variants or aliases as separate capabilities. 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 adding case variants or aliases as separate capabilities.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Check set size and preserve canonical spellings internally.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from Values are unique canonical strings?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing adding case variants or aliases as separate capabilities be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny CCA budget with separating currency-code support from current exchange data. Include one ordinary case, one boundary and one deliberate failure caused by adding case variants or aliases as separate capabilities. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The returned list uses canonical identifiers without duplicate entries for the same supported value. It shows a trace, not only a final value. The ordinary case should demonstrate “A conforming list contains no duplicate strings.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Check set size and preserve canonical spellings internally. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Values are unique canonical strings, separate the documented JavaScript Intl.supportedValuesOf() 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
Results have a deterministic sorted order, useful for testing but not automatically the best human-facing order. 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 displaying technical identifier order as a finished user experience. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Map to localised labels and apply a deliberate presentation order.
For the The array is sorted chapter on JavaScript Intl.supportedValuesOf(), 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 displaying technical identifier order as a finished user experience. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const a=Intl.supportedValuesOf('unit'); console.log(a[0],a.at(-1));Explained result. The endpoints reflect identifier sorting, not pedagogical or cultural priority. 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: reading app. Contrast the rule using checking numbering systems without guessing language needs. 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 “Results have a deterministic sorted order, useful for testing but not automatically the best human-facing order.” Apply this procedure: Map to localised labels and apply a deliberate presentation order. The expected mechanism is: The endpoints reflect identifier sorting, not pedagogical or cultural priority. For the reading app, add one near-miss that exposes displaying technical identifier order as a finished user experience. 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: sorting tool. Stress-test the rule using understanding supported collations and locale relevance. 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 “Results have a deterministic sorted order, useful for testing but not automatically the best human-facing order.” Apply this procedure: Map to localised labels and apply a deliberate presentation order. The expected mechanism is: The endpoints reflect identifier sorting, not pedagogical or cultural priority. For the sorting tool, add one near-miss that exposes displaying technical identifier order as a finished user experience. 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: test laboratory. Explain the rule using checking keys, fresh arrays, canonical spelling and invalid input. 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 “Results have a deterministic sorted order, useful for testing but not automatically the best human-facing order.” Apply this procedure: Map to localised labels and apply a deliberate presentation order. The expected mechanism is: The endpoints reflect identifier sorting, not pedagogical or cultural priority. For the test laboratory, add one near-miss that exposes displaying technical identifier order as a finished user experience. 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: design review. Transfer the rule using combining runtime support, catalogue support and user preference. 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 “Results have a deterministic sorted order, useful for testing but not automatically the best human-facing order.” Apply this procedure: Map to localised labels and apply a deliberate presentation order. The expected mechanism is: The endpoints reflect identifier sorting, not pedagogical or cultural priority. For the design review, add one near-miss that exposes displaying technical identifier order as a finished user experience. 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 displaying technical identifier order as a finished user experience.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Map to localised labels and apply a deliberate presentation order.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from The array is sorted?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing displaying technical identifier order as a finished user experience be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny science converter with building a unit picker from standard identifiers. Include one ordinary case, one boundary and one deliberate failure caused by displaying technical identifier order as a finished user experience. 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: Results have a deterministic sorted order, useful for testing but not automatically the best human-facing order. It shows a trace, not only a final value. The ordinary case should demonstrate “The endpoints reflect identifier sorting, not pedagogical or cultural priority.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Map to localised labels and apply a deliberate presentation order. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For The array is sorted, separate the documented JavaScript Intl.supportedValuesOf() 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
Calendar identifiers can be passed where Intl date-time options accept a calendar, subject to locale resolution. 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 calendar should appear in every interface. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Intersect capability with the application feature set and user need.
For the calendar values name calendar systems chapter on JavaScript Intl.supportedValuesOf(), 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 calendar should appear in every interface. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const values=Intl.supportedValuesOf('calendar'); console.log(values.includes('gregory'));Explained result. A supporting runtime normally includes gregory; product policy still decides whether to offer 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: test laboratory. Stress-test the rule using checking keys, fresh arrays, canonical spelling and invalid input. 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 “Calendar identifiers can be passed where Intl date-time options accept a calendar, subject to locale resolution.” Apply this procedure: Intersect capability with the application feature set and user need. The expected mechanism is: A supporting runtime normally includes gregory; product policy still decides whether to offer it. For the test laboratory, add one near-miss that exposes assuming every calendar should appear in every interface. 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: design review. Explain the rule using combining runtime support, catalogue support and user preference. 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 “Calendar identifiers can be passed where Intl date-time options accept a calendar, subject to locale resolution.” Apply this procedure: Intersect capability with the application feature set and user need. The expected mechanism is: A supporting runtime normally includes gregory; product policy still decides whether to offer it. For the design review, add one near-miss that exposes assuming every calendar should appear in every interface. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family calendar. Transfer the rule using offering supported calendars while keeping a sensible default. 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 “Calendar identifiers can be passed where Intl date-time options accept a calendar, subject to locale resolution.” Apply this procedure: Intersect capability with the application feature set and user need. The expected mechanism is: A supporting runtime normally includes gregory; product policy still decides whether to offer it. For the family calendar, add one near-miss that exposes assuming every calendar should appear in every interface. 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: school timetable. Predict the rule using validating a chosen IANA time-zone identifier. 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 “Calendar identifiers can be passed where Intl date-time options accept a calendar, subject to locale resolution.” Apply this procedure: Intersect capability with the application feature set and user need. The expected mechanism is: A supporting runtime normally includes gregory; product policy still decides whether to offer it. For the school timetable, add one near-miss that exposes assuming every calendar should appear in every interface. 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 calendar should appear in every interface.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Intersect capability with the application feature set and user need.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from calendar values name calendar systems?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming every calendar should appear in every interface be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny reading app with checking numbering systems without guessing language needs. Include one ordinary case, one boundary and one deliberate failure caused by assuming every calendar should appear in every interface. 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: Calendar identifiers can be passed where Intl date-time options accept a calendar, subject to locale resolution. It shows a trace, not only a final value. The ordinary case should demonstrate “A supporting runtime normally includes gregory; product policy still decides whether to offer it.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Intersect capability with the application feature set and user need. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For calendar values name calendar systems, separate the documented JavaScript Intl.supportedValuesOf() 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
Collation identifiers name specialised ordering variants and exclude the reserved search and standard values from this reported set. 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 showing every collation as a language choice. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Keep language selection, sort purpose and collation variant separate.
For the collation values are not user languages chapter on JavaScript Intl.supportedValuesOf(), 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 showing every collation as a language choice. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
console.log(Intl.supportedValuesOf('collation').slice(0,8));Explained result. The list describes collation types, not locale tags. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family calendar. Explain the rule using offering supported calendars while keeping a sensible default. 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 “Collation identifiers name specialised ordering variants and exclude the reserved search and standard values from this reported set.” Apply this procedure: Keep language selection, sort purpose and collation variant separate. The expected mechanism is: The list describes collation types, not locale tags. For the family calendar, add one near-miss that exposes showing every collation as a language choice. 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: school timetable. Transfer the rule using validating a chosen IANA time-zone identifier. 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 “Collation identifiers name specialised ordering variants and exclude the reserved search and standard values from this reported set.” Apply this procedure: Keep language selection, sort purpose and collation variant separate. The expected mechanism is: The list describes collation types, not locale tags. For the school timetable, add one near-miss that exposes showing every collation as a language choice. 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 budget. Predict the rule using separating currency-code support from current exchange data. 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 “Collation identifiers name specialised ordering variants and exclude the reserved search and standard values from this reported set.” Apply this procedure: Keep language selection, sort purpose and collation variant separate. The expected mechanism is: The list describes collation types, not locale tags. For the CCA budget, add one near-miss that exposes showing every collation as a language choice. 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 converter. Contrast the rule using building a unit picker from standard identifiers. 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 “Collation identifiers name specialised ordering variants and exclude the reserved search and standard values from this reported set.” Apply this procedure: Keep language selection, sort purpose and collation variant separate. The expected mechanism is: The list describes collation types, not locale tags. For the science converter, add one near-miss that exposes showing every collation as a language choice. 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 showing every collation as a language choice.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Keep language selection, sort purpose and collation variant separate.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from collation values are not user languages?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing showing every collation as a language choice be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny sorting tool with understanding supported collations and locale relevance. Include one ordinary case, one boundary and one deliberate failure caused by showing every collation as a language choice. 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: Collation identifiers name specialised ordering variants and exclude the reserved search and standard values from this reported set. It shows a trace, not only a final value. The ordinary case should demonstrate “The list describes collation types, not locale tags.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Keep language selection, sort purpose and collation variant separate. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For collation values are not user languages, separate the documented JavaScript Intl.supportedValuesOf() 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
Currency results are canonical upper-case identifiers supported by the implementation. 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 claiming list membership means current legal tender or live rates exist. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Join codes to dated financial data and product eligibility separately.
For the currency values are ISO-style codes chapter on JavaScript Intl.supportedValuesOf(), 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 claiming list membership means current legal tender or live rates exist. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const codes=Intl.supportedValuesOf('currency'); console.log(codes.includes('SGD'));Explained result. SGD capability supports formatting decisions; it supplies neither a balance nor an exchange rate. 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 budget. Transfer the rule using separating currency-code support from current exchange data. 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 “Currency results are canonical upper-case identifiers supported by the implementation.” Apply this procedure: Join codes to dated financial data and product eligibility separately. The expected mechanism is: SGD capability supports formatting decisions; it supplies neither a balance nor an exchange rate. For the CCA budget, add one near-miss that exposes claiming list membership means current legal tender or live rates exist. 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 converter. Predict the rule using building a unit picker from standard identifiers. 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 “Currency results are canonical upper-case identifiers supported by the implementation.” Apply this procedure: Join codes to dated financial data and product eligibility separately. The expected mechanism is: SGD capability supports formatting decisions; it supplies neither a balance nor an exchange rate. For the science converter, add one near-miss that exposes claiming list membership means current legal tender or live rates exist. 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: reading app. Contrast the rule using checking numbering systems without guessing language needs. 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 “Currency results are canonical upper-case identifiers supported by the implementation.” Apply this procedure: Join codes to dated financial data and product eligibility separately. The expected mechanism is: SGD capability supports formatting decisions; it supplies neither a balance nor an exchange rate. For the reading app, add one near-miss that exposes claiming list membership means current legal tender or live rates exist. 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: sorting tool. Stress-test the rule using understanding supported collations and locale relevance. 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 “Currency results are canonical upper-case identifiers supported by the implementation.” Apply this procedure: Join codes to dated financial data and product eligibility separately. The expected mechanism is: SGD capability supports formatting decisions; it supplies neither a balance nor an exchange rate. For the sorting tool, add one near-miss that exposes claiming list membership means current legal tender or live rates exist. 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 claiming list membership means current legal tender or live rates exist.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Join codes to dated financial data and product eligibility 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from currency values are ISO-style codes?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing claiming list membership means current legal tender or live rates exist be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny test laboratory with checking keys, fresh arrays, canonical spelling and invalid input. Include one ordinary case, one boundary and one deliberate failure caused by claiming list membership means current legal tender or live rates exist. 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: Currency results are canonical upper-case identifiers supported by the implementation. It shows a trace, not only a final value. The ordinary case should demonstrate “SGD capability supports formatting decisions; it supplies neither a balance nor an exchange rate.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Join codes to dated financial data and product eligibility separately. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For currency values are ISO-style codes, separate the documented JavaScript Intl.supportedValuesOf() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
The list contains canonical numbering-system identifiers usable by relevant Intl options. 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 equating a numbering system with a language or mathematical ability. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Let locale negotiation choose a default and expose overrides only when useful.
For the numberingSystem values name digit systems chapter on JavaScript Intl.supportedValuesOf(), 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 equating a numbering system with a language or mathematical ability. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
console.log(Intl.supportedValuesOf('numberingSystem').includes('latn'));Explained result. latn may be supported, but that fact alone does not identify the user preference. 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: reading app. Predict the rule using checking numbering systems without guessing language needs. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The list contains canonical numbering-system identifiers usable by relevant Intl options.” Apply this procedure: Let locale negotiation choose a default and expose overrides only when useful. The expected mechanism is: latn may be supported, but that fact alone does not identify the user preference. For the reading app, add one near-miss that exposes equating a numbering system with a language or mathematical ability. 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: sorting tool. Contrast the rule using understanding supported collations and locale relevance. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The list contains canonical numbering-system identifiers usable by relevant Intl options.” Apply this procedure: Let locale negotiation choose a default and expose overrides only when useful. The expected mechanism is: latn may be supported, but that fact alone does not identify the user preference. For the sorting tool, add one near-miss that exposes equating a numbering system with a language or mathematical ability. 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: test laboratory. Stress-test the rule using checking keys, fresh arrays, canonical spelling and invalid input. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The list contains canonical numbering-system identifiers usable by relevant Intl options.” Apply this procedure: Let locale negotiation choose a default and expose overrides only when useful. The expected mechanism is: latn may be supported, but that fact alone does not identify the user preference. For the test laboratory, add one near-miss that exposes equating a numbering system with a language or mathematical ability. 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: design review. Explain the rule using combining runtime support, catalogue support and user preference. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The list contains canonical numbering-system identifiers usable by relevant Intl options.” Apply this procedure: Let locale negotiation choose a default and expose overrides only when useful. The expected mechanism is: latn may be supported, but that fact alone does not identify the user preference. For the design review, add one near-miss that exposes equating a numbering system with a language or mathematical ability. 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 equating a numbering system with a language or mathematical ability.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Let locale negotiation choose a default and expose overrides only when useful.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from numberingSystem values name digit systems?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing equating a numbering system with a language or mathematical ability be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny design review with combining runtime support, catalogue support and user preference. Include one ordinary case, one boundary and one deliberate failure caused by equating a numbering system with a language or mathematical ability. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The list contains canonical numbering-system identifiers usable by relevant Intl options. It shows a trace, not only a final value. The ordinary case should demonstrate “latn may be supported, but that fact alone does not identify the user preference.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Let locale negotiation choose a default and expose overrides only when useful. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For numberingSystem values name digit systems, separate the documented JavaScript Intl.supportedValuesOf() 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 12 OF 20 . Handle boundaries
12. timeZone values are identifiers, not offsets
Time-zone entries identify zones with rule histories; a fixed +08:00 offset is a different concept. 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 replacing Asia/Singapore with a hand-written offset everywhere. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Store the chosen identifier and format a date through DateTimeFormat.
For the timeZone values are identifiers, not offsets chapter on JavaScript Intl.supportedValuesOf(), 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 replacing Asia/Singapore with a hand-written offset everywhere. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const zones=Intl.supportedValuesOf('timeZone'); console.log(zones.includes('Asia/Singapore'));Explained result. Membership can validate a runtime identifier while the formatter applies its rules. 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: test laboratory. Contrast the rule using checking keys, fresh arrays, canonical spelling and invalid input. 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 “Time-zone entries identify zones with rule histories; a fixed +08:00 offset is a different concept.” Apply this procedure: Store the chosen identifier and format a date through DateTimeFormat. The expected mechanism is: Membership can validate a runtime identifier while the formatter applies its rules. For the test laboratory, add one near-miss that exposes replacing Asia/Singapore with a hand-written offset everywhere. 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: design review. Stress-test the rule using combining runtime support, catalogue support and user preference. 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 “Time-zone entries identify zones with rule histories; a fixed +08:00 offset is a different concept.” Apply this procedure: Store the chosen identifier and format a date through DateTimeFormat. The expected mechanism is: Membership can validate a runtime identifier while the formatter applies its rules. For the design review, add one near-miss that exposes replacing Asia/Singapore with a hand-written offset everywhere. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family calendar. Explain the rule using offering supported calendars while keeping a sensible default. 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 “Time-zone entries identify zones with rule histories; a fixed +08:00 offset is a different concept.” Apply this procedure: Store the chosen identifier and format a date through DateTimeFormat. The expected mechanism is: Membership can validate a runtime identifier while the formatter applies its rules. For the family calendar, add one near-miss that exposes replacing Asia/Singapore with a hand-written offset everywhere. 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: school timetable. Transfer the rule using validating a chosen IANA time-zone identifier. 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 “Time-zone entries identify zones with rule histories; a fixed +08:00 offset is a different concept.” Apply this procedure: Store the chosen identifier and format a date through DateTimeFormat. The expected mechanism is: Membership can validate a runtime identifier while the formatter applies its rules. For the school timetable, add one near-miss that exposes replacing Asia/Singapore with a hand-written offset everywhere. 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 replacing Asia/Singapore with a hand-written offset everywhere.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Store the chosen identifier and format a date through DateTimeFormat.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from timeZone values are identifiers, not offsets?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing replacing Asia/Singapore with a hand-written offset everywhere be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny family calendar with offering supported calendars while keeping a sensible default. Include one ordinary case, one boundary and one deliberate failure caused by replacing Asia/Singapore with a hand-written offset everywhere. 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: Time-zone entries identify zones with rule histories; a fixed +08:00 offset is a different concept. It shows a trace, not only a final value. The ordinary case should demonstrate “Membership can validate a runtime identifier while the formatter applies its rules.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Store the chosen identifier and format a date through DateTimeFormat. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For timeZone values are identifiers, not offsets, separate the documented JavaScript Intl.supportedValuesOf() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
The API reports canonical primary identifiers under the specification rules, so an application should not create duplicate choices from aliases. 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 presenting aliases as separate places without normalisation. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Store one canonical key and keep display labels separate.
For the Time-zone aliases require canonical care chapter on JavaScript Intl.supportedValuesOf(), 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 presenting aliases as separate places without normalisation. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const zones=Intl.supportedValuesOf('timeZone'); console.log(new Set(zones).size===zones.length);Explained result. The unique list is suitable as a canonical capability basis. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family calendar. Stress-test the rule using offering supported calendars while keeping a sensible default. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The API reports canonical primary identifiers under the specification rules, so an application should not create duplicate choices from aliases.” Apply this procedure: Store one canonical key and keep display labels separate. The expected mechanism is: The unique list is suitable as a canonical capability basis. For the family calendar, add one near-miss that exposes presenting aliases as separate places without normalisation. 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: school timetable. Explain the rule using validating a chosen IANA time-zone identifier. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The API reports canonical primary identifiers under the specification rules, so an application should not create duplicate choices from aliases.” Apply this procedure: Store one canonical key and keep display labels separate. The expected mechanism is: The unique list is suitable as a canonical capability basis. For the school timetable, add one near-miss that exposes presenting aliases as separate places without normalisation. 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 budget. Transfer the rule using separating currency-code support from current exchange data. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The API reports canonical primary identifiers under the specification rules, so an application should not create duplicate choices from aliases.” Apply this procedure: Store one canonical key and keep display labels separate. The expected mechanism is: The unique list is suitable as a canonical capability basis. For the CCA budget, add one near-miss that exposes presenting aliases as separate places without normalisation. 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 converter. Predict the rule using building a unit picker from standard identifiers. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The API reports canonical primary identifiers under the specification rules, so an application should not create duplicate choices from aliases.” Apply this procedure: Store one canonical key and keep display labels separate. The expected mechanism is: The unique list is suitable as a canonical capability basis. For the science converter, add one near-miss that exposes presenting aliases as separate places without normalisation. 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 presenting aliases as separate places without normalisation.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Store one canonical key and keep display labels separate.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from Time-zone aliases require canonical care?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing presenting aliases as separate places without normalisation be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny school timetable with validating a chosen IANA time-zone identifier. Include one ordinary case, one boundary and one deliberate failure caused by presenting aliases as separate places without normalisation. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The API reports canonical primary identifiers under the specification rules, so an application should not create duplicate choices from aliases. It shows a trace, not only a final value. The ordinary case should demonstrate “The unique list is suitable as a canonical capability basis.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Store one canonical key and keep display labels separate. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Time-zone aliases require canonical care, separate the documented JavaScript Intl.supportedValuesOf() mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.
Previous chapter . Contents . Next chapter
The unit list contains identifiers usable by number formatting for unit style; compound per-units are composed by supported syntax rather than all appearing as separate entries. 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 expecting every human measurement phrase in the returned array. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Check simple units and construct only supported compounds.
For the unit values are sanctioned simple units chapter on JavaScript Intl.supportedValuesOf(), 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 expecting every human measurement phrase in the returned array. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const units=Intl.supportedValuesOf('unit'); console.log(units.includes('meter'));Explained result. meter capability can participate in unit formatting; a label catalogue is still needed. 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 budget. Explain the rule using separating currency-code support from current exchange data. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The unit list contains identifiers usable by number formatting for unit style; compound per-units are composed by supported syntax rather than all appearing as separate entries.” Apply this procedure: Check simple units and construct only supported compounds. The expected mechanism is: meter capability can participate in unit formatting; a label catalogue is still needed. For the CCA budget, add one near-miss that exposes expecting every human measurement phrase in the returned array. 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 converter. Transfer the rule using building a unit picker from standard identifiers. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The unit list contains identifiers usable by number formatting for unit style; compound per-units are composed by supported syntax rather than all appearing as separate entries.” Apply this procedure: Check simple units and construct only supported compounds. The expected mechanism is: meter capability can participate in unit formatting; a label catalogue is still needed. For the science converter, add one near-miss that exposes expecting every human measurement phrase in the returned array. 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: reading app. Predict the rule using checking numbering systems without guessing language needs. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The unit list contains identifiers usable by number formatting for unit style; compound per-units are composed by supported syntax rather than all appearing as separate entries.” Apply this procedure: Check simple units and construct only supported compounds. The expected mechanism is: meter capability can participate in unit formatting; a label catalogue is still needed. For the reading app, add one near-miss that exposes expecting every human measurement phrase in the returned array. 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: sorting tool. Contrast the rule using understanding supported collations and locale relevance. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The unit list contains identifiers usable by number formatting for unit style; compound per-units are composed by supported syntax rather than all appearing as separate entries.” Apply this procedure: Check simple units and construct only supported compounds. The expected mechanism is: meter capability can participate in unit formatting; a label catalogue is still needed. For the sorting tool, add one near-miss that exposes expecting every human measurement phrase in the returned array. 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 expecting every human measurement phrase in the returned array.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Check simple units and construct only supported compounds.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from unit values are sanctioned simple units?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing expecting every human measurement phrase in the returned array be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny CCA budget with separating currency-code support from current exchange data. Include one ordinary case, one boundary and one deliberate failure caused by expecting every human measurement phrase in the returned array. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The unit list contains identifiers usable by number formatting for unit style; compound per-units are composed by supported syntax rather than all appearing as separate entries. It shows a trace, not only a final value. The ordinary case should demonstrate “meter capability can participate in unit formatting; a label catalogue is still needed.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Check simple units and construct only supported compounds. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For unit values are sanctioned simple units, separate the documented JavaScript Intl.supportedValuesOf() 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
Runtime support says the engine can handle an identifier, not that it is customary for one locale or task. 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 choosing the first supported calendar, unit or collation for every user. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Resolve locale defaults and ask for explicit preferences where the choice matters.
For the Support is not locale appropriateness chapter on JavaScript Intl.supportedValuesOf(), 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 choosing the first supported calendar, unit or collation for every user. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const locale='en-SG'; const options={timeZone:'Asia/Singapore'};Explained result. The explicit policy combines user context with runtime capability. 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: reading app. Transfer the rule using checking numbering systems without guessing language needs. 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 “Runtime support says the engine can handle an identifier, not that it is customary for one locale or task.” Apply this procedure: Resolve locale defaults and ask for explicit preferences where the choice matters. The expected mechanism is: The explicit policy combines user context with runtime capability. For the reading app, add one near-miss that exposes choosing the first supported calendar, unit or collation for every user. 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: sorting tool. Predict the rule using understanding supported collations and locale relevance. 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 “Runtime support says the engine can handle an identifier, not that it is customary for one locale or task.” Apply this procedure: Resolve locale defaults and ask for explicit preferences where the choice matters. The expected mechanism is: The explicit policy combines user context with runtime capability. For the sorting tool, add one near-miss that exposes choosing the first supported calendar, unit or collation for every user. 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: test laboratory. Contrast the rule using checking keys, fresh arrays, canonical spelling and invalid input. 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 “Runtime support says the engine can handle an identifier, not that it is customary for one locale or task.” Apply this procedure: Resolve locale defaults and ask for explicit preferences where the choice matters. The expected mechanism is: The explicit policy combines user context with runtime capability. For the test laboratory, add one near-miss that exposes choosing the first supported calendar, unit or collation for every user. 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: design review. Stress-test the rule using combining runtime support, catalogue support and user preference. 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 “Runtime support says the engine can handle an identifier, not that it is customary for one locale or task.” Apply this procedure: Resolve locale defaults and ask for explicit preferences where the choice matters. The expected mechanism is: The explicit policy combines user context with runtime capability. For the design review, add one near-miss that exposes choosing the first supported calendar, unit or collation for every user. 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 choosing the first supported calendar, unit or collation for every user.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Resolve locale defaults and ask for explicit preferences where the choice matters.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from Support is not locale appropriateness?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing choosing the first supported calendar, unit or collation for every user be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny science converter with building a unit picker from standard identifiers. Include one ordinary case, one boundary and one deliberate failure caused by choosing the first supported calendar, unit or collation for every user. 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: Runtime support says the engine can handle an identifier, not that it is customary for one locale or task. It shows a trace, not only a final value. The ordinary case should demonstrate “The explicit policy combines user context with runtime capability.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Resolve locale defaults and ask for explicit preferences where the choice matters. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Support is not locale appropriateness, separate the documented JavaScript Intl.supportedValuesOf() 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 browser may format an identifier while the application lacks translations, data, testing or business rules for 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 building a selector directly from the complete runtime array. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Intersect runtime values with an application allow-list.
For the Support is not application support chapter on JavaScript Intl.supportedValuesOf(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on building a selector directly from the complete runtime array. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const offered=Intl.supportedValuesOf('currency').filter(x=>appCurrencies.has(x));Explained result. The intersection reflects two different capability layers. 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: test laboratory. Predict the rule using checking keys, fresh arrays, canonical spelling and invalid input. 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 browser may format an identifier while the application lacks translations, data, testing or business rules for it.” Apply this procedure: Intersect runtime values with an application allow-list. The expected mechanism is: The intersection reflects two different capability layers. For the test laboratory, add one near-miss that exposes building a selector directly from the complete runtime array. 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: design review. Contrast the rule using combining runtime support, catalogue support and user preference. 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 browser may format an identifier while the application lacks translations, data, testing or business rules for it.” Apply this procedure: Intersect runtime values with an application allow-list. The expected mechanism is: The intersection reflects two different capability layers. For the design review, add one near-miss that exposes building a selector directly from the complete runtime array. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family calendar. Stress-test the rule using offering supported calendars while keeping a sensible default. 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 browser may format an identifier while the application lacks translations, data, testing or business rules for it.” Apply this procedure: Intersect runtime values with an application allow-list. The expected mechanism is: The intersection reflects two different capability layers. For the family calendar, add one near-miss that exposes building a selector directly from the complete runtime array. 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: school timetable. Explain the rule using validating a chosen IANA time-zone identifier. 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 browser may format an identifier while the application lacks translations, data, testing or business rules for it.” Apply this procedure: Intersect runtime values with an application allow-list. The expected mechanism is: The intersection reflects two different capability layers. For the school timetable, add one near-miss that exposes building a selector directly from the complete runtime array. 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 building a selector directly from the complete runtime array.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Intersect runtime values with an application allow-list.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from Support is not application support?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing building a selector directly from the complete runtime array be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny reading app with checking numbering systems without guessing language needs. Include one ordinary case, one boundary and one deliberate failure caused by building a selector directly from the complete runtime array. 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 browser may format an identifier while the application lacks translations, data, testing or business rules for it. It shows a trace, not only a final value. The ordinary case should demonstrate “The intersection reflects two different capability layers.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Intersect runtime values with an application allow-list. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Support is not application support, separate the documented JavaScript Intl.supportedValuesOf() 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
Older engines may lack Intl.supportedValuesOf, so production code should test the method before calling 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 crashing the interface on a runtime without the static method. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Check typeof and use a maintained product list or disable the choice safely.
For the Feature detection needs a fallback chapter on JavaScript Intl.supportedValuesOf(), 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 crashing the interface on a runtime without the static method. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const hasSupportedValues=typeof Intl.supportedValuesOf==='function';Explained result. The boolean gates use without pretending a fallback list is runtime discovery. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.
Four purposeful transfer cases
Case 1: family calendar. Contrast the rule using offering supported calendars while keeping a sensible default. 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 “Older engines may lack Intl.supportedValuesOf, so production code should test the method before calling it.” Apply this procedure: Check typeof and use a maintained product list or disable the choice safely. The expected mechanism is: The boolean gates use without pretending a fallback list is runtime discovery. For the family calendar, add one near-miss that exposes crashing the interface on a runtime without the static method. 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: school timetable. Stress-test the rule using validating a chosen IANA time-zone identifier. 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 “Older engines may lack Intl.supportedValuesOf, so production code should test the method before calling it.” Apply this procedure: Check typeof and use a maintained product list or disable the choice safely. The expected mechanism is: The boolean gates use without pretending a fallback list is runtime discovery. For the school timetable, add one near-miss that exposes crashing the interface on a runtime without the static method. 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 budget. Explain the rule using separating currency-code support from current exchange data. 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 “Older engines may lack Intl.supportedValuesOf, so production code should test the method before calling it.” Apply this procedure: Check typeof and use a maintained product list or disable the choice safely. The expected mechanism is: The boolean gates use without pretending a fallback list is runtime discovery. For the CCA budget, add one near-miss that exposes crashing the interface on a runtime without the static method. 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 converter. Transfer the rule using building a unit picker from standard identifiers. 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 “Older engines may lack Intl.supportedValuesOf, so production code should test the method before calling it.” Apply this procedure: Check typeof and use a maintained product list or disable the choice safely. The expected mechanism is: The boolean gates use without pretending a fallback list is runtime discovery. For the science converter, add one near-miss that exposes crashing the interface on a runtime without the static method. 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 crashing the interface on a runtime without the static method.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Check typeof and use a maintained product list or disable the choice safely.” and record the first changed observation.
- Transfer check: repeat the rule in a second context and identify what remains invariant.
A parent does not need to know the final JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from Feature detection needs a fallback?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing crashing the interface on a runtime without the static method be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny sorting tool with understanding supported collations and locale relevance. Include one ordinary case, one boundary and one deliberate failure caused by crashing the interface on a runtime without the static method. 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: Older engines may lack Intl.supportedValuesOf, so production code should test the method before calling it. It shows a trace, not only a final value. The ordinary case should demonstrate “The boolean gates use without pretending a fallback list is runtime discovery.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Check typeof and use a maintained product list or disable the choice safely. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Feature detection needs a fallback, separate the documented JavaScript Intl.supportedValuesOf() 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 18 OF 20 . Transfer with judgment
18. Do not pin the complete list in brittle tests
Implementation data can evolve with standards and data updates, so tests should assert required invariants and known essentials rather than one giant snapshot. 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 failing deployments because a valid identifier was added. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test uniqueness, sorting, type and application-required values.
For the Do not pin the complete list in brittle tests chapter on JavaScript Intl.supportedValuesOf(), 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 failing deployments because a valid identifier was added. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const zones=Intl.supportedValuesOf('timeZone'); if(!zones.includes('Asia/Singapore')) throw Error('required zone absent');Explained result. The test protects the product requirement without freezing every entry. 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 budget. Stress-test the rule using separating currency-code support from current exchange data. 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 “Implementation data can evolve with standards and data updates, so tests should assert required invariants and known essentials rather than one giant snapshot.” Apply this procedure: Test uniqueness, sorting, type and application-required values. The expected mechanism is: The test protects the product requirement without freezing every entry. For the CCA budget, add one near-miss that exposes failing deployments because a valid identifier was added. 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 converter. Explain the rule using building a unit picker from standard identifiers. 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 “Implementation data can evolve with standards and data updates, so tests should assert required invariants and known essentials rather than one giant snapshot.” Apply this procedure: Test uniqueness, sorting, type and application-required values. The expected mechanism is: The test protects the product requirement without freezing every entry. For the science converter, add one near-miss that exposes failing deployments because a valid identifier was added. 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: reading app. Transfer the rule using checking numbering systems without guessing language needs. 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 “Implementation data can evolve with standards and data updates, so tests should assert required invariants and known essentials rather than one giant snapshot.” Apply this procedure: Test uniqueness, sorting, type and application-required values. The expected mechanism is: The test protects the product requirement without freezing every entry. For the reading app, add one near-miss that exposes failing deployments because a valid identifier was added. 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: sorting tool. Predict the rule using understanding supported collations and locale relevance. 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 “Implementation data can evolve with standards and data updates, so tests should assert required invariants and known essentials rather than one giant snapshot.” Apply this procedure: Test uniqueness, sorting, type and application-required values. The expected mechanism is: The test protects the product requirement without freezing every entry. For the sorting tool, add one near-miss that exposes failing deployments because a valid identifier was added. 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 failing deployments because a valid identifier was added.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Test uniqueness, sorting, type and application-required values.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from Do not pin the complete list in brittle tests?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing failing deployments because a valid identifier was added be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny test laboratory with checking keys, fresh arrays, canonical spelling and invalid input. Include one ordinary case, one boundary and one deliberate failure caused by failing deployments because a valid identifier was added. 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: Implementation data can evolve with standards and data updates, so tests should assert required invariants and known essentials rather than one giant snapshot. It shows a trace, not only a final value. The ordinary case should demonstrate “The test protects the product requirement without freezing every entry.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Test uniqueness, sorting, type and application-required values. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Do not pin the complete list in brittle tests, separate the documented JavaScript Intl.supportedValuesOf() 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. Validate stored values at the right layer
A stored identifier can be structurally plausible yet unsupported by this runtime or unavailable to the product. 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 one regex as complete internationalisation validation. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Check canonical runtime membership, then application policy and migration handling.
For the Validate stored values at the right layer chapter on JavaScript Intl.supportedValuesOf(), 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 one regex as complete internationalisation validation. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const supported=new Set(Intl.supportedValuesOf('timeZone')); const ok=supported.has(savedZone);Explained result. Membership answers the runtime layer; other layers still need their own decisions. 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: reading app. Explain the rule using checking numbering systems without guessing language needs. 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 stored identifier can be structurally plausible yet unsupported by this runtime or unavailable to the product.” Apply this procedure: Check canonical runtime membership, then application policy and migration handling. The expected mechanism is: Membership answers the runtime layer; other layers still need their own decisions. For the reading app, add one near-miss that exposes using one regex as complete internationalisation validation. 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: sorting tool. Transfer the rule using understanding supported collations and locale relevance. 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 stored identifier can be structurally plausible yet unsupported by this runtime or unavailable to the product.” Apply this procedure: Check canonical runtime membership, then application policy and migration handling. The expected mechanism is: Membership answers the runtime layer; other layers still need their own decisions. For the sorting tool, add one near-miss that exposes using one regex as complete internationalisation validation. 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: test laboratory. Predict the rule using checking keys, fresh arrays, canonical spelling and invalid input. 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 stored identifier can be structurally plausible yet unsupported by this runtime or unavailable to the product.” Apply this procedure: Check canonical runtime membership, then application policy and migration handling. The expected mechanism is: Membership answers the runtime layer; other layers still need their own decisions. For the test laboratory, add one near-miss that exposes using one regex as complete internationalisation validation. 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: design review. Contrast the rule using combining runtime support, catalogue support and user preference. 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 stored identifier can be structurally plausible yet unsupported by this runtime or unavailable to the product.” Apply this procedure: Check canonical runtime membership, then application policy and migration handling. The expected mechanism is: Membership answers the runtime layer; other layers still need their own decisions. For the design review, add one near-miss that exposes using one regex as complete internationalisation validation. 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 one regex as complete internationalisation validation.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Check canonical runtime membership, then application policy and migration handling.” 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from Validate stored values at the right layer?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using one regex as complete internationalisation validation be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny design review with combining runtime support, catalogue support and user preference. Include one ordinary case, one boundary and one deliberate failure caused by using one regex as complete internationalisation validation. 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 stored identifier can be structurally plausible yet unsupported by this runtime or unavailable to the product. It shows a trace, not only a final value. The ordinary case should demonstrate “Membership answers the runtime layer; other layers still need their own decisions.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Check canonical runtime membership, then application policy and migration handling. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Validate stored values at the right layer, separate the documented JavaScript Intl.supportedValuesOf() 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. Use the method as evidence, not authority over users
The API is valuable for capability-aware interfaces and diagnostics when its boundary is explicit. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.
The high-value mistake in this chapter is turning engine data into assumptions about identity, geography or culture. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Document key, runtime, product intersection, label source and fallback.
For the Use the method as evidence, not authority over users chapter on JavaScript Intl.supportedValuesOf(), use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on turning engine data into assumptions about identity, geography or culture. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.
Core worked example
const audit={key:'timeZone',runtime:true,catalogue:true,userSelected:true};Explained result. A layered audit preserves user choice and makes the capability claim testable. 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: test laboratory. Transfer the rule using checking keys, fresh arrays, canonical spelling and invalid input. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The API is valuable for capability-aware interfaces and diagnostics when its boundary is explicit.” Apply this procedure: Document key, runtime, product intersection, label source and fallback. The expected mechanism is: A layered audit preserves user choice and makes the capability claim testable. For the test laboratory, add one near-miss that exposes turning engine data into assumptions about identity, geography or culture. 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: design review. Predict the rule using combining runtime support, catalogue support and user preference. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The API is valuable for capability-aware interfaces and diagnostics when its boundary is explicit.” Apply this procedure: Document key, runtime, product intersection, label source and fallback. The expected mechanism is: A layered audit preserves user choice and makes the capability claim testable. For the design review, add one near-miss that exposes turning engine data into assumptions about identity, geography or culture. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.
Case 3: family calendar. Contrast the rule using offering supported calendars while keeping a sensible default. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The API is valuable for capability-aware interfaces and diagnostics when its boundary is explicit.” Apply this procedure: Document key, runtime, product intersection, label source and fallback. The expected mechanism is: A layered audit preserves user choice and makes the capability claim testable. For the family calendar, add one near-miss that exposes turning engine data into assumptions about identity, geography or culture. 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: school timetable. Stress-test the rule using validating a chosen IANA time-zone identifier. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.
Reasoned route. Begin with “The API is valuable for capability-aware interfaces and diagnostics when its boundary is explicit.” Apply this procedure: Document key, runtime, product intersection, label source and fallback. The expected mechanism is: A layered audit preserves user choice and makes the capability claim testable. For the school timetable, add one near-miss that exposes turning engine data into assumptions about identity, geography or culture. 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 turning engine data into assumptions about identity, geography or culture.
- Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
- Repair check: use the reversible procedure “Document key, runtime, product intersection, label source and 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 JavaScript Intl.supportedValuesOf() syntax. For this chapter, useful prompts are: “What did you expect from Use the method as evidence, not authority over users?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing turning engine data into assumptions about identity, geography or culture be made smaller?” The learner, not the parent, should supply the technical explanation.
Practice with an explained answer
Question. Build a tiny family calendar with offering supported calendars while keeping a sensible default. Include one ordinary case, one boundary and one deliberate failure caused by turning engine data into assumptions about identity, geography or culture. Predict each result before using a tool, then report the first point where observation differs from prediction.
Answer guide. A strong response starts with the rule: The API is valuable for capability-aware interfaces and diagnostics when its boundary is explicit. It shows a trace, not only a final value. The ordinary case should demonstrate “A layered audit preserves user choice and makes the capability claim testable.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Document key, runtime, product intersection, label source and fallback. Other data choices are valid when the evidence supports the same causal chain.
Decision and transfer
For Use the method as evidence, not authority over users, separate the documented JavaScript Intl.supportedValuesOf() 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. family calendar: model, boundary and recovery
Create a small family calendar using offering supported calendars while keeping a sensible default. Combine “The method reports supported identifiers” 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: Intl.supportedValuesOf takes one key and returns identifiers the current implementation supports for that category. Apply: Request one key and label the result as capability data. Verify: The output is an array of supported calendar identifiers, not formatted dates. 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. school timetable: model, boundary and recovery
Create a small school timetable using validating a chosen IANA time-zone identifier. Combine “Unknown keys throw RangeError” 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: An unsupported key is a programming error rather than an empty capability set. Apply: Catch RangeError at a configuration boundary and fix the caller. Verify: The misspelling produces RangeError. 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 budget: model, boundary and recovery
Create a small CCA budget using separating currency-code support from current exchange data. Combine “The array is sorted” 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: Results have a deterministic sorted order, useful for testing but not automatically the best human-facing order. Apply: Map to localised labels and apply a deliberate presentation order. Verify: The endpoints reflect identifier sorting, not pedagogical or cultural priority. 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 converter: model, boundary and recovery
Create a small science converter using building a unit picker from standard identifiers. Combine “currency values are ISO-style codes” 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: Currency results are canonical upper-case identifiers supported by the implementation. Apply: Join codes to dated financial data and product eligibility separately. Verify: SGD capability supports formatting decisions; it supplies neither a balance nor an exchange rate. 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. reading app: model, boundary and recovery
Create a small reading app using checking numbering systems without guessing language needs. Combine “Time-zone aliases require canonical care” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: The API reports canonical primary identifiers under the specification rules, so an application should not create duplicate choices from aliases. Apply: Store one canonical key and keep display labels separate. Verify: The unique list is suitable as a canonical capability basis. 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. sorting tool: model, boundary and recovery
Create a small sorting tool using understanding supported collations and locale relevance. Combine “Support is not application support” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: A browser may format an identifier while the application lacks translations, data, testing or business rules for it. Apply: Intersect runtime values with an application allow-list. Verify: The intersection reflects two different capability layers. 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. test laboratory: model, boundary and recovery
Create a small test laboratory using checking keys, fresh arrays, canonical spelling and invalid input. Combine “Validate stored values at the right layer” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.
Explained route. Start with: A stored identifier can be structurally plausible yet unsupported by this runtime or unavailable to the product. Apply: Check canonical runtime membership, then application policy and migration handling. Verify: Membership answers the runtime layer; other layers still need their own decisions. 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. design review: model, boundary and recovery
Create a small design review using combining runtime support, catalogue support and user preference. Combine “It is a static Intl method” 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: Call it on Intl itself; no NumberFormat, Locale or other formatter instance is constructed. Apply: Check the owning object and function type. Verify: A supporting runtime prints function. 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.
