skip to content

In the TC39 process for JavaScript proposals, what are the stages, and what does each one promise about a proposal's stability?

level: middleimportance: should knowfreq 36%

answer

  1. more than 0 to 4
  2. a stage between 2 and 3
  3. draft, then validated, then implemented
  4. tests written before the recommendation
  5. two compatible implementations to finish

basics

~20 s

TC39 proposals move through six stages: 0, 1, 2, 2.7, 3 and 4. Stability rises along the way: Stage 2 may change significantly, Stage 3 changes only if forced, and Stage 4 is finished and headed for the standard.

solid answer

~50 s

The process has six stages: a strawperson Stage 0 plus five maturity stages, 1, 2, 2.7, 3 and 4. Stage 0 is an idea the committee is not yet considering. Stage 1 means it is under consideration, with a champion examining the problem. Stage 2 means a preferred solution is chosen, but the design is a draft that may change significantly and may never be standardized. Stage 2.7 means approved in principle: spec text is complete and signed off, the committee requests changes only if testing, implementation or usage calls for them, and conformance tests get written. Stage 3 recommends implementation, and changes are not expected, though web incompatibilities or production feedback can force them. Stage 4 means complete: two compatible implementations pass Test262 and no further changes are made to the proposal. By consensus, a proposal can also be sent back or withdrawn.

go deeper

for a junior

Recall that a feature climbs a ladder before it is standard, that Stage 3 means recommended for implementation, and that Stage 4 means finished. Know that the ladder has more steps than the numbers 0 to 4 suggest.

for a middle

Give each stage's promise in words: draft at 2, validated at 2.7, recommended at 3, complete at 4. Say that Stage 4 requires two compatible implementations passing Test262.

for a senior

Use the stages as risk evidence and quote them accurately. Stage 3 changes are not expected but remain possible, and the stage says nothing about which engines your users run.

for a principal

The tradeoff angle is that the ladder measures design stability, while adoption also depends on runtime support and exit cost. Team rules that key only on the stage number miss the other two.

## What the process is **TC39** is the Ecma committee that evolves ECMAScript, the standard behind JavaScript. It works by consensus, and a new feature normally starts as a **proposal** that climbs a ladder of stages. A **champion**, a person or group, carries the proposal and asks the committee to approve each step. The committee may also elide the process, based on the scope of a change, as it sees fit. Many older write-ups say "stages 0 to 4" and describe five stages. The process document says otherwise: "There are six stages: a strawperson stage and five maturity stages." The one those write-ups miss is **Stage 2.7**. ## The stages | Stage | Status | What it takes to enter | Work done there | |---|---|---|---| | 0 | New, not currently being considered by the committee | Nothing; authors assign it themselves | Make the case and explore the problem | | 1 | Under consideration | A champion, prose on the problem and solution shape, a public repository | Design a solution, resolve cross-cutting concerns | | 2 | Preferred solution chosen; design is a draft | Proposal document, examples, initial spec text | Refine details, get reviews, build experimental implementations | | 2.7 | Approved in principle, under validation | Complete spec text, signed off by reviewers and editors | Write tests, validate the design | | 3 | Recommended for implementation | Sufficient testing and pre-implementation experience | Gain implementation experience, find web compatibility issues | | 4 | Complete, ready for the standard | Two compatible implementations passing Test262, in-the-field experience, a signed-off pull request | Integrate into the draft and a yearly edition | **Test262** is the official conformance test suite for ECMAScript, and an **implementation** usually means a JavaScript engine. ## What each stage promises The useful way to read the ladder is by the strength of its stated promise. - **Stage 0 and Stage 1 promise nothing about the result.** Stage 1 only says the committee expects to spend time examining the problem space. - **Stage 2 expects a feature but does not guarantee one.** The design "may still change significantly", and the process says the feature "may never be included in the standard". The process describes its experimental **polyfills**, script that imitates a missing feature, as loosely-correct and not for production use. - **Stage 2.7 narrows changes.** The solution is complete, and the committee will request no changes aside from those elicited through testing, implementation or usage experience. - **Stage 3 recommends implementation.** No changes are expected, but some necessary changes may still occur because of web incompatibilities or feedback from production-grade implementations. - **Stage 4 closes the proposal.** No further changes will be made to it. Stage 3 carries a further protection. A Stage 3 proposal that meets the Stage 4 criteria may not be held back unless the objection concerns implementation experience or raises something the committee has not previously discussed. The stated aim is to let implementers invest with confidence. ## Stages and engines The stages do not describe what your runtime can do. Engines typically implement at stage 3 or stage 4, but the timing is each engine's choice. A proposal can sit at Stage 3 with no engine shipping it unflagged, and a feature can reach Stage 4 while an engine outside the required two still lacks it. ## From Stage 4 to an edition Reaching Stage 4 is not the same as appearing in a published edition. The steps are: 1. Entering Stage 4 already requires a pull request with the integrated spec text, signed off by the relevant editors. 2. At the March TC39 meeting, Stage 4 proposals are incorporated and the new version is branched. 3. The Ecma General Assembly approves the new standard in July. The dates are an approximate timeline, so treat them as the usual shape of the year. A proposal that reaches Stage 4 after the March cut-off goes into the next year's edition. ## Moving backwards The ladder is not one-way. At any point a champion may ask to regress a proposal to an earlier stage or withdraw it, with a rationale and the committee's consensus. There is no established concept of a rejected proposal: when consensus is not reached, the reasons are recorded, and a champion can rework the proposal and come back.

  • What does Stage 2.7 do that Stage 2 and Stage 3 do not?
    It is the validation step between them. Spec text is complete and signed off by reviewers and editors, and the committee will request no changes unless testing, implementation or usage calls for them. Test262 tests get written here, so a proposal arrives at the implementation recommendation with tests behind it.
  • When does a proposal that has just reached Stage 4 appear in a published edition?
    It goes into the next edition still open. At the March TC39 meeting Stage 4 proposals are incorporated and the new version is branched, and the General Assembly approves it around July. One that reaches Stage 4 after that cut-off waits for the following year's edition.
  • Can a TC39 proposal be rejected outright?
    The process has no established concept of a rejected proposal. If consensus is withheld, the reasons are recorded and the champion can rework it and return. A proposal can also be regressed to an earlier stage or withdrawn, with a rationale and the committee's consensus.

  • There are exactly five stages: 0, 1, 2, 3 and 4.
  • Stage 3 guarantees that the design will never change.
  • Stage 2 means the feature will definitely reach the standard.
  • Stage 4 means every major engine has already shipped the feature.
  • A Stage 0 idea is already under review by the committee.
  • A champion can move a proposal up the stages without committee consensus.