Inside ECMA TC39: How JavaScript Proposals Evolve from Idea to Standard

About ECMA TC39

https://github.com/tc39/agendas/blob/main/2024/12.md

ECMA TC39 (ECMA Technical Committee 39) is the technical committee of Ecma International responsible for defining and maintaining the ECMAScript standard, the language specification behind JavaScript.

TC39 was founded in 1996, originating from the development and standardisation of JavaScript.

The committee meets six times a year, roughly every two months, with each meeting lasting three to four days to discuss and advance JavaScript language proposals.

Members include browser vendors (Google, Microsoft, Mozilla), technology companies (Meta, Netflix), community projects (Babel, TypeScript), academic institutions, and occasionally external experts.

Main agenda items:

Discussion and voting on proposals (e.g., advancing to the next stage).

Revision of ECMAScript specification issues.

Feedback and progress on browser engines and toolchains.

Data analysis and community discussion of language feature usage.

Each change goes through multiple stages:

Stage 0: Strawman – initial idea presented for discussion.

Stage 1: Proposal – problem and solution are defined, entering formal proposal.

Stage 2: Draft – design stabilises, a draft specification is provided.

Stage 3: Candidate – specification is complete, implementation feedback is collected.

Stage 4: Finished – proposal is finalised and incorporated into the standard.

The whole process from Stage 0 to Stage 4 typically takes 1–3 years, but can be longer.

Stage 2.7 is not an official TC39 stage; it is an informal internal marker used to indicate intermediate draft versions (e.g., 2.0, 2.1, 2.7) before moving to Stage 3.

ECMA also runs other meetings such as ECMAScript Working Groups, the Annual ECMAScript Summit, and version release meetings.

105th TC39 Meeting

The 105th TC39 meeting presented the following updates:

Stage 4

Intl.DurationFormat

A locale‑sensitive API for formatting durations (e.g., "1 hour, 30 minutes").

<code>new Intl.DurationFormat("fr-FR", { style: "long" }).format({
  hours: 1,
  minutes: 46,
  seconds: 40,
});
// => "1 heure, 46 minutes et 40 secondes"
</code>

Stage 3

Error.isError

Adds a static isError method to check whether a value is an instance of Error .

<code>Error.isError(undefined); // false
Error.isError(new Error()); // true
</code>

Stage 2.7

ESM Phase Imports

Enhances the ECMAScript module system with new import capabilities to simplify dependency declarations.

<code>import source myModule from "./my-module.js";
// `{ type: 'module' }` can be inferred because myModule is a module object
const worker = new Worker(myModule);
</code>

P.S.: Note that this approval is conditional.

Stage 2

Immutable ArrayBuffer

Introduces an immutable ArrayBuffer concept to prevent modification of binary data after creation.

<code>Object.freeze(new Uint8Array(buf.transferToImmutable()));
</code>

Intl Currency Display Choices

Extends currency formatting options, allowing control over symbol and code styles.

<code>const formal = new Intl.NumberFormat("en-US", {
  style: "currency",
  currency: "USD",
  currencyDisplay: "formalSymbol",
});
formal.format(42); // "US$42.00"

const never = new Intl.NumberFormat("en-US", {
  style: "currency",
  currency: "USD",
  currencyDisplay: "never",
});
never.format(42); // "42.00"
</code>

Stage 1

Import Sync

Provides a clear synchronous import function for ES modules, based on the Defer Import Eval proposal.

<code>let react;
try {
  react = import.sync('react');
} catch {}
if (react) {
  // If available, bind to the React framework
}
</code>