How to Master JavaScript Intl.Collator in Punggol Tuition

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.Collator constructs a locale-sensitive string comparator. Its compare method returns a negative number, zero or a positive number according to the resolved collation rules; the magnitude is not a portable promise. Mastery means choosing options for the reader job, preserving data separately from display order, testing culturally relevant examples and understanding that collation equality is not the same as code-unit identity. 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

Collator produces a comparator
Only the sign is portable
Locale negotiation resolves a supported request
usage distinguishes sort and search

Chapters 5-8 . Use the core tools

sensitivity controls distinctions
Collation equality is not identity
numeric orders digit sequences naturally
numeric is not arithmetic

Chapters 9-12 . Handle boundaries

caseFirst is a tie preference
ignorePunctuation changes the comparison surface
collation selects a named ordering when supported
compare is a bound callable

Chapters 13-16 . Debug and verify

Sorting mutates unless a copying method is chosen
Stable sort preserves comparator ties
Comparator chains need a final identity policy
Unicode normalization is a separate choice

Chapters 17-20 . Transfer with judgment

Cache by policy, not by guess
Test culturally relevant fixtures
Do not infer language or personhood from order
Choose Collator for a declared reader job

CHAPTER 1 OF 20 . Build the model

1. Collator produces a comparator

Back to contents

new Intl.Collator creates an object whose compare function can be passed to sorting operations. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is calling localeCompare inconsistently at scattered call sites with different implicit choices. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Construct one collator at the policy boundary and reuse its compare function.

For the Collator produces a comparator chapter on JavaScript Intl.Collator, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on calling localeCompare inconsistently at scattered call sites with different implicit choices. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const c=new Intl.Collator('en-SG'); ['b','a'].sort(c.compare)

Explained result. The array is ordered using the collator rather than raw code-unit comparison. 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: homework titles. Predict the rule using sorting multilingual assignment names for a dashboard. 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 “new Intl.Collator creates an object whose compare function can be passed to sorting operations.” Apply this procedure: Construct one collator at the policy boundary and reuse its compare function. The expected mechanism is: The array is ordered using the collator rather than raw code-unit comparison. For the homework titles, add one near-miss that exposes calling localeCompare inconsistently at scattered call sites with different implicit choices. 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: library shelf. Contrast the rule using ordering titles while handling articles and punctuation policy. 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 “new Intl.Collator creates an object whose compare function can be passed to sorting operations.” Apply this procedure: Construct one collator at the policy boundary and reuse its compare function. The expected mechanism is: The array is ordered using the collator rather than raw code-unit comparison. For the library shelf, add one near-miss that exposes calling localeCompare inconsistently at scattered call sites with different implicit choices. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: CCA roster. Stress-test the rule using presenting participant names without changing stored identities. 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 “new Intl.Collator creates an object whose compare function can be passed to sorting operations.” Apply this procedure: Construct one collator at the policy boundary and reuse its compare function. The expected mechanism is: The array is ordered using the collator rather than raw code-unit comparison. For the CCA roster, add one near-miss that exposes calling localeCompare inconsistently at scattered call sites with different implicit choices. 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 table. Explain the rule using sorting labels with embedded numbers such as Sample 2 and Sample 10. 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 “new Intl.Collator creates an object whose compare function can be passed to sorting operations.” Apply this procedure: Construct one collator at the policy boundary and reuse its compare function. The expected mechanism is: The array is ordered using the collator rather than raw code-unit comparison. For the science table, add one near-miss that exposes calling localeCompare inconsistently at scattered call sites with different implicit choices. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers calling localeCompare inconsistently at scattered call sites with different implicit choices.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Construct one collator at the policy boundary and reuse its compare function.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from Collator produces a comparator?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing calling localeCompare inconsistently at scattered call sites with different implicit choices be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family contacts with grouping display names while retaining unique identifiers. Include one ordinary case, one boundary and one deliberate failure caused by calling localeCompare inconsistently at scattered call sites with different implicit choices. 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: new Intl.Collator creates an object whose compare function can be passed to sorting operations. It shows a trace, not only a final value. The ordinary case should demonstrate “The array is ordered using the collator rather than raw code-unit comparison.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Construct one collator at the policy boundary and reuse its compare function. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Collator produces a comparator, separate the documented JavaScript Intl.Collator 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 2 OF 20 . Build the model

2. Only the sign is portable

Back to contents

compare returns a negative, zero or positive number; programs should not depend on a result being exactly minus one or one. 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 tests that assert a particular non-zero magnitude. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Assert less than zero, equal to zero or greater than zero.

For the Only the sign is portable chapter on JavaScript Intl.Collator, 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 tests that assert a particular non-zero magnitude. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

Math.sign(c.compare('a','b'))

Explained result. The sign communicates order; the engine may choose any negative magnitude. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: CCA roster. Contrast the rule using presenting participant names without changing stored identities. 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 “compare returns a negative, zero or positive number; programs should not depend on a result being exactly minus one or one.” Apply this procedure: Assert less than zero, equal to zero or greater than zero. The expected mechanism is: The sign communicates order; the engine may choose any negative magnitude. For the CCA roster, add one near-miss that exposes writing tests that assert a particular non-zero magnitude. 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 table. Stress-test the rule using sorting labels with embedded numbers such as Sample 2 and Sample 10. 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 “compare returns a negative, zero or positive number; programs should not depend on a result being exactly minus one or one.” Apply this procedure: Assert less than zero, equal to zero or greater than zero. The expected mechanism is: The sign communicates order; the engine may choose any negative magnitude. For the science table, add one near-miss that exposes writing tests that assert a particular non-zero magnitude. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: revision files. Explain the rule using ordering chapter names by their visible numeric suffix. 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 “compare returns a negative, zero or positive number; programs should not depend on a result being exactly minus one or one.” Apply this procedure: Assert less than zero, equal to zero or greater than zero. The expected mechanism is: The sign communicates order; the engine may choose any negative magnitude. For the revision files, add one near-miss that exposes writing tests that assert a particular non-zero magnitude. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: family contacts. Transfer the rule using grouping display names while retaining unique 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 “compare returns a negative, zero or positive number; programs should not depend on a result being exactly minus one or one.” Apply this procedure: Assert less than zero, equal to zero or greater than zero. The expected mechanism is: The sign communicates order; the engine may choose any negative magnitude. For the family contacts, add one near-miss that exposes writing tests that assert a particular non-zero magnitude. 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 tests that assert a particular non-zero magnitude.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Assert less than zero, equal to zero or greater than zero.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from Only the sign is portable?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing writing tests that assert a particular non-zero magnitude be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny transport list with ordering station display names for a locale-aware menu. Include one ordinary case, one boundary and one deliberate failure caused by writing tests that assert a particular non-zero magnitude. 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: compare returns a negative, zero or positive number; programs should not depend on a result being exactly minus one or one. It shows a trace, not only a final value. The ordinary case should demonstrate “The sign communicates order; the engine may choose any negative magnitude.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Assert less than zero, equal to zero or greater than zero. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Only the sign is portable, separate the documented JavaScript Intl.Collator 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 3 OF 20 . Build the model

3. Locale negotiation resolves a supported request

Back to contents

The requested locale list is negotiated against implementation support and the resolved locale can be inspected. 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 the first requested tag is always used exactly as written. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Call resolvedOptions and record the locale actually selected.

For the Locale negotiation resolves a supported request chapter on JavaScript Intl.Collator, 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 the first requested tag is always used exactly as written. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

new Intl.Collator(['ban','id']).resolvedOptions().locale

Explained result. The result identifies the supported locale chosen by the runtime rather than a guessed promise. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: revision files. Stress-test the rule using ordering chapter names by their visible numeric suffix. 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 requested locale list is negotiated against implementation support and the resolved locale can be inspected.” Apply this procedure: Call resolvedOptions and record the locale actually selected. The expected mechanism is: The result identifies the supported locale chosen by the runtime rather than a guessed promise. For the revision files, add one near-miss that exposes assuming the first requested tag is always used exactly as written. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: family contacts. Explain the rule using grouping display names while retaining unique 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 requested locale list is negotiated against implementation support and the resolved locale can be inspected.” Apply this procedure: Call resolvedOptions and record the locale actually selected. The expected mechanism is: The result identifies the supported locale chosen by the runtime rather than a guessed promise. For the family contacts, add one near-miss that exposes assuming the first requested tag is always used exactly as written. 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: transport list. Transfer the rule using ordering station display names for a locale-aware menu. 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 requested locale list is negotiated against implementation support and the resolved locale can be inspected.” Apply this procedure: Call resolvedOptions and record the locale actually selected. The expected mechanism is: The result identifies the supported locale chosen by the runtime rather than a guessed promise. For the transport list, add one near-miss that exposes assuming the first requested tag is always used exactly as written. 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: project search. Predict the rule using comparing query labels with a deliberate sensitivity policy. 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 requested locale list is negotiated against implementation support and the resolved locale can be inspected.” Apply this procedure: Call resolvedOptions and record the locale actually selected. The expected mechanism is: The result identifies the supported locale chosen by the runtime rather than a guessed promise. For the project search, add one near-miss that exposes assuming the first requested tag is always used exactly as written. 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 the first requested tag is always used exactly as written.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Call resolvedOptions and record the locale actually selected.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from Locale negotiation resolves a supported request?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming the first requested tag is always used exactly as written be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny project search with comparing query labels with a deliberate sensitivity policy. Include one ordinary case, one boundary and one deliberate failure caused by assuming the first requested tag is always used exactly as written. 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 requested locale list is negotiated against implementation support and the resolved locale can be inspected. It shows a trace, not only a final value. The ordinary case should demonstrate “The result identifies the supported locale chosen by the runtime rather than a guessed promise.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Call resolvedOptions and record the locale actually selected. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Locale negotiation resolves a supported request, separate the documented JavaScript Intl.Collator 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 4 OF 20 . Build the model

4. usage distinguishes sort and search

Back to contents

The usage option states whether the collator supports ordering or matching; search collation is not a general ordering contract. 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 usage search as a comparator for a permanent sorted list. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use sort for ordering and treat search results as match decisions.

For the usage distinguishes sort and search chapter on JavaScript Intl.Collator, 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 usage search as a comparator for a permanent sorted list. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

new Intl.Collator('en',{usage:'search'})

Explained result. The object is configured for search comparison, not for a user-visible total order. 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: transport list. Explain the rule using ordering station display names for a locale-aware menu. 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 usage option states whether the collator supports ordering or matching; search collation is not a general ordering contract.” Apply this procedure: Use sort for ordering and treat search results as match decisions. The expected mechanism is: The object is configured for search comparison, not for a user-visible total order. For the transport list, add one near-miss that exposes using usage search as a comparator for a permanent sorted list. 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: project search. Transfer the rule using comparing query labels with a deliberate sensitivity policy. 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 usage option states whether the collator supports ordering or matching; search collation is not a general ordering contract.” Apply this procedure: Use sort for ordering and treat search results as match decisions. The expected mechanism is: The object is configured for search comparison, not for a user-visible total order. For the project search, add one near-miss that exposes using usage search as a comparator for a permanent sorted list. 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: homework titles. Predict the rule using sorting multilingual assignment names for a dashboard. 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 usage option states whether the collator supports ordering or matching; search collation is not a general ordering contract.” Apply this procedure: Use sort for ordering and treat search results as match decisions. The expected mechanism is: The object is configured for search comparison, not for a user-visible total order. For the homework titles, add one near-miss that exposes using usage search as a comparator for a permanent sorted list. 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: library shelf. Contrast the rule using ordering titles while handling articles and punctuation policy. 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 usage option states whether the collator supports ordering or matching; search collation is not a general ordering contract.” Apply this procedure: Use sort for ordering and treat search results as match decisions. The expected mechanism is: The object is configured for search comparison, not for a user-visible total order. For the library shelf, add one near-miss that exposes using usage search as a comparator for a permanent sorted list. 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 usage search as a comparator for a permanent sorted list.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Use sort for ordering and treat search results as match decisions.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from usage distinguishes sort and search?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using usage search as a comparator for a permanent sorted list be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework titles with sorting multilingual assignment names for a dashboard. Include one ordinary case, one boundary and one deliberate failure caused by using usage search as a comparator for a permanent sorted list. 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 usage option states whether the collator supports ordering or matching; search collation is not a general ordering contract. It shows a trace, not only a final value. The ordinary case should demonstrate “The object is configured for search comparison, not for a user-visible total order.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use sort for ordering and treat search results as match decisions. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For usage distinguishes sort and search, separate the documented JavaScript Intl.Collator mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 5 OF 20 . Use the core tools

5. sensitivity controls distinctions

Back to contents

Sensitivity can consider base letters, accents, case or both accent and case, subject to the resolved collation. 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 describing base sensitivity as lowercasing and stripping marks in every language. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test pairs relevant to the chosen locale and read resolved options.

For the sensitivity controls distinctions chapter on JavaScript Intl.Collator, 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 describing base sensitivity as lowercasing and stripping marks in every language. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

new Intl.Collator('en',{sensitivity:'base'}).compare('a','A')

Explained result. The comparison can report collation equality even though the strings remain distinct values. 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: homework titles. Transfer the rule using sorting multilingual assignment names for a dashboard. 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 “Sensitivity can consider base letters, accents, case or both accent and case, subject to the resolved collation.” Apply this procedure: Test pairs relevant to the chosen locale and read resolved options. The expected mechanism is: The comparison can report collation equality even though the strings remain distinct values. For the homework titles, add one near-miss that exposes describing base sensitivity as lowercasing and stripping marks in every language. 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: library shelf. Predict the rule using ordering titles while handling articles and punctuation policy. 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 “Sensitivity can consider base letters, accents, case or both accent and case, subject to the resolved collation.” Apply this procedure: Test pairs relevant to the chosen locale and read resolved options. The expected mechanism is: The comparison can report collation equality even though the strings remain distinct values. For the library shelf, add one near-miss that exposes describing base sensitivity as lowercasing and stripping marks in every language. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: CCA roster. Contrast the rule using presenting participant names without changing stored identities. 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 “Sensitivity can consider base letters, accents, case or both accent and case, subject to the resolved collation.” Apply this procedure: Test pairs relevant to the chosen locale and read resolved options. The expected mechanism is: The comparison can report collation equality even though the strings remain distinct values. For the CCA roster, add one near-miss that exposes describing base sensitivity as lowercasing and stripping marks in every language. 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 table. Stress-test the rule using sorting labels with embedded numbers such as Sample 2 and Sample 10. 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 “Sensitivity can consider base letters, accents, case or both accent and case, subject to the resolved collation.” Apply this procedure: Test pairs relevant to the chosen locale and read resolved options. The expected mechanism is: The comparison can report collation equality even though the strings remain distinct values. For the science table, add one near-miss that exposes describing base sensitivity as lowercasing and stripping marks in every language. 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 describing base sensitivity as lowercasing and stripping marks in every language.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Test pairs relevant to the chosen locale and read resolved options.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from sensitivity controls distinctions?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing describing base sensitivity as lowercasing and stripping marks in every language be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library shelf with ordering titles while handling articles and punctuation policy. Include one ordinary case, one boundary and one deliberate failure caused by describing base sensitivity as lowercasing and stripping marks in every language. 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: Sensitivity can consider base letters, accents, case or both accent and case, subject to the resolved collation. It shows a trace, not only a final value. The ordinary case should demonstrate “The comparison can report collation equality even though the strings remain distinct values.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Test pairs relevant to the chosen locale and read resolved options. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For sensitivity controls distinctions, separate the documented JavaScript Intl.Collator mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 6 OF 20 . Use the core tools

6. Collation equality is not identity

Back to contents

A zero comparison means equivalent for that collation policy, not that the strings have identical code points or should share a database key. 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 deduplicating accounts or records solely because compare returned zero. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Keep stable identifiers and use the collator only for presentation or a carefully specified match policy.

For the Collation equality is not identity chapter on JavaScript Intl.Collator, 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 deduplicating accounts or records solely because compare returned zero. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

c.compare('resume','résumé')===0

Explained result. The boolean may be true under base sensitivity while strict string equality remains 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: CCA roster. Predict the rule using presenting participant names without changing stored identities. 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 zero comparison means equivalent for that collation policy, not that the strings have identical code points or should share a database key.” Apply this procedure: Keep stable identifiers and use the collator only for presentation or a carefully specified match policy. The expected mechanism is: The boolean may be true under base sensitivity while strict string equality remains false. For the CCA roster, add one near-miss that exposes deduplicating accounts or records solely because compare returned zero. 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 table. Contrast the rule using sorting labels with embedded numbers such as Sample 2 and Sample 10. 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 zero comparison means equivalent for that collation policy, not that the strings have identical code points or should share a database key.” Apply this procedure: Keep stable identifiers and use the collator only for presentation or a carefully specified match policy. The expected mechanism is: The boolean may be true under base sensitivity while strict string equality remains false. For the science table, add one near-miss that exposes deduplicating accounts or records solely because compare returned zero. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: revision files. Stress-test the rule using ordering chapter names by their visible numeric suffix. 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 zero comparison means equivalent for that collation policy, not that the strings have identical code points or should share a database key.” Apply this procedure: Keep stable identifiers and use the collator only for presentation or a carefully specified match policy. The expected mechanism is: The boolean may be true under base sensitivity while strict string equality remains false. For the revision files, add one near-miss that exposes deduplicating accounts or records solely because compare returned zero. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: family contacts. Explain the rule using grouping display names while retaining unique 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 “A zero comparison means equivalent for that collation policy, not that the strings have identical code points or should share a database key.” Apply this procedure: Keep stable identifiers and use the collator only for presentation or a carefully specified match policy. The expected mechanism is: The boolean may be true under base sensitivity while strict string equality remains false. For the family contacts, add one near-miss that exposes deduplicating accounts or records solely because compare returned zero. 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 deduplicating accounts or records solely because compare returned zero.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Keep stable identifiers and use the collator only for presentation or a carefully specified match policy.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from Collation equality is not identity?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing deduplicating accounts or records solely because compare returned zero be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA roster with presenting participant names without changing stored identities. Include one ordinary case, one boundary and one deliberate failure caused by deduplicating accounts or records solely because compare returned zero. 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 zero comparison means equivalent for that collation policy, not that the strings have identical code points or should share a database key. It shows a trace, not only a final value. The ordinary case should demonstrate “The boolean may be true under base sensitivity while strict string equality remains false.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Keep stable identifiers and use the collator only for presentation or a carefully specified match policy. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Collation equality is not identity, separate the documented JavaScript Intl.Collator mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 7 OF 20 . Use the core tools

7. numeric orders digit sequences naturally

Back to contents

With numeric true, digit sequences can be compared by numeric value so visible labels such as 2 and 10 sort naturally. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is parsing the whole label as a number or assuming every numeric script behaves identically. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test the exact label grammar and compare numeric false with true.

For the numeric orders digit sequences naturally chapter on JavaScript Intl.Collator, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on parsing the whole label as a number or assuming every numeric script behaves identically. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

['Lesson 10','Lesson 2'].sort(new Intl.Collator('en',{numeric:true}).compare)

Explained result. Lesson 2 comes before Lesson 10 under the numeric collation. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: revision files. Contrast the rule using ordering chapter names by their visible numeric suffix. 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 “With numeric true, digit sequences can be compared by numeric value so visible labels such as 2 and 10 sort naturally.” Apply this procedure: Test the exact label grammar and compare numeric false with true. The expected mechanism is: Lesson 2 comes before Lesson 10 under the numeric collation. For the revision files, add one near-miss that exposes parsing the whole label as a number or assuming every numeric script behaves identically. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: family contacts. Stress-test the rule using grouping display names while retaining unique 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 “With numeric true, digit sequences can be compared by numeric value so visible labels such as 2 and 10 sort naturally.” Apply this procedure: Test the exact label grammar and compare numeric false with true. The expected mechanism is: Lesson 2 comes before Lesson 10 under the numeric collation. For the family contacts, add one near-miss that exposes parsing the whole label as a number or assuming every numeric script behaves identically. 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: transport list. Explain the rule using ordering station display names for a locale-aware menu. 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 “With numeric true, digit sequences can be compared by numeric value so visible labels such as 2 and 10 sort naturally.” Apply this procedure: Test the exact label grammar and compare numeric false with true. The expected mechanism is: Lesson 2 comes before Lesson 10 under the numeric collation. For the transport list, add one near-miss that exposes parsing the whole label as a number or assuming every numeric script behaves identically. 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: project search. Transfer the rule using comparing query labels with a deliberate sensitivity policy. 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 “With numeric true, digit sequences can be compared by numeric value so visible labels such as 2 and 10 sort naturally.” Apply this procedure: Test the exact label grammar and compare numeric false with true. The expected mechanism is: Lesson 2 comes before Lesson 10 under the numeric collation. For the project search, add one near-miss that exposes parsing the whole label as a number or assuming every numeric script behaves identically. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers parsing the whole label as a number or assuming every numeric script behaves identically.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Test the exact label grammar and compare numeric false with true.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from numeric orders digit sequences naturally?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing parsing the whole label as a number or assuming every numeric script behaves identically be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science table with sorting labels with embedded numbers such as Sample 2 and Sample 10. Include one ordinary case, one boundary and one deliberate failure caused by parsing the whole label as a number or assuming every numeric script behaves identically. 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: With numeric true, digit sequences can be compared by numeric value so visible labels such as 2 and 10 sort naturally. It shows a trace, not only a final value. The ordinary case should demonstrate “Lesson 2 comes before Lesson 10 under the numeric collation.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Test the exact label grammar and compare numeric false with true. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For numeric orders digit sequences naturally, separate the documented JavaScript Intl.Collator mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 8 OF 20 . Use the core tools

8. numeric is not arithmetic

Back to contents

Numeric collation helps ordering textual digit runs; it does not validate quantities, units, signs, decimals or scientific notation as numbers. 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 Collator instead of parsing structured numeric data. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Parse genuine quantities with a domain grammar and reserve collation for labels.

For the numeric is not arithmetic chapter on JavaScript Intl.Collator, 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 Collator instead of parsing structured numeric data. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

['1.2','1.10'].sort(c.compare)

Explained result. The outcome is a string-collation result and must not be treated as decimal arithmetic. 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: transport list. Stress-test the rule using ordering station display names for a locale-aware menu. 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 “Numeric collation helps ordering textual digit runs; it does not validate quantities, units, signs, decimals or scientific notation as numbers.” Apply this procedure: Parse genuine quantities with a domain grammar and reserve collation for labels. The expected mechanism is: The outcome is a string-collation result and must not be treated as decimal arithmetic. For the transport list, add one near-miss that exposes using Collator instead of parsing structured numeric data. 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: project search. Explain the rule using comparing query labels with a deliberate sensitivity policy. 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 “Numeric collation helps ordering textual digit runs; it does not validate quantities, units, signs, decimals or scientific notation as numbers.” Apply this procedure: Parse genuine quantities with a domain grammar and reserve collation for labels. The expected mechanism is: The outcome is a string-collation result and must not be treated as decimal arithmetic. For the project search, add one near-miss that exposes using Collator instead of parsing structured numeric data. 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: homework titles. Transfer the rule using sorting multilingual assignment names for a dashboard. 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 “Numeric collation helps ordering textual digit runs; it does not validate quantities, units, signs, decimals or scientific notation as numbers.” Apply this procedure: Parse genuine quantities with a domain grammar and reserve collation for labels. The expected mechanism is: The outcome is a string-collation result and must not be treated as decimal arithmetic. For the homework titles, add one near-miss that exposes using Collator instead of parsing structured numeric data. 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: library shelf. Predict the rule using ordering titles while handling articles and punctuation policy. 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 “Numeric collation helps ordering textual digit runs; it does not validate quantities, units, signs, decimals or scientific notation as numbers.” Apply this procedure: Parse genuine quantities with a domain grammar and reserve collation for labels. The expected mechanism is: The outcome is a string-collation result and must not be treated as decimal arithmetic. For the library shelf, add one near-miss that exposes using Collator instead of parsing structured numeric data. 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 Collator instead of parsing structured numeric data.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Parse genuine quantities with a domain grammar and reserve collation for labels.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from numeric is not arithmetic?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using Collator instead of parsing structured numeric data be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny revision files with ordering chapter names by their visible numeric suffix. Include one ordinary case, one boundary and one deliberate failure caused by using Collator instead of parsing structured numeric data. 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: Numeric collation helps ordering textual digit runs; it does not validate quantities, units, signs, decimals or scientific notation as numbers. It shows a trace, not only a final value. The ordinary case should demonstrate “The outcome is a string-collation result and must not be treated as decimal arithmetic.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Parse genuine quantities with a domain grammar and reserve collation for labels. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For numeric is not arithmetic, separate the documented JavaScript Intl.Collator 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 9 OF 20 . Handle boundaries

9. caseFirst is a tie preference

Back to contents

caseFirst can request upper-first, lower-first or false, but its effect depends on locale and other sensitivity rules. 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 promising uppercase-first without checking the resolved option and meaningful distinctions. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Inspect resolvedOptions and test a tied base-letter pair.

For the caseFirst is a tie preference chapter on JavaScript Intl.Collator, 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 promising uppercase-first without checking the resolved option and meaningful distinctions. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

new Intl.Collator('en',{caseFirst:'upper'}).resolvedOptions().caseFirst

Explained result. The runtime reports the effective case-first policy that the comparator uses. 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: homework titles. Explain the rule using sorting multilingual assignment names for a dashboard. 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 “caseFirst can request upper-first, lower-first or false, but its effect depends on locale and other sensitivity rules.” Apply this procedure: Inspect resolvedOptions and test a tied base-letter pair. The expected mechanism is: The runtime reports the effective case-first policy that the comparator uses. For the homework titles, add one near-miss that exposes promising uppercase-first without checking the resolved option and meaningful distinctions. 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: library shelf. Transfer the rule using ordering titles while handling articles and punctuation policy. 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 “caseFirst can request upper-first, lower-first or false, but its effect depends on locale and other sensitivity rules.” Apply this procedure: Inspect resolvedOptions and test a tied base-letter pair. The expected mechanism is: The runtime reports the effective case-first policy that the comparator uses. For the library shelf, add one near-miss that exposes promising uppercase-first without checking the resolved option and meaningful distinctions. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: CCA roster. Predict the rule using presenting participant names without changing stored identities. 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 “caseFirst can request upper-first, lower-first or false, but its effect depends on locale and other sensitivity rules.” Apply this procedure: Inspect resolvedOptions and test a tied base-letter pair. The expected mechanism is: The runtime reports the effective case-first policy that the comparator uses. For the CCA roster, add one near-miss that exposes promising uppercase-first without checking the resolved option and meaningful distinctions. 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 table. Contrast the rule using sorting labels with embedded numbers such as Sample 2 and Sample 10. 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 “caseFirst can request upper-first, lower-first or false, but its effect depends on locale and other sensitivity rules.” Apply this procedure: Inspect resolvedOptions and test a tied base-letter pair. The expected mechanism is: The runtime reports the effective case-first policy that the comparator uses. For the science table, add one near-miss that exposes promising uppercase-first without checking the resolved option and meaningful distinctions. 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 promising uppercase-first without checking the resolved option and meaningful distinctions.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Inspect resolvedOptions and test a tied base-letter pair.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from caseFirst is a tie preference?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing promising uppercase-first without checking the resolved option and meaningful distinctions be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family contacts with grouping display names while retaining unique identifiers. Include one ordinary case, one boundary and one deliberate failure caused by promising uppercase-first without checking the resolved option and meaningful distinctions. 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: caseFirst can request upper-first, lower-first or false, but its effect depends on locale and other sensitivity rules. It shows a trace, not only a final value. The ordinary case should demonstrate “The runtime reports the effective case-first policy that the comparator uses.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Inspect resolvedOptions and test a tied base-letter pair. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For caseFirst is a tie preference, separate the documented JavaScript Intl.Collator 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 10 OF 20 . Handle boundaries

10. ignorePunctuation changes the comparison surface

Back to contents

ignorePunctuation asks the collation to disregard punctuation according to its rules, which can alter order or equality. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is removing punctuation from stored data to imitate a display sort. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Preserve original strings and apply the option only in the comparator.

For the ignorePunctuation changes the comparison surface chapter on JavaScript Intl.Collator, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on removing punctuation from stored data to imitate a display sort. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

new Intl.Collator('en',{ignorePunctuation:true}).compare('a-b','ab')

Explained result. The pair may compare as equivalent for ordering while the source labels remain unchanged. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: CCA roster. Transfer the rule using presenting participant names without changing stored identities. 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 “ignorePunctuation asks the collation to disregard punctuation according to its rules, which can alter order or equality.” Apply this procedure: Preserve original strings and apply the option only in the comparator. The expected mechanism is: The pair may compare as equivalent for ordering while the source labels remain unchanged. For the CCA roster, add one near-miss that exposes removing punctuation from stored data to imitate a display sort. 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 table. Predict the rule using sorting labels with embedded numbers such as Sample 2 and Sample 10. 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 “ignorePunctuation asks the collation to disregard punctuation according to its rules, which can alter order or equality.” Apply this procedure: Preserve original strings and apply the option only in the comparator. The expected mechanism is: The pair may compare as equivalent for ordering while the source labels remain unchanged. For the science table, add one near-miss that exposes removing punctuation from stored data to imitate a display sort. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: revision files. Contrast the rule using ordering chapter names by their visible numeric suffix. 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 “ignorePunctuation asks the collation to disregard punctuation according to its rules, which can alter order or equality.” Apply this procedure: Preserve original strings and apply the option only in the comparator. The expected mechanism is: The pair may compare as equivalent for ordering while the source labels remain unchanged. For the revision files, add one near-miss that exposes removing punctuation from stored data to imitate a display sort. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: family contacts. Stress-test the rule using grouping display names while retaining unique 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 “ignorePunctuation asks the collation to disregard punctuation according to its rules, which can alter order or equality.” Apply this procedure: Preserve original strings and apply the option only in the comparator. The expected mechanism is: The pair may compare as equivalent for ordering while the source labels remain unchanged. For the family contacts, add one near-miss that exposes removing punctuation from stored data to imitate a display sort. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers removing punctuation from stored data to imitate a display sort.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Preserve original strings and apply the option only in the comparator.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from ignorePunctuation changes the comparison surface?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing removing punctuation from stored data to imitate a display sort be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny transport list with ordering station display names for a locale-aware menu. Include one ordinary case, one boundary and one deliberate failure caused by removing punctuation from stored data to imitate a display sort. 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: ignorePunctuation asks the collation to disregard punctuation according to its rules, which can alter order or equality. It shows a trace, not only a final value. The ordinary case should demonstrate “The pair may compare as equivalent for ordering while the source labels remain unchanged.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Preserve original strings and apply the option only in the comparator. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For ignorePunctuation changes the comparison surface, separate the documented JavaScript Intl.Collator mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 11 OF 20 . Handle boundaries

11. collation selects a named ordering when supported

Back to contents

The collation option or Unicode extension can request a supported collation type, and resolvedOptions reveals what was accepted. 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 a collation name or assuming every runtime supports the same set. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use supportedValuesOf when available and verify the resolved collation.

For the collation selects a named ordering when supported chapter on JavaScript Intl.Collator, 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 a collation name or assuming every runtime supports the same set. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

Intl.supportedValuesOf('collation').slice(0,5)

Explained result. The returned values are implementation-supported collation identifiers, not popularity rankings. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: revision files. Predict the rule using ordering chapter names by their visible numeric suffix. 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 collation option or Unicode extension can request a supported collation type, and resolvedOptions reveals what was accepted.” Apply this procedure: Use supportedValuesOf when available and verify the resolved collation. The expected mechanism is: The returned values are implementation-supported collation identifiers, not popularity rankings. For the revision files, add one near-miss that exposes inventing a collation name or assuming every runtime supports the same set. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: family contacts. Contrast the rule using grouping display names while retaining unique 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 collation option or Unicode extension can request a supported collation type, and resolvedOptions reveals what was accepted.” Apply this procedure: Use supportedValuesOf when available and verify the resolved collation. The expected mechanism is: The returned values are implementation-supported collation identifiers, not popularity rankings. For the family contacts, add one near-miss that exposes inventing a collation name or assuming every runtime supports the same set. 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: transport list. Stress-test the rule using ordering station display names for a locale-aware menu. 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 collation option or Unicode extension can request a supported collation type, and resolvedOptions reveals what was accepted.” Apply this procedure: Use supportedValuesOf when available and verify the resolved collation. The expected mechanism is: The returned values are implementation-supported collation identifiers, not popularity rankings. For the transport list, add one near-miss that exposes inventing a collation name or assuming every runtime supports the same set. 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: project search. Explain the rule using comparing query labels with a deliberate sensitivity policy. 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 collation option or Unicode extension can request a supported collation type, and resolvedOptions reveals what was accepted.” Apply this procedure: Use supportedValuesOf when available and verify the resolved collation. The expected mechanism is: The returned values are implementation-supported collation identifiers, not popularity rankings. For the project search, add one near-miss that exposes inventing a collation name or assuming every runtime supports the same set. 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 a collation name or assuming every runtime supports the same set.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Use supportedValuesOf when available and verify the resolved collation.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from collation selects a named ordering when supported?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing inventing a collation name or assuming every runtime supports the same set be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny project search with comparing query labels with a deliberate sensitivity policy. Include one ordinary case, one boundary and one deliberate failure caused by inventing a collation name or assuming every runtime supports the same set. 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 collation option or Unicode extension can request a supported collation type, and resolvedOptions reveals what was accepted. It shows a trace, not only a final value. The ordinary case should demonstrate “The returned values are implementation-supported collation identifiers, not popularity rankings.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Use supportedValuesOf when available and verify the resolved collation. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For collation selects a named ordering when supported, separate the documented JavaScript Intl.Collator 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. compare is a bound callable

Back to contents

The compare accessor yields a function bound to its collator, so it can be passed directly to Array sorting. 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 wrapping compare incorrectly and reversing its arguments by accident. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test one known pair before using the function across a collection.

For the compare is a bound callable chapter on JavaScript Intl.Collator, 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 wrapping compare incorrectly and reversing its arguments by accident. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const cmp=new Intl.Collator('en').compare; ['z','a'].sort(cmp)

Explained result. The extracted callable still uses the originating collator and orders a before z. 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: transport list. Contrast the rule using ordering station display names for a locale-aware menu. 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 compare accessor yields a function bound to its collator, so it can be passed directly to Array sorting.” Apply this procedure: Test one known pair before using the function across a collection. The expected mechanism is: The extracted callable still uses the originating collator and orders a before z. For the transport list, add one near-miss that exposes wrapping compare incorrectly and reversing its arguments by accident. 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: project search. Stress-test the rule using comparing query labels with a deliberate sensitivity policy. 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 compare accessor yields a function bound to its collator, so it can be passed directly to Array sorting.” Apply this procedure: Test one known pair before using the function across a collection. The expected mechanism is: The extracted callable still uses the originating collator and orders a before z. For the project search, add one near-miss that exposes wrapping compare incorrectly and reversing its arguments by accident. 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: homework titles. Explain the rule using sorting multilingual assignment names for a dashboard. 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 compare accessor yields a function bound to its collator, so it can be passed directly to Array sorting.” Apply this procedure: Test one known pair before using the function across a collection. The expected mechanism is: The extracted callable still uses the originating collator and orders a before z. For the homework titles, add one near-miss that exposes wrapping compare incorrectly and reversing its arguments by accident. 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: library shelf. Transfer the rule using ordering titles while handling articles and punctuation policy. 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 compare accessor yields a function bound to its collator, so it can be passed directly to Array sorting.” Apply this procedure: Test one known pair before using the function across a collection. The expected mechanism is: The extracted callable still uses the originating collator and orders a before z. For the library shelf, add one near-miss that exposes wrapping compare incorrectly and reversing its arguments by accident. 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 wrapping compare incorrectly and reversing its arguments by accident.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Test one known pair before using the function across a collection.” and record the first changed observation.
Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Intl.Collator syntax. For this chapter, useful prompts are: “What did you expect from compare is a bound callable?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing wrapping compare incorrectly and reversing its arguments by accident be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework titles with sorting multilingual assignment names for a dashboard. Include one ordinary case, one boundary and one deliberate failure caused by wrapping compare incorrectly and reversing its arguments by accident. 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 compare accessor yields a function bound to its collator, so it can be passed directly to Array sorting. It shows a trace, not only a final value. The ordinary case should demonstrate “The extracted callable still uses the originating collator and orders a before z.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Test one known pair before using the function across a collection. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For compare is a bound callable, separate the documented JavaScript Intl.Collator 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 13 OF 20 . Debug and verify

13. Sorting mutates unless a copying method is chosen

Back to contents

Array.prototype.sort rearranges the original array, while toSorted creates a new array with the comparator. 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 blaming the collator when a source list changes because sort mutated it. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Decide ownership first and test original and result references.

For the Sorting mutates unless a copying method is chosen chapter on JavaScript Intl.Collator, 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 blaming the collator when a source list changes because sort mutated it. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const ordered=names.toSorted(c.compare)

Explained result. ordered is a new array and names retains its original sequence. 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: homework titles. Stress-test the rule using sorting multilingual assignment names for a dashboard. 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 “Array.prototype.sort rearranges the original array, while toSorted creates a new array with the comparator.” Apply this procedure: Decide ownership first and test original and result references. The expected mechanism is: ordered is a new array and names retains its original sequence. For the homework titles, add one near-miss that exposes blaming the collator when a source list changes because sort mutated it. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: library shelf. Explain the rule using ordering titles while handling articles and punctuation policy. 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 “Array.prototype.sort rearranges the original array, while toSorted creates a new array with the comparator.” Apply this procedure: Decide ownership first and test original and result references. The expected mechanism is: ordered is a new array and names retains its original sequence. For the library shelf, add one near-miss that exposes blaming the collator when a source list changes because sort mutated it. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: CCA roster. Transfer the rule using presenting participant names without changing stored identities. 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 “Array.prototype.sort rearranges the original array, while toSorted creates a new array with the comparator.” Apply this procedure: Decide ownership first and test original and result references. The expected mechanism is: ordered is a new array and names retains its original sequence. For the CCA roster, add one near-miss that exposes blaming the collator when a source list changes because sort mutated it. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: science table. Predict the rule using sorting labels with embedded numbers such as Sample 2 and Sample 10. 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 “Array.prototype.sort rearranges the original array, while toSorted creates a new array with the comparator.” Apply this procedure: Decide ownership first and test original and result references. The expected mechanism is: ordered is a new array and names retains its original sequence. For the science table, add one near-miss that exposes blaming the collator when a source list changes because sort mutated it. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers blaming the collator when a source list changes because sort mutated it.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Decide ownership first and test original and result references.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from Sorting mutates unless a copying method is chosen?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing blaming the collator when a source list changes because sort mutated it be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library shelf with ordering titles while handling articles and punctuation policy. Include one ordinary case, one boundary and one deliberate failure caused by blaming the collator when a source list changes because sort mutated it. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: Array.prototype.sort rearranges the original array, while toSorted creates a new array with the comparator. It shows a trace, not only a final value. The ordinary case should demonstrate “ordered is a new array and names retains its original sequence.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Decide ownership first and test original and result references. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Sorting mutates unless a copying method is chosen, separate the documented JavaScript Intl.Collator mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 14 OF 20 . Debug and verify

14. Stable sort preserves comparator ties

Back to contents

Modern ECMAScript sorting is stable, so elements that compare as zero retain their prior relative 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 adding an accidental fallback key that destroys an intentional earlier grouping. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Pre-sort by the secondary policy or supply an explicit comparator chain.

For the Stable sort preserves comparator ties chapter on JavaScript Intl.Collator, 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 an accidental fallback key that destroys an intentional earlier grouping. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

rows.toSorted((a,b)=>c.compare(a.label,b.label))

Explained result. Rows tied by the collator keep their earlier relative sequence. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: CCA roster. Explain the rule using presenting participant names without changing stored identities. 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 “Modern ECMAScript sorting is stable, so elements that compare as zero retain their prior relative order.” Apply this procedure: Pre-sort by the secondary policy or supply an explicit comparator chain. The expected mechanism is: Rows tied by the collator keep their earlier relative sequence. For the CCA roster, add one near-miss that exposes adding an accidental fallback key that destroys an intentional earlier grouping. 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 table. Transfer the rule using sorting labels with embedded numbers such as Sample 2 and Sample 10. 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 “Modern ECMAScript sorting is stable, so elements that compare as zero retain their prior relative order.” Apply this procedure: Pre-sort by the secondary policy or supply an explicit comparator chain. The expected mechanism is: Rows tied by the collator keep their earlier relative sequence. For the science table, add one near-miss that exposes adding an accidental fallback key that destroys an intentional earlier grouping. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: revision files. Predict the rule using ordering chapter names by their visible numeric suffix. 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 “Modern ECMAScript sorting is stable, so elements that compare as zero retain their prior relative order.” Apply this procedure: Pre-sort by the secondary policy or supply an explicit comparator chain. The expected mechanism is: Rows tied by the collator keep their earlier relative sequence. For the revision files, add one near-miss that exposes adding an accidental fallback key that destroys an intentional earlier grouping. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: family contacts. Contrast the rule using grouping display names while retaining unique 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 “Modern ECMAScript sorting is stable, so elements that compare as zero retain their prior relative order.” Apply this procedure: Pre-sort by the secondary policy or supply an explicit comparator chain. The expected mechanism is: Rows tied by the collator keep their earlier relative sequence. For the family contacts, add one near-miss that exposes adding an accidental fallback key that destroys an intentional earlier grouping. 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 an accidental fallback key that destroys an intentional earlier grouping.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Pre-sort by the secondary policy or supply an explicit comparator chain.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from Stable sort preserves comparator ties?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing adding an accidental fallback key that destroys an intentional earlier grouping be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA roster with presenting participant names without changing stored identities. Include one ordinary case, one boundary and one deliberate failure caused by adding an accidental fallback key that destroys an intentional earlier grouping. 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: Modern ECMAScript sorting is stable, so elements that compare as zero retain their prior relative order. It shows a trace, not only a final value. The ordinary case should demonstrate “Rows tied by the collator keep their earlier relative sequence.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Pre-sort by the secondary policy or supply an explicit comparator chain. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Stable sort preserves comparator ties, separate the documented JavaScript Intl.Collator 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 15 OF 20 . Debug and verify

15. Comparator chains need a final identity policy

Back to contents

A display sort may compare name, then class and finally a stable identifier to produce deterministic output without confusing equivalence with identity. 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 subtraction or raw less-than as an undocumented fallback on mixed fields. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Write each comparison step and return only after a non-zero sign.

For the Comparator chains need a final identity policy chapter on JavaScript Intl.Collator, 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 subtraction or raw less-than as an undocumented fallback on mixed fields. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

c.compare(a.name,b.name) || a.id.localeCompare(b.id)

Explained result. The name policy runs first and the identifier breaks only remaining ties. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: revision files. Transfer the rule using ordering chapter names by their visible numeric suffix. 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 display sort may compare name, then class and finally a stable identifier to produce deterministic output without confusing equivalence with identity.” Apply this procedure: Write each comparison step and return only after a non-zero sign. The expected mechanism is: The name policy runs first and the identifier breaks only remaining ties. For the revision files, add one near-miss that exposes using subtraction or raw less-than as an undocumented fallback on mixed fields. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: family contacts. Predict the rule using grouping display names while retaining unique 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 “A display sort may compare name, then class and finally a stable identifier to produce deterministic output without confusing equivalence with identity.” Apply this procedure: Write each comparison step and return only after a non-zero sign. The expected mechanism is: The name policy runs first and the identifier breaks only remaining ties. For the family contacts, add one near-miss that exposes using subtraction or raw less-than as an undocumented fallback on mixed fields. 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: transport list. Contrast the rule using ordering station display names for a locale-aware menu. 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 display sort may compare name, then class and finally a stable identifier to produce deterministic output without confusing equivalence with identity.” Apply this procedure: Write each comparison step and return only after a non-zero sign. The expected mechanism is: The name policy runs first and the identifier breaks only remaining ties. For the transport list, add one near-miss that exposes using subtraction or raw less-than as an undocumented fallback on mixed fields. 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: project search. Stress-test the rule using comparing query labels with a deliberate sensitivity policy. 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 display sort may compare name, then class and finally a stable identifier to produce deterministic output without confusing equivalence with identity.” Apply this procedure: Write each comparison step and return only after a non-zero sign. The expected mechanism is: The name policy runs first and the identifier breaks only remaining ties. For the project search, add one near-miss that exposes using subtraction or raw less-than as an undocumented fallback on mixed fields. 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 subtraction or raw less-than as an undocumented fallback on mixed fields.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Write each comparison step and return only after a non-zero sign.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from Comparator chains need a final identity policy?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using subtraction or raw less-than as an undocumented fallback on mixed fields be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science table with sorting labels with embedded numbers such as Sample 2 and Sample 10. Include one ordinary case, one boundary and one deliberate failure caused by using subtraction or raw less-than as an undocumented fallback on mixed fields. 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 display sort may compare name, then class and finally a stable identifier to produce deterministic output without confusing equivalence with identity. It shows a trace, not only a final value. The ordinary case should demonstrate “The name policy runs first and the identifier breaks only remaining ties.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Write each comparison step and return only after a non-zero sign. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Comparator chains need a final identity policy, separate the documented JavaScript Intl.Collator mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 16 OF 20 . Debug and verify

16. Unicode normalization is a separate choice

Back to contents

Canonically equivalent sequences may be handled by collation, but applications should not assume collation rewrites or normalizes stored strings. 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 saving compare-equal text as though the original encoding had been canonicalised. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Inspect code points and choose an explicit normalization boundary if storage requires one.

For the Unicode normalization is a separate choice chapter on JavaScript Intl.Collator, 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 saving compare-equal text as though the original encoding had been canonicalised. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

Array.from(text).map(ch=>ch.codePointAt(0).toString(16))

Explained result. The diagnostic exposes representation while the collator remains an ordering tool. 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: transport list. Predict the rule using ordering station display names for a locale-aware menu. 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 “Canonically equivalent sequences may be handled by collation, but applications should not assume collation rewrites or normalizes stored strings.” Apply this procedure: Inspect code points and choose an explicit normalization boundary if storage requires one. The expected mechanism is: The diagnostic exposes representation while the collator remains an ordering tool. For the transport list, add one near-miss that exposes saving compare-equal text as though the original encoding had been canonicalised. 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: project search. Contrast the rule using comparing query labels with a deliberate sensitivity policy. 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 “Canonically equivalent sequences may be handled by collation, but applications should not assume collation rewrites or normalizes stored strings.” Apply this procedure: Inspect code points and choose an explicit normalization boundary if storage requires one. The expected mechanism is: The diagnostic exposes representation while the collator remains an ordering tool. For the project search, add one near-miss that exposes saving compare-equal text as though the original encoding had been canonicalised. 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: homework titles. Stress-test the rule using sorting multilingual assignment names for a dashboard. 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 “Canonically equivalent sequences may be handled by collation, but applications should not assume collation rewrites or normalizes stored strings.” Apply this procedure: Inspect code points and choose an explicit normalization boundary if storage requires one. The expected mechanism is: The diagnostic exposes representation while the collator remains an ordering tool. For the homework titles, add one near-miss that exposes saving compare-equal text as though the original encoding had been canonicalised. 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: library shelf. Explain the rule using ordering titles while handling articles and punctuation policy. 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 “Canonically equivalent sequences may be handled by collation, but applications should not assume collation rewrites or normalizes stored strings.” Apply this procedure: Inspect code points and choose an explicit normalization boundary if storage requires one. The expected mechanism is: The diagnostic exposes representation while the collator remains an ordering tool. For the library shelf, add one near-miss that exposes saving compare-equal text as though the original encoding had been canonicalised. 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 saving compare-equal text as though the original encoding had been canonicalised.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Inspect code points and choose an explicit normalization boundary if storage requires one.” and record the first changed observation.
Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Intl.Collator syntax. For this chapter, useful prompts are: “What did you expect from Unicode normalization is a separate choice?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing saving compare-equal text as though the original encoding had been canonicalised be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny revision files with ordering chapter names by their visible numeric suffix. Include one ordinary case, one boundary and one deliberate failure caused by saving compare-equal text as though the original encoding had been canonicalised. 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: Canonically equivalent sequences may be handled by collation, but applications should not assume collation rewrites or normalizes stored strings. It shows a trace, not only a final value. The ordinary case should demonstrate “The diagnostic exposes representation while the collator remains an ordering tool.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Inspect code points and choose an explicit normalization boundary if storage requires one. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Unicode normalization is a separate choice, separate the documented JavaScript Intl.Collator mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

CHAPTER 17 OF 20 . Transfer with judgment

17. Cache by policy, not by guess

Back to contents

Repeated construction can be avoided by reusing a collator for the same locale and options, while a policy change needs a distinct instance. 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 creating one global comparator for every language and reader job. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Key a cache with canonical locale and deliberate option fields.

For the Cache by policy, not by guess chapter on JavaScript Intl.Collator, 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 creating one global comparator for every language and reader job. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const key=JSON.stringify(['en-SG',{numeric:true}])

Explained result. The cache key makes the comparison policy visible instead of silently sharing incompatible choices. 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: homework titles. Contrast the rule using sorting multilingual assignment names for a dashboard. 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 “Repeated construction can be avoided by reusing a collator for the same locale and options, while a policy change needs a distinct instance.” Apply this procedure: Key a cache with canonical locale and deliberate option fields. The expected mechanism is: The cache key makes the comparison policy visible instead of silently sharing incompatible choices. For the homework titles, add one near-miss that exposes creating one global comparator for every language and reader job. 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: library shelf. Stress-test the rule using ordering titles while handling articles and punctuation policy. 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 “Repeated construction can be avoided by reusing a collator for the same locale and options, while a policy change needs a distinct instance.” Apply this procedure: Key a cache with canonical locale and deliberate option fields. The expected mechanism is: The cache key makes the comparison policy visible instead of silently sharing incompatible choices. For the library shelf, add one near-miss that exposes creating one global comparator for every language and reader job. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: CCA roster. Explain the rule using presenting participant names without changing stored identities. 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 “Repeated construction can be avoided by reusing a collator for the same locale and options, while a policy change needs a distinct instance.” Apply this procedure: Key a cache with canonical locale and deliberate option fields. The expected mechanism is: The cache key makes the comparison policy visible instead of silently sharing incompatible choices. For the CCA roster, add one near-miss that exposes creating one global comparator for every language and reader job. 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 table. Transfer the rule using sorting labels with embedded numbers such as Sample 2 and Sample 10. 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 “Repeated construction can be avoided by reusing a collator for the same locale and options, while a policy change needs a distinct instance.” Apply this procedure: Key a cache with canonical locale and deliberate option fields. The expected mechanism is: The cache key makes the comparison policy visible instead of silently sharing incompatible choices. For the science table, add one near-miss that exposes creating one global comparator for every language and reader job. 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 creating one global comparator for every language and reader job.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Key a cache with canonical locale and deliberate option fields.” and record the first changed observation.
Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Intl.Collator syntax. For this chapter, useful prompts are: “What did you expect from Cache by policy, not by guess?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing creating one global comparator for every language and reader job be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family contacts with grouping display names while retaining unique identifiers. Include one ordinary case, one boundary and one deliberate failure caused by creating one global comparator for every language and reader job. 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: Repeated construction can be avoided by reusing a collator for the same locale and options, while a policy change needs a distinct instance. It shows a trace, not only a final value. The ordinary case should demonstrate “The cache key makes the comparison policy visible instead of silently sharing incompatible choices.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Key a cache with canonical locale and deliberate option fields. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Cache by policy, not by guess, separate the documented JavaScript Intl.Collator 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. Test culturally relevant fixtures

Back to contents

ASCII-only tests cannot validate a locale-aware design; fixtures should include accents, case, punctuation, digit runs and scripts relevant to users. 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 declaring internationalisation correct after sorting a through z. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Record expected relations from product policy and verify them on supported runtimes.

For the Test culturally relevant fixtures chapter on JavaScript Intl.Collator, 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 declaring internationalisation correct after sorting a through z. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

pairs.forEach(([a,b,sign])=>console.assert(Math.sign(c.compare(a,b))===sign))

Explained result. The suite tests ordering relationships rather than brittle implementation magnitudes. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: CCA roster. Stress-test the rule using presenting participant names without changing stored identities. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “ASCII-only tests cannot validate a locale-aware design; fixtures should include accents, case, punctuation, digit runs and scripts relevant to users.” Apply this procedure: Record expected relations from product policy and verify them on supported runtimes. The expected mechanism is: The suite tests ordering relationships rather than brittle implementation magnitudes. For the CCA roster, add one near-miss that exposes declaring internationalisation correct after sorting a through z. 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 table. Explain the rule using sorting labels with embedded numbers such as Sample 2 and Sample 10. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “ASCII-only tests cannot validate a locale-aware design; fixtures should include accents, case, punctuation, digit runs and scripts relevant to users.” Apply this procedure: Record expected relations from product policy and verify them on supported runtimes. The expected mechanism is: The suite tests ordering relationships rather than brittle implementation magnitudes. For the science table, add one near-miss that exposes declaring internationalisation correct after sorting a through z. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 3: revision files. Transfer the rule using ordering chapter names by their visible numeric suffix. State the input grain or object graph, the chapter boundary and the intended output before choosing syntax. Change only one variable, so a wrong prediction has a single plausible cause.

Reasoned route. Begin with “ASCII-only tests cannot validate a locale-aware design; fixtures should include accents, case, punctuation, digit runs and scripts relevant to users.” Apply this procedure: Record expected relations from product policy and verify them on supported runtimes. The expected mechanism is: The suite tests ordering relationships rather than brittle implementation magnitudes. For the revision files, add one near-miss that exposes declaring internationalisation correct after sorting a through z. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 4: family contacts. Predict the rule using grouping display names while retaining unique 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 “ASCII-only tests cannot validate a locale-aware design; fixtures should include accents, case, punctuation, digit runs and scripts relevant to users.” Apply this procedure: Record expected relations from product policy and verify them on supported runtimes. The expected mechanism is: The suite tests ordering relationships rather than brittle implementation magnitudes. For the family contacts, add one near-miss that exposes declaring internationalisation correct after sorting a through z. 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 declaring internationalisation correct after sorting a through z.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Record expected relations from product policy and verify them on supported runtimes.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from Test culturally relevant fixtures?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing declaring internationalisation correct after sorting a through z be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny transport list with ordering station display names for a locale-aware menu. Include one ordinary case, one boundary and one deliberate failure caused by declaring internationalisation correct after sorting a through z. Predict each result before using a tool, then report the first point where observation differs from prediction.

Answer guide. A strong response starts with the rule: ASCII-only tests cannot validate a locale-aware design; fixtures should include accents, case, punctuation, digit runs and scripts relevant to users. It shows a trace, not only a final value. The ordinary case should demonstrate “The suite tests ordering relationships rather than brittle implementation magnitudes.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Record expected relations from product policy and verify them on supported runtimes. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Test culturally relevant fixtures, separate the documented JavaScript Intl.Collator 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. Do not infer language or personhood from order

Back to contents

Collation provides an ordering mechanism; it does not determine a person’s preferred language, name format or cultural identity. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is using a locale guess to rewrite names or make eligibility decisions. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Let users and product policy select presentation preferences and preserve source data.

For the Do not infer language or personhood from order chapter on JavaScript Intl.Collator, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on using a locale guess to rewrite names or make eligibility decisions. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const displayOrder=records.toSorted((a,b)=>c.compare(a.displayName,b.displayName))

Explained result. Only the displayed sequence changes; identities and original names remain intact. Check the boundary as well as the happy path: ask what happens with an empty input, a duplicate or tied value, an unsupported type, a missing path, a NULL, or a second reference to the same object. Only the relevant boundary should be kept; the list is a prompt for judgment, not a demand to force every case into every example.

Four purposeful transfer cases

Case 1: revision files. Explain the rule using ordering chapter names by their visible numeric suffix. 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 provides an ordering mechanism; it does not determine a person’s preferred language, name format or cultural identity.” Apply this procedure: Let users and product policy select presentation preferences and preserve source data. The expected mechanism is: Only the displayed sequence changes; identities and original names remain intact. For the revision files, add one near-miss that exposes using a locale guess to rewrite names or make eligibility decisions. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Case 2: family contacts. Transfer the rule using grouping display names while retaining unique 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 provides an ordering mechanism; it does not determine a person’s preferred language, name format or cultural identity.” Apply this procedure: Let users and product policy select presentation preferences and preserve source data. The expected mechanism is: Only the displayed sequence changes; identities and original names remain intact. For the family contacts, add one near-miss that exposes using a locale guess to rewrite names or make eligibility decisions. 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: transport list. Predict the rule using ordering station display names for a locale-aware menu. 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 provides an ordering mechanism; it does not determine a person’s preferred language, name format or cultural identity.” Apply this procedure: Let users and product policy select presentation preferences and preserve source data. The expected mechanism is: Only the displayed sequence changes; identities and original names remain intact. For the transport list, add one near-miss that exposes using a locale guess to rewrite names or make eligibility decisions. 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: project search. Contrast the rule using comparing query labels with a deliberate sensitivity policy. 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 provides an ordering mechanism; it does not determine a person’s preferred language, name format or cultural identity.” Apply this procedure: Let users and product policy select presentation preferences and preserve source data. The expected mechanism is: Only the displayed sequence changes; identities and original names remain intact. For the project search, add one near-miss that exposes using a locale guess to rewrite names or make eligibility decisions. The answer is complete only when it says why the near-miss fails and how the corrected model transfers to a different project without relying on the original variable names.

Diagnostic route

Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
Boundary check: create the smallest input that triggers using a locale guess to rewrite names or make eligibility decisions.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Let users and product policy select presentation preferences and preserve source 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from Do not infer language or personhood from order?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using a locale guess to rewrite names or make eligibility decisions be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny project search with comparing query labels with a deliberate sensitivity policy. Include one ordinary case, one boundary and one deliberate failure caused by using a locale guess to rewrite names or make eligibility decisions. 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 provides an ordering mechanism; it does not determine a person’s preferred language, name format or cultural identity. It shows a trace, not only a final value. The ordinary case should demonstrate “Only the displayed sequence changes; identities and original names remain intact.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Let users and product policy select presentation preferences and preserve source data. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Do not infer language or personhood from order, separate the documented JavaScript Intl.Collator 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. Choose Collator for a declared reader job

Back to contents

Use it when human-facing string comparison needs a locale-sensitive policy that is tested, inspectable and separate from storage identity. 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 Intl.Collator to machine identifiers, security checks or arithmetic data without justification. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Write the locale, usage, options, tie policy and non-goals before implementation.

For the Choose Collator for a declared reader job chapter on JavaScript Intl.Collator, 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 Intl.Collator to machine identifiers, security checks or arithmetic data without justification. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

policy={locale:'en-SG',usage:'sort',numeric:true}

Explained result. A written policy makes the comparator explainable and prevents it from becoming a hidden source of identity 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: transport list. Transfer the rule using ordering station display names for a locale-aware menu. 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 “Use it when human-facing string comparison needs a locale-sensitive policy that is tested, inspectable and separate from storage identity.” Apply this procedure: Write the locale, usage, options, tie policy and non-goals before implementation. The expected mechanism is: A written policy makes the comparator explainable and prevents it from becoming a hidden source of identity decisions. For the transport list, add one near-miss that exposes adding Intl.Collator to machine identifiers, security checks or arithmetic data without justification. 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: project search. Predict the rule using comparing query labels with a deliberate sensitivity policy. 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 “Use it when human-facing string comparison needs a locale-sensitive policy that is tested, inspectable and separate from storage identity.” Apply this procedure: Write the locale, usage, options, tie policy and non-goals before implementation. The expected mechanism is: A written policy makes the comparator explainable and prevents it from becoming a hidden source of identity decisions. For the project search, add one near-miss that exposes adding Intl.Collator to machine identifiers, security checks or arithmetic data without justification. 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: homework titles. Contrast the rule using sorting multilingual assignment names for a dashboard. 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 “Use it when human-facing string comparison needs a locale-sensitive policy that is tested, inspectable and separate from storage identity.” Apply this procedure: Write the locale, usage, options, tie policy and non-goals before implementation. The expected mechanism is: A written policy makes the comparator explainable and prevents it from becoming a hidden source of identity decisions. For the homework titles, add one near-miss that exposes adding Intl.Collator to machine identifiers, security checks or arithmetic data without justification. 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: library shelf. Stress-test the rule using ordering titles while handling articles and punctuation policy. 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 “Use it when human-facing string comparison needs a locale-sensitive policy that is tested, inspectable and separate from storage identity.” Apply this procedure: Write the locale, usage, options, tie policy and non-goals before implementation. The expected mechanism is: A written policy makes the comparator explainable and prevents it from becoming a hidden source of identity decisions. For the library shelf, add one near-miss that exposes adding Intl.Collator to machine identifiers, security checks or arithmetic data without justification. 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 Intl.Collator to machine identifiers, security checks or arithmetic data without justification.
Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
Repair check: use the reversible procedure “Write the locale, usage, options, tie policy and non-goals before implementation.” 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.Collator syntax. For this chapter, useful prompts are: “What did you expect from Choose Collator for a declared reader job?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing adding Intl.Collator to machine identifiers, security checks or arithmetic data without justification be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework titles with sorting multilingual assignment names for a dashboard. Include one ordinary case, one boundary and one deliberate failure caused by adding Intl.Collator to machine identifiers, security checks or arithmetic data without justification. 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: Use it when human-facing string comparison needs a locale-sensitive policy that is tested, inspectable and separate from storage identity. It shows a trace, not only a final value. The ordinary case should demonstrate “A written policy makes the comparator explainable and prevents it from becoming a hidden source of identity decisions.” The boundary must exercise the same mechanism at an edge, and the deliberate failure must be repaired with: Write the locale, usage, options, tie policy and non-goals before implementation. Other data choices are valid when the evidence supports the same causal chain.

Decision and transfer

For Choose Collator for a declared reader job, separate the documented JavaScript Intl.Collator 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. homework titles: model, boundary and recovery

Create a small homework titles using sorting multilingual assignment names for a dashboard. Combine “Collator produces a comparator” 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: new Intl.Collator creates an object whose compare function can be passed to sorting operations. Apply: Construct one collator at the policy boundary and reuse its compare function. Verify: The array is ordered using the collator rather than raw code-unit comparison. 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. library shelf: model, boundary and recovery

Create a small library shelf using ordering titles while handling articles and punctuation policy. Combine “usage distinguishes sort and search” 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 usage option states whether the collator supports ordering or matching; search collation is not a general ordering contract. Apply: Use sort for ordering and treat search results as match decisions. Verify: The object is configured for search comparison, not for a user-visible total order. Then add a second chapter whose boundary could change the outcome. A complete solution contains the input model, a trace, observed evidence, a correction and one transfer statement. The exact data may differ; the causal chain must be checkable.

3. CCA roster: model, boundary and recovery

Create a small CCA roster using presenting participant names without changing stored identities. Combine “numeric orders digit sequences naturally” 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: With numeric true, digit sequences can be compared by numeric value so visible labels such as 2 and 10 sort naturally. Apply: Test the exact label grammar and compare numeric false with true. Verify: Lesson 2 comes before Lesson 10 under the numeric collation. 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 table: model, boundary and recovery

Create a small science table using sorting labels with embedded numbers such as Sample 2 and Sample 10. Combine “ignorePunctuation changes the comparison surface” 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: ignorePunctuation asks the collation to disregard punctuation according to its rules, which can alter order or equality. Apply: Preserve original strings and apply the option only in the comparator. Verify: The pair may compare as equivalent for ordering while the source labels remain unchanged. 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. revision files: model, boundary and recovery

Create a small revision files using ordering chapter names by their visible numeric suffix. Combine “Sorting mutates unless a copying method is chosen” 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: Array.prototype.sort rearranges the original array, while toSorted creates a new array with the comparator. Apply: Decide ownership first and test original and result references. Verify: ordered is a new array and names retains its original sequence. 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. family contacts: model, boundary and recovery

Create a small family contacts using grouping display names while retaining unique identifiers. Combine “Unicode normalization is a separate choice” 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: Canonically equivalent sequences may be handled by collation, but applications should not assume collation rewrites or normalizes stored strings. Apply: Inspect code points and choose an explicit normalization boundary if storage requires one. Verify: The diagnostic exposes representation while the collator remains an ordering tool. 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. transport list: model, boundary and recovery

Create a small transport list using ordering station display names for a locale-aware menu. Combine “Do not infer language or personhood from order” 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: Collation provides an ordering mechanism; it does not determine a person’s preferred language, name format or cultural identity. Apply: Let users and product policy select presentation preferences and preserve source data. Verify: Only the displayed sequence changes; identities and original names remain intact. 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. project search: model, boundary and recovery

Create a small project search using comparing query labels with a deliberate sensitivity policy. Combine “Only the sign is portable” 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: compare returns a negative, zero or positive number; programs should not depend on a result being exactly minus one or one. Apply: Assert less than zero, equal to zero or greater than zero. Verify: The sign communicates order; the engine may choose any negative magnitude. 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.

Official and supporting references

Return to contents

eduKate Punggol

Build the model

Use the core tools

Handle boundaries

Debug and verify

Transfer with judgment

eduKate Punggol

Contact

Menu

Email Us

感谢您的回复。 ✨

Small Group Tutorials

How to Master JavaScript Intl.Collator in Punggol Tuition

Find your next learning step

Build the model

Use the core tools

Handle boundaries

Debug and verify

Transfer with judgment

Complete chapter index

1. Collator produces a comparator

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

2. Only the sign is portable

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

3. Locale negotiation resolves a supported request

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

4. usage distinguishes sort and search

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

5. sensitivity controls distinctions

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

6. Collation equality is not identity

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

7. numeric orders digit sequences naturally

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

8. numeric is not arithmetic

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

9. caseFirst is a tie preference

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

10. ignorePunctuation changes the comparison surface

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

11. collation selects a named ordering when supported

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer

Decision and transfer

12. compare is a bound callable

Core worked example

Four purposeful transfer cases

Diagnostic route

Practice with an explained answer