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.DurationFormat turns a structured duration record into locale-aware text or parts. It does not measure elapsed time, subtract dates or decide how months convert to days. Mastery means separating duration arithmetic from presentation, predicting which fields display under each option, and testing both the chosen locale contract and the runtime that will execute it. 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.

Intl.DurationFormat receives duration fields and formats them; it does not compute the fields from timestamps. 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 passing two dates and expecting subtraction or calendar arithmetic. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Calculate or obtain a duration record first, then give that record to the formatter.

For the Duration formatting is presentation chapter on JavaScript Intl.DurationFormat, 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 passing two dates and expecting subtraction or calendar arithmetic. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const df=new Intl.DurationFormat('en',{style:'long'});
df.format({hours:1,minutes:30});

Four purposeful transfer cases

Case 1: homework timer. Predict the rule using hours, minutes and seconds spent on focused work. 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.

Case 2: library visit. Contrast the rule using minutes for travel, browsing and borrowing. 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.

Case 3: CCA rehearsal. Stress-test the rule using hours and minutes in a practice block. 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.

Case 4: science observation. Explain the rule using seconds, milliseconds and instrument resolution. 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.

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 passing two dates and expecting subtraction or calendar arithmetic.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Calculate or obtain a duration record first, then give that record to the formatter.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from Duration formatting is presentation?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing passing two dates and expecting subtraction or calendar arithmetic be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family journey with hours and minutes across route segments. Include one ordinary case, one boundary and one deliberate failure caused by passing two dates and expecting subtraction or calendar arithmetic. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

The specification requires Intl.DurationFormat to be constructed; calling it without new throws TypeError. 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 copying call patterns from Intl.NumberFormat without checking this constructor contract. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use new and make the construction step visible in examples and factories.

For the Construct with new chapter on JavaScript Intl.DurationFormat, 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 copying call patterns from Intl.NumberFormat without checking this constructor contract. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const df=new Intl.DurationFormat('en-SG');

Four purposeful transfer cases

Case 1: CCA rehearsal. Contrast the rule using hours and minutes in a practice block. 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.

Case 2: science observation. Stress-test the rule using seconds, milliseconds and instrument resolution. 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.

Case 3: revision plan. Explain the rule using days, hours and short study intervals. 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.

Case 4: family journey. Transfer the rule using hours and minutes across route segments. 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.

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 copying call patterns from Intl.NumberFormat without checking this constructor contract.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Use new and make the construction step visible in examples and factories.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from Construct with new?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing copying call patterns from Intl.NumberFormat without checking this constructor contract be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny coding benchmark with milliseconds, microseconds and display precision. Include one ordinary case, one boundary and one deliberate failure caused by copying call patterns from Intl.NumberFormat without checking this constructor contract. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

The input object can contain years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds and nanoseconds. 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 passing a number of seconds directly and expecting the API to infer its unit. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Use an object whose property name states each unit explicitly.

For the Duration input is a record chapter on JavaScript Intl.DurationFormat, 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 passing a number of seconds directly and expecting the API to infer its unit. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

df.format({minutes:12,seconds:5});

Four purposeful transfer cases

Case 1: revision plan. Stress-test the rule using days, hours and short study intervals. 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.

Case 2: family journey. Explain the rule using hours and minutes across route segments. 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.

Case 3: coding benchmark. Transfer the rule using milliseconds, microseconds and display precision. 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.

Case 4: project countdown. Predict the rule using weeks, days and hours remaining. 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.

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 passing a number of seconds directly and expecting the API to infer its unit.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Use an object whose property name states each unit explicitly.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from Duration input is a record?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing passing a number of seconds directly and expecting the API to infer its unit be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny project countdown with weeks, days and hours remaining. Include one ordinary case, one boundary and one deliberate failure caused by passing a number of seconds directly and expecting the API to infer its unit. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

An object with none of the recognised duration properties is rejected instead of formatting as an empty duration. 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 passing an unrelated object and interpreting the error as a locale problem. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Validate the record shape before formatting and include an explicit zero field when zero is meaningful.

For the At least one field is required chapter on JavaScript Intl.DurationFormat, 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 passing an unrelated object and interpreting the error as a locale problem. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

df.format({seconds:0});

Four purposeful transfer cases

Case 1: coding benchmark. Explain the rule using milliseconds, microseconds and display precision. 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.

Case 2: project countdown. Transfer the rule using weeks, days and hours remaining. 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.

Case 3: homework timer. Predict the rule using hours, minutes and seconds spent on focused work. 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.

Case 4: library visit. Contrast the rule using minutes for travel, browsing and borrowing. 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.

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 passing an unrelated object and interpreting the error as a locale problem.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Validate the record shape before formatting and include an explicit zero field when zero is meaningful.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from At least one field is required?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing passing an unrelated object and interpreting the error as a locale problem be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework timer with hours, minutes and seconds spent on focused work. Include one ordinary case, one boundary and one deliberate failure caused by passing an unrelated object and interpreting the error as a locale problem. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

Each supplied duration field is converted to a Number and must be an integral value; non-integral values cause RangeError. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is putting 1.5 in seconds instead of expressing fractional precision with smaller units. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Convert the amount into integer seconds and subsecond units before formatting.

For the Field values must be integral chapter on JavaScript Intl.DurationFormat, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on putting 1.5 in seconds instead of expressing fractional precision with smaller units. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

df.format({seconds:1,milliseconds:500});

Four purposeful transfer cases

Case 1: homework timer. Transfer the rule using hours, minutes and seconds spent on focused work. 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.

Case 2: library visit. Predict the rule using minutes for travel, browsing and borrowing. 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.

Case 3: CCA rehearsal. Contrast the rule using hours and minutes in a practice block. 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.

Case 4: science observation. Stress-test the rule using seconds, milliseconds and instrument resolution. 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.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers putting 1.5 in seconds instead of expressing fractional precision with smaller units.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Convert the amount into integer seconds and subsecond units before formatting.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from Field values must be integral?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing putting 1.5 in seconds instead of expressing fractional precision with smaller units be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library visit with minutes for travel, browsing and borrowing. Include one ordinary case, one boundary and one deliberate failure caused by putting 1.5 in seconds instead of expressing fractional precision with smaller units. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

A valid duration cannot mix positive and negative nonzero components because that would not be one consistently directed duration. 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 hours:1 and minutes:-30 to mean subtraction inside the formatter. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Normalise arithmetic before presentation so the resulting record has one sign.

For the All nonzero fields share one sign chapter on JavaScript Intl.DurationFormat, 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 hours:1 and minutes:-30 to mean subtraction inside the formatter. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

df.format({hours:-1,minutes:-30});

Four purposeful transfer cases

Case 1: CCA rehearsal. Predict the rule using hours and minutes in a practice block. 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.

Case 2: science observation. Contrast the rule using seconds, milliseconds and instrument resolution. 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.

Case 3: revision plan. Stress-test the rule using days, hours and short study intervals. 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.

Case 4: family journey. Explain the rule using hours and minutes across route segments. 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.

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 hours:1 and minutes:-30 to mean subtraction inside the formatter.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Normalise arithmetic before presentation so the resulting record has one 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from All nonzero fields share one sign?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using hours:1 and minutes:-30 to mean subtraction inside the formatter be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA rehearsal with hours and minutes in a practice block. Include one ordinary case, one boundary and one deliberate failure caused by using hours:1 and minutes:-30 to mean subtraction inside the formatter. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

The locales argument requests language and regional conventions, while the runtime resolves an available locale. 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 hard-coding English punctuation around a supposedly localised result. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Compare supportedLocalesOf and resolvedOptions before making output assertions.

For the Locale negotiation changes language chapter on JavaScript Intl.DurationFormat, 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 hard-coding English punctuation around a supposedly localised result. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

new Intl.DurationFormat('fr',{style:'long'}).format({hours:2})

Four purposeful transfer cases

Case 1: revision plan. Contrast the rule using days, hours and short study intervals. 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.

Case 2: family journey. Stress-test the rule using hours and minutes across route segments. 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.

Case 3: coding benchmark. Explain the rule using milliseconds, microseconds and display precision. 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.

Case 4: project countdown. Transfer the rule using weeks, days and hours remaining. 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.

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 hard-coding English punctuation around a supposedly localised result.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Compare supportedLocalesOf and resolvedOptions before making output assertions.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from Locale negotiation changes language?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing hard-coding English punctuation around a supposedly localised result be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science observation with seconds, milliseconds and instrument resolution. Include one ordinary case, one boundary and one deliberate failure caused by hard-coding English punctuation around a supposedly localised result. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Locale negotiation changes language, separate the documented JavaScript Intl.DurationFormat 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

When style is omitted, the constructor uses short duration formatting as the overall style. 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 long words because an example happened to specify style long. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Inspect resolvedOptions and set style explicitly when product copy depends on it.

For the The default style is short chapter on JavaScript Intl.DurationFormat, 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 long words because an example happened to specify style long. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

new Intl.DurationFormat('en').resolvedOptions().style

Four purposeful transfer cases

Case 1: coding benchmark. Stress-test the rule using milliseconds, microseconds and display precision. 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.

Case 2: project countdown. Explain the rule using weeks, days and hours remaining. 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.

Case 3: homework timer. Transfer the rule using hours, minutes and seconds spent on focused work. 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.

Case 4: library visit. Predict the rule using minutes for travel, browsing and borrowing. 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.

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 long words because an example happened to specify style long.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Inspect resolvedOptions and set style explicitly when product copy depends on it.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from The default style is short?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming long words because an example happened to specify style long be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny revision plan with days, hours and short study intervals. Include one ordinary case, one boundary and one deliberate failure caused by assuming long words because an example happened to specify style long. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

The three textual styles request different degrees of unit-name abbreviation while remaining locale-sensitive. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is treating narrow as a guaranteed fixed ASCII token format. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test representative locales and never parse the formatted string as data.

For the Long, short and narrow are semantic choices chapter on JavaScript Intl.DurationFormat, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on treating narrow as a guaranteed fixed ASCII token format. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

for(const style of ['long','short','narrow']) console.log(new Intl.DurationFormat('en',{style}).format({hours:2,minutes:5}));

Four purposeful transfer cases

Case 1: homework timer. Explain the rule using hours, minutes and seconds spent on focused work. 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.

Case 2: library visit. Transfer the rule using minutes for travel, browsing and borrowing. 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.

Case 3: CCA rehearsal. Predict the rule using hours and minutes in a practice block. 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.

Case 4: science observation. Contrast the rule using seconds, milliseconds and instrument resolution. 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.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers treating narrow as a guaranteed fixed ASCII token format.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Test representative locales and never parse the formatted string as 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from Long, short and narrow are semantic choices?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing treating narrow as a guaranteed fixed ASCII token format be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family journey with hours and minutes across route segments. Include one ordinary case, one boundary and one deliberate failure caused by treating narrow as a guaranteed fixed ASCII token format. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Long, short and narrow are semantic choices, separate the documented JavaScript Intl.DurationFormat 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

Digital style uses locale data for hour-minute and minute-second separators and coordinated numeric field defaults. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is building a colon string manually and calling it locale-aware. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Let the formatter choose separators and two-digit behavior, then test exact target locales.

For the Digital is a coordinated style chapter on JavaScript Intl.DurationFormat, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on building a colon string manually and calling it locale-aware. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

new Intl.DurationFormat('en',{style:'digital'}).format({hours:1,minutes:2,seconds:3})

Four purposeful transfer cases

Case 1: CCA rehearsal. Transfer the rule using hours and minutes in a practice block. 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.

Case 2: science observation. Predict the rule using seconds, milliseconds and instrument resolution. 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.

Case 3: revision plan. Contrast the rule using days, hours and short study intervals. 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.

Case 4: family journey. Stress-test the rule using hours and minutes across route segments. 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.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers building a colon string manually and calling it locale-aware.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Let the formatter choose separators and two-digit behavior, then test exact target locales.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from Digital is a coordinated style?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing building a colon string manually and calling it locale-aware be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny coding benchmark with milliseconds, microseconds and display precision. Include one ordinary case, one boundary and one deliberate failure caused by building a colon string manually and calling it locale-aware. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Digital is a coordinated style, separate the documented JavaScript Intl.DurationFormat 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

Per-unit display options decide whether a unit appears always or automatically under the applicable 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 assuming every property supplied with zero must be printed. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Set the unit display policy explicitly and verify zero-only and mixed records.

For the Unit display controls zero fields chapter on JavaScript Intl.DurationFormat, use a two-column trace during a short Punggol home session. On the left, write the predicted state for this exact mechanism before the tool runs. On the right, record the observation that bears on assuming every property supplied with zero must be printed. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

new Intl.DurationFormat('en',{seconds:'long',secondsDisplay:'always'}).format({seconds:0})

Four purposeful transfer cases

Case 1: revision plan. Predict the rule using days, hours and short study intervals. 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.

Case 2: family journey. Contrast the rule using hours and minutes across route segments. 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.

Case 3: coding benchmark. Stress-test the rule using milliseconds, microseconds and display precision. 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.

Case 4: project countdown. Explain the rule using weeks, days and hours remaining. 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.

Diagnostic route

• Model check: ask the learner to draw or list the exact rows, fields, references, paths or states involved.
• Boundary check: create the smallest input that triggers assuming every property supplied with zero must be printed.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Set the unit display policy explicitly and verify zero-only and mixed records.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from Unit display controls zero fields?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming every property supplied with zero must be printed be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny project countdown with weeks, days and hours remaining. Include one ordinary case, one boundary and one deliberate failure caused by assuming every property supplied with zero must be printed. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Unit display controls zero fields, separate the documented JavaScript Intl.DurationFormat 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

Unit options such as hours, minutes or seconds can select allowed textual or numeric styles within the constructor 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 combining arbitrary unit styles without checking the option dependencies. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Read resolvedOptions and reduce the case when an option combination throws.

For the Per-unit styles can refine the result chapter on JavaScript Intl.DurationFormat, 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 combining arbitrary unit styles without checking the option dependencies. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

new Intl.DurationFormat('en',{hours:'numeric',minutes:'2-digit'}).resolvedOptions()

Four purposeful transfer cases

Case 1: coding benchmark. Contrast the rule using milliseconds, microseconds and display precision. 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.

Case 2: project countdown. Stress-test the rule using weeks, days and hours remaining. 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.

Case 3: homework timer. Explain the rule using hours, minutes and seconds spent on focused work. 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.

Case 4: library visit. Transfer the rule using minutes for travel, browsing and borrowing. 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.

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 combining arbitrary unit styles without checking the option dependencies.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Read resolvedOptions and reduce the case when an option combination throws.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from Per-unit styles can refine the result?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing combining arbitrary unit styles without checking the option dependencies be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework timer with hours, minutes and seconds spent on focused work. Include one ordinary case, one boundary and one deliberate failure caused by combining arbitrary unit styles without checking the option dependencies. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Per-unit styles can refine the result, separate the documented JavaScript Intl.DurationFormat mechanism from the project policy. State exactly what the technical contract guarantees, then state the project choice about validation, ordering, ownership, performance or recovery. Test whether the same distinction survives one transfer case, and keep stateful experiments disposable and backed up.

Previous chapter . Contents . Next chapter

The fractionalDigits option accepts an integer from zero through nine and controls numeric subsecond precision. 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 value outside the range or expecting it to accept arbitrary precision. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test minimum, maximum and one invalid value during configuration validation.

For the fractionalDigits ranges from zero to nine chapter on JavaScript Intl.DurationFormat, 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 value outside the range or expecting it to accept arbitrary precision. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

new Intl.DurationFormat('en',{style:'digital',fractionalDigits:3}).format({seconds:1,milliseconds:234})

Four purposeful transfer cases

Case 1: homework timer. Stress-test the rule using hours, minutes and seconds spent on focused work. 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.

Case 2: library visit. Explain the rule using minutes for travel, browsing and borrowing. 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.

Case 3: CCA rehearsal. Transfer the rule using hours and minutes in a practice block. 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.

Case 4: science observation. Predict the rule using seconds, milliseconds and instrument resolution. 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.

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 value outside the range or expecting it to accept arbitrary precision.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Test minimum, maximum and one invalid value during configuration validation.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from fractionalDigits ranges from zero to nine?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using a value outside the range or expecting it to accept arbitrary precision be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny library visit with minutes for travel, browsing and borrowing. Include one ordinary case, one boundary and one deliberate failure caused by using a value outside the range or expecting it to accept arbitrary precision. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For fractionalDigits ranges from zero to nine, separate the documented JavaScript Intl.DurationFormat 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

Milliseconds, microseconds and nanoseconds are distinct integer fields rather than a single decimal string. 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 placing a decimal string in seconds and losing the structured-unit contract. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Convert measured data to explicit integer fields and keep the original measurement policy separate.

For the Subsecond fields have exact units chapter on JavaScript Intl.DurationFormat, 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 placing a decimal string in seconds and losing the structured-unit contract. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

df.format({milliseconds:12,microseconds:345,nanoseconds:678})

Four purposeful transfer cases

Case 1: CCA rehearsal. Explain the rule using hours and minutes in a practice block. 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.

Case 2: science observation. Transfer the rule using seconds, milliseconds and instrument resolution. 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.

Case 3: revision plan. Predict the rule using days, hours and short study intervals. 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.

Case 4: family journey. Contrast the rule using hours and minutes across route segments. 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.

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 placing a decimal string in seconds and losing the structured-unit contract.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Convert measured data to explicit integer fields and keep the original measurement policy separate.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Intl.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from Subsecond fields have exact units?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing placing a decimal string in seconds and losing the structured-unit contract be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny CCA rehearsal with hours and minutes in a practice block. Include one ordinary case, one boundary and one deliberate failure caused by placing a decimal string in seconds and losing the structured-unit contract. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Subsecond fields have exact units, separate the documented JavaScript Intl.DurationFormat 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

format concatenates locale-sensitive parts into a human-facing string whose punctuation and spacing are not a storage format. 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 splitting the result on spaces or colons to recover values. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Keep the original record as data and use the string only for display.

For the format returns an opaque display string chapter on JavaScript Intl.DurationFormat, 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 splitting the result on spaces or colons to recover values. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const label=df.format({minutes:9,seconds:4});

Four purposeful transfer cases

Case 1: revision plan. Transfer the rule using days, hours and short study intervals. 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.

Case 2: family journey. Predict the rule using hours and minutes across route segments. 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.

Case 3: coding benchmark. Contrast the rule using milliseconds, microseconds and display precision. 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.

Case 4: project countdown. Stress-test the rule using weeks, days and hours remaining. 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.

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 splitting the result on spaces or colons to recover values.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Keep the original record as data and use the string only for display.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from format returns an opaque display string?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing splitting the result on spaces or colons to recover values be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny science observation with seconds, milliseconds and instrument resolution. Include one ordinary case, one boundary and one deliberate failure caused by splitting the result on spaces or colons to recover values. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For format returns an opaque display string, separate the documented JavaScript Intl.DurationFormat 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

formatToParts returns objects with type and value, and duration-related parts can also carry a unit. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is using a regular expression to find numbers in a localised string. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Inspect part types and units, then assemble accessible markup without changing order.

For the formatToParts exposes typed pieces chapter on JavaScript Intl.DurationFormat, 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 regular expression to find numbers in a localised string. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

df.formatToParts({hours:1,minutes:2})

Four purposeful transfer cases

Case 1: coding benchmark. Predict the rule using milliseconds, microseconds and display precision. 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.

Case 2: project countdown. Contrast the rule using weeks, days and hours remaining. 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.

Case 3: homework timer. Stress-test the rule using hours, minutes and seconds spent on focused work. 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.

Case 4: library visit. Explain the rule using minutes for travel, browsing and borrowing. 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.

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 regular expression to find numbers in a localised string.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Inspect part types and units, then assemble accessible markup without changing order.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Intl.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from formatToParts exposes typed pieces?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using a regular expression to find numbers in a localised string be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny revision plan with days, hours and short study intervals. Include one ordinary case, one boundary and one deliberate failure caused by using a regular expression to find numbers in a localised string. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For formatToParts exposes typed pieces, separate the documented JavaScript Intl.DurationFormat 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

resolvedOptions reports the resolved locale, numbering system, style and relevant unit settings used by the 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 assuming the requested locale or every supplied option survived unchanged. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Log the receipt in tests and assert only the product contract that truly matters.

For the resolvedOptions is the configuration receipt chapter on JavaScript Intl.DurationFormat, 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 requested locale or every supplied option survived unchanged. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const options=df.resolvedOptions(); console.log(options.locale,options.style);

Four purposeful transfer cases

Case 1: homework timer. Contrast the rule using hours, minutes and seconds spent on focused work. 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.

Case 2: library visit. Stress-test the rule using minutes for travel, browsing and borrowing. 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.

Case 3: CCA rehearsal. Explain the rule using hours and minutes in a practice block. 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.

Case 4: science observation. Transfer the rule using seconds, milliseconds and instrument resolution. 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.

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 requested locale or every supplied option survived unchanged.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Log the receipt in tests and assert only the product contract that truly matters.” and record the first changed observation.
• Transfer check: repeat the rule in a second context and identify what remains invariant.

A parent does not need to know the final JavaScript Intl.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from resolvedOptions is the configuration receipt?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing assuming the requested locale or every supplied option survived unchanged be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny family journey with hours and minutes across route segments. Include one ordinary case, one boundary and one deliberate failure caused by assuming the requested locale or every supplied option survived unchanged. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

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

Previous chapter . Contents . Next chapter

A deployment should check whether Intl.DurationFormat exists in the target runtime before relying on it. Treat that sentence as a testable model. A secure learner can point to the relevant input, name the operation, describe the resulting state and identify one observation that would prove the model incomplete.

The high-value mistake in this chapter is inferring universal support from one development machine. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Detect the constructor and choose a documented fallback without pretending the fallback is identical.

For the Feature detection belongs at the boundary chapter on JavaScript Intl.DurationFormat, 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 inferring universal support from one development machine. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const supported=typeof Intl.DurationFormat==='function';

Four purposeful transfer cases

Case 1: CCA rehearsal. Stress-test the rule using hours and minutes in a practice block. 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.

Case 2: science observation. Explain the rule using seconds, milliseconds and instrument resolution. 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.

Case 3: revision plan. Transfer the rule using days, hours and short study intervals. 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.

Case 4: family journey. Predict the rule using hours and minutes across route segments. 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.

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 inferring universal support from one development machine.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Detect the constructor and choose a documented fallback without pretending the fallback is identical.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from Feature detection belongs at the boundary?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing inferring universal support from one development machine be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny coding benchmark with milliseconds, microseconds and display precision. Include one ordinary case, one boundary and one deliberate failure caused by inferring universal support from one development machine. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Feature detection belongs at the boundary, separate the documented JavaScript Intl.DurationFormat 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

Exact strings can vary across locales and runtime data, so tests must fix the locale or assert meaningful parts. 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 snapshotting one machine’s punctuation as a universal standard. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. Test a fixed supported locale and use formatToParts for structural assertions when appropriate.

For the Tests should avoid accidental locale assumptions chapter on JavaScript Intl.DurationFormat, 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 snapshotting one machine’s punctuation as a universal standard. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const parts=new Intl.DurationFormat('en',{style:'long'}).formatToParts({hours:2});

Four purposeful transfer cases

Case 1: revision plan. Explain the rule using days, hours and short study intervals. 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.

Case 2: family journey. Transfer the rule using hours and minutes across route segments. 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.

Case 3: coding benchmark. Predict the rule using milliseconds, microseconds and display precision. 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.

Case 4: project countdown. Contrast the rule using weeks, days and hours remaining. 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.

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 snapshotting one machine’s punctuation as a universal standard.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “Test a fixed supported locale and use formatToParts for structural assertions when appropriate.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from Tests should avoid accidental locale assumptions?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing snapshotting one machine’s punctuation as a universal standard be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny project countdown with weeks, days and hours remaining. Include one ordinary case, one boundary and one deliberate failure caused by snapshotting one machine’s punctuation as a universal standard. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Tests should avoid accidental locale assumptions, separate the documented JavaScript Intl.DurationFormat 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

Use Intl.DurationFormat when the application already has a valid structured duration and needs localised presentation. 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 it as a date-difference engine, timer or duration parser. It matters because the output may look reasonable while the ownership, ordering, identity or safety rule is wrong. State the arithmetic owner, record normalisation rule, locale policy and fallback before construction.

For the Choose DurationFormat after arithmetic chapter on JavaScript Intl.DurationFormat, 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 it as a date-difference engine, timer or duration parser. Explain the earliest difference with one causal sentence, then repeat only the smallest changed case.

Core worked example

const record={hours:1,minutes:45}; const text=new Intl.DurationFormat('en-SG',{style:'long'}).format(record);

Four purposeful transfer cases

Case 1: coding benchmark. Transfer the rule using milliseconds, microseconds and display precision. 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.

Case 2: project countdown. Predict the rule using weeks, days and hours remaining. 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.

Case 3: homework timer. Contrast the rule using hours, minutes and seconds spent on focused work. 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.

Case 4: library visit. Stress-test the rule using minutes for travel, browsing and borrowing. 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.

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 it as a date-difference engine, timer or duration parser.
• Evidence check: separate a printed value from identity, ordering, ownership, type or repository state.
• Repair check: use the reversible procedure “State the arithmetic owner, record normalisation rule, locale policy and fallback before construction.” 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.DurationFormat syntax. For this chapter, useful prompts are: “What did you expect from Choose DurationFormat after arithmetic?”, “Which state changed first?”, “What evidence tests that prediction?”, and “Can the case exposing using it as a date-difference engine, timer or duration parser be made smaller?” The learner, not the parent, should supply the technical explanation.

Practice with an explained answer

Question. Build a tiny homework timer with hours, minutes and seconds spent on focused work. Include one ordinary case, one boundary and one deliberate failure caused by using it as a date-difference engine, timer or duration parser. Predict each result before using a tool, then report the first point where observation differs from prediction.

Decision and transfer

For Choose DurationFormat after arithmetic, separate the documented JavaScript Intl.DurationFormat 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

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.

1. homework timer: model, boundary and recovery

Create a small homework timer using hours, minutes and seconds spent on focused work. Combine “Duration formatting is presentation” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

2. library visit: model, boundary and recovery

Create a small library visit using minutes for travel, browsing and borrowing. Combine “At least one field is required” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

3. CCA rehearsal: model, boundary and recovery

Create a small CCA rehearsal using hours and minutes in a practice block. Combine “Locale negotiation changes language” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

4. science observation: model, boundary and recovery

Create a small science observation using seconds, milliseconds and instrument resolution. Combine “Digital is a coordinated style” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

5. revision plan: model, boundary and recovery

Create a small revision plan using days, hours and short study intervals. Combine “fractionalDigits ranges from zero to nine” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

6. family journey: model, boundary and recovery

Create a small family journey using hours and minutes across route segments. Combine “formatToParts exposes typed pieces” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

7. coding benchmark: model, boundary and recovery

Create a small coding benchmark using milliseconds, microseconds and display precision. Combine “Tests should avoid accidental locale assumptions” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

8. project countdown: model, boundary and recovery

Create a small project countdown using weeks, days and hours remaining. Combine “Construct with new” with one later chapter. Include an ordinary case, a boundary, a deliberate failure and a recovery. Write the expected state before each operation.

Frequently asked questions

How long should a practice session be?

Use one complete 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

• Primary technical documentation for JavaScript Intl.DurationFormat
• eduKatePunggol: How Studying Works

Return to contents