ECMAScript - Introducing All Stages of the TC39 Process

Every year, an edition of the ECMAScript specification is released - containing all recent features and changes which were approved since the previous edition.

In this article, we’re not going to explain the new changes themselves, but rather the authority approving them and the entire way until the approval.

The content is available as a video as well:

Let’s begin.

TC39

TC39 (Technical Committee 39) is a group under Ecma International containing ECMA members, which are JavaScript developers, implementers, academics and more; from various companies and institutions. The committee collaborates with the community to maintain and evolve the definition of the ECMAScript specification.

The committee meets regularly with a public agenda, in order to plan and make decisions regarding the specification. It’s worth mentioning that the decisions are made by consensus, meaning a proposal advances only when no delegate objects.

The TC39 Process

The process of making changes in the ECMAScript specification is done by the TC39, and naturally called the TC39 process. This process is built from six stages, starting with stage zero. Any proposal for a change in the specification goes through these stages without exception, when the committee must approve the progress from one stage to the next one.

The process was introduced after ECMAScript 2015 (ES6), which was a pretty huge release lasting very long without delivery (actually almost 6 years). Therefore, as of ECMAScript 2016, the editions have become smaller and are delivered every year, containing all proposals that reached stage 4 since the previous edition.

Stages

Now, let’s elaborate on the stages of the process.

🤷🏻 Stage 0: Strawperson

This is the first stage, called "Strawperson", representing an initial idea for addition or change to the specification that isn’t considered as a formal proposal. Suggestions for this stage must come from a TC39 member or registered contributor.

💡 Stage 1: Proposal

This stage is a formal proposal that describes a discrete problem or general need, suggests a shape of the solution and points out potential challenges, such as “cross-cutting” concerns with other features or complex implementation. The solution’s description should contain a high-level API with concrete examples; and also discuss algorithms, abstractions and semantics.

On top of that, one TC39 member, called the champion, is responsible for advancing the proposal. Typically the champion is the original author of the proposal, but not always. Reaching stage 1 means the committee is willing to invest time in exploring the problem. Moving on to the draft stage requires a new consensus of the committee, once there is an initial specification text.

✍🏻 Stage 2: Draft

This stage is the initial draft of the proposal in the specification, written in formal specification language.

The draft should describe the syntax, semantics and APIs precisely as much as possible, although it can have "TODO" comments or placeholders. During this stage, experimental implementations (such as polyfills or a build-time transpiler like Babel) are typically developed.

Moving forward from this stage means that the committee expects that the proposal would be developed and included eventually in the official specification, when only incremental changes (and mostly fixes) are expected.

🧪 Stage 2.7: Approved in Principle

This stage, added in 2024, means the proposal is approved in principle and undergoing validation. The specification text is complete, and all ECMAScript editors and designated reviewers have signed off on it.

The next step is validating the design through tests and implementations, so changes are expected only in response to issues found along the way.

📝 Stage 3: Candidate

This stage is a candidate proposal that’s almost final and recommended for implementation, but ready for feedback and refinements from implementations and users. The proposal is considered final when there is neither further work with the specification nor external feedback.

To reach this stage, the proposal should come with Test262 acceptance tests, and there should be sufficient experience to be confident that it can be implemented.

After this stage, changes would be made only for critical issues.

✅ Stage 4: Finished

This is the last stage, called "finished" obviously, indicating that the proposal is ready to be included in the latest draft of the specification - and be delivered with its next edition.

To reach this stage, the proposal requires two independent spec-compatible implementations passing the acceptance tests, significant in-the-field experience with them, a pull request to the ecma262 repository, and the sign-off of the ECMAScript editors.

Wrapping Up

The ECMAScript specification evolves every year through the TC39 process.

Key points to remember:

• TC39 is a diverse group of members working with JavaScript under ECMA International
• TC39 collaborates with the community to maintain and evolve the ECMAScript specification
• The TC39 process allows making changes in the ECMAScript specification using six regulated stages
• TC39 must approve each stage of the TC39 process for any change in the specification
• New editions of the specification are delivered every year
• Stage 0 represents an initial idea for addition or change to the specification
• Stage 1 is a formal proposal describing a problem and suggesting a proper solution
• Stage 2 is an initial draft of the proposal specification
• Stage 2.7 is when the specification text is complete and signed off, awaiting tests and implementations
• Stage 3 represents the proposal when it’s almost final and recommended for implementation
• Stage 4 is when the proposal specification is completely ready and included within the next edition