A New Collection of Thoughtful Learning Apps — Now Available on iOS & Android

Image
I’m excited to share a set of mobile apps I’ve recently completed and published on both the Google Play Store and the Apple App Store. These apps are designed with a simple goal in mind: to make meaningful, structured content more accessible, whether you’re studying theology or improving your English vocabulary. 📱 Now Available on Both Platforms All apps are live and available for download: Google Play Developer Page: https://play.google.com/store/apps/dev?id=5835943159853189043 Apple App Store Developer Page: https://apps.apple.com/ca/developer/q-z-l-corp/id1888794100 📖 Theology & Confession Study Apps For those interested in Reformed theology and classical Christian teachings, I’ve developed a series of apps that present foundational texts in a clean, focused reading format: The Belgic Confession Canons of Dort Heidelberg Catechism Westminster Shorter Catechism Each app is designed to provide a distraction-free experience, making it easier to read, reflect, and revisit these im...

JavaScript Temporal Is Ready for a Careful Migration—Not a Blind Date Rewrite

JavaScript Temporal Is Ready for a Careful Migration—Not a Blind Date Rewrite


JavaScript date handling is entering an important transition. The Temporal proposal is now a Stage 4 draft, Node.js 26 enables it by default, and current Chromium- and Firefox-based browsers support it. But Safari and iOS support still require care. The practical conclusion is not “replace every Date today.” It is: start using Temporal at well-defined boundaries, keep a compatibility plan, and stop making one object represent every kind of date and time.

Why Temporal is different

The legacy Date object mixes several concepts: an instant on the UTC timeline, local date-time components, and formatting for a user's time zone. That makes ordinary-looking code ambiguous. Is 2026-11-20 a calendar date, midnight in a particular zone, or a timestamp?

Temporal separates those concepts into purpose-specific immutable types:

  • Temporal.Instant represents one exact point on the timeline.
  • Temporal.ZonedDateTime represents an exact point together with a time zone and calendar view.
  • Temporal.PlainDate represents a calendar date with no time zone.
  • Temporal.PlainTime represents a wall-clock time with no date or time zone.
  • Temporal.Duration represents an amount such as “two hours” or “three months.”

This distinction prevents a common design error: attaching a time zone to a value that was never meant to identify an instant. A birthday, a billing due date, and a meeting are not the same kind of data.

Choose the type from the business meaning

Before changing code, classify the value you are storing or passing around:

Business valueTemporal typeTypical persistence
Audit event or message timestampInstantUTC timestamp such as 2026-11-20T14:30:00Z
Meeting at a named locationZonedDateTimeInstant plus an IANA zone such as America/Toronto
Birthday or due datePlainDateISO date such as 2026-11-20
Store opening timePlainTimeLocal clock time such as 09:00

The table is not merely an API reference. It is a data-modeling test. If the team cannot agree whether a value is an instant or a calendar date, adding a new library will not solve the underlying bug.

Start with explicit values

Here is a small example of the types working together:

const releaseDate = Temporal.PlainDate.from("2026-11-20"); const releaseMoment = Temporal.Instant.from("2026-11-20T14:30:00Z"); const TorontoMeeting = Temporal.ZonedDateTime.from({ year: 2026, month: 11, day: 20, hour: 9, minute: 30, timeZone: "America/Toronto" }); console.log(releaseDate.toString()); console.log(releaseMoment.toString()); console.log(TorontoMeeting.toString());

Use PlainDate for the first value because a release date is a calendar label. Use Instant for the second because the event happened at one exact moment. Use ZonedDateTime for the meeting because both the local clock reading and the named location matter.

Do not perform time-zone arithmetic with strings

Daylight-saving transitions are where date code usually becomes operationally expensive. Adding 24 elapsed hours is not always the same as moving a local appointment to the next day. Temporal makes the choice visible:

const appointment = Temporal.ZonedDateTime.from( "2026-03-08T01:30-05:00[America/New_York]" ); const oneElapsedHour = appointment.add({ hours: 1 }); const nextCalendarDay = appointment.add({ days: 1 }); console.log(oneElapsedHour.toString()); console.log(nextCalendarDay.toString());

The important point is not memorizing a daylight-saving result. It is choosing whether the rule is elapsed-time arithmetic or calendar arithmetic. A timeout, token lifetime, or retry window usually wants an Instant or elapsed duration. A recurring appointment usually wants a zone-aware calendar operation.

A safe migration strategy

1. Keep the boundary stable

Do not rewrite database schemas, API contracts, and every UI component in one pull request. Pick one boundary with a clear defect history: scheduling, recurring billing, reports around midnight, or an audit log. Convert the value at that boundary and document the invariant.

2. Convert at the edge

For a legacy timestamp, convert once when it enters the new part of the application:

function parseAuditTimestamp(value) { return Temporal.Instant.from(value); } function serializeAuditTimestamp(value) { return value.toString(); }

Keep the old representation at an integration boundary until the surrounding contract can change. This limits the blast radius and makes it possible to compare old and new results in tests.

3. Test the rule, not just a date

Include dates around daylight-saving transitions, month ends, leap years, invalid dates, and at least two time zones. Test that a birthday remains the same calendar date when viewed from different locations, while an audit instant renders differently for users in different zones. These tests are more valuable than a large collection of ordinary mid-month examples.

4. Make support an explicit deployment decision

As of November 2026, MDN lists full Temporal support in Chrome 144, Edge 144, Firefox 139, and corresponding Android browsers, but only preview support in Safari and no support in Safari on iOS. Since iOS browsers use WebKit, a public web application cannot assume that a Chromium-compatible feature test covers its mobile audience.

Feature-detect the global before using it:

if (typeof Temporal === "undefined") { // Load a supported polyfill or use the application's compatibility path. throw new Error("Temporal is not available in this runtime"); }

For applications that need broader coverage, the maintainers of @js-temporal/polyfill document an ESM and CommonJS package. The polyfill exports Temporal rather than silently installing a global, so code should import it deliberately and avoid accidentally mixing native and polyfilled objects across module boundaries.

Node.js 26 changes the server-side conversation

Node.js 26 enables Temporal by default. That makes it practical to introduce Temporal in a server or command-line service without waiting for a separate runtime flag. It does not mean every deployed process has the same capability: production fleets often contain older Node.js lines, build workers, test runners, and browser clients with different support levels.

Check the actual runtime matrix in CI and document the minimum version. If a package is shared between Node and browsers, keep the compatibility decision at the package boundary instead of assuming that the server's native implementation will be available in the browser.

What not to do

  • Do not turn every existing Date into ZonedDateTime. Most values do not need a time zone.
  • Do not store a local date-time without also deciding whether its zone is part of the meaning.
  • Do not compare formatted strings when you mean to compare instants or calendar dates.
  • Do not claim browser support from Node.js support. They are separate deployment targets.
  • Do not hide a polyfill behind an untested global mutation. Make the import and compatibility path visible.

The practical next step

Temporal is ready for production-oriented evaluation, but migration should follow the domain model rather than the excitement of a new API. Pick one date-related bug or ambiguous data field, name its intended meaning, introduce the narrowest Temporal type, and test it across time zones and boundary dates. That approach delivers the main benefit—fewer accidental interpretations—without turning a mature application into a risky date rewrite.

References

❤️ Support This Blog


If this post helped you, you can support my writing with a small donation. Thank you for reading.


Comments

Popular Posts

A New Collection of Thoughtful Learning Apps — Now Available on iOS & Android

react-native run-android : do not build/update modified code(App.js)