Platform under construction

Versions & Runtimes

Intermediate

TC39 Process

TC39 is the standards committee that evolves ECMAScript. The proposal stages explain whether a new JavaScript feature is only an idea, being designed or ready for the language.

// Mental model
const proposal = { name: "Example feature", stage: 3 };

if (proposal.stage >= 3) {
  console.log("Watch implementation support closely.");
}

Versions & Runtimes

New JavaScript features move through a staged standards process.

JavaScript does not evolve because one browser vendor randomly adds syntax and everyone else follows. ECMAScript is evolved through TC39, the Ecma technical committee responsible for the language specification.

Proposals move through maturity stages. Stage 0 is an idea. Later stages require a clearer design, specification text, tests, implementation feedback and eventually readiness for inclusion in the standard.

For developers, the practical lesson is caution. Stage 3 can be exciting, but it is not the same as universal support. Stage 4 means the feature is complete and ready to be included in the standard, but your runtime still has to implement it.

Stage 0

An idea or strawperson. Interesting, but far away from production certainty.

Stage 1 and 2

The problem and solution shape are being explored and refined. Details can still change.

Stage 2.7 and 3

The design is much more mature and needs testing, implementations and real feedback.

Stage 4

The proposal is finished and ready to be included in the ECMAScript standard.

Examples

Good JavaScript respects its target environment.

Treat proposals as maturity signals

function canUseFeature({ stage, supported }) {
  if (stage < 4) {
    return "Use only in experiments or with careful tooling.";
  }

  return supported ? "Safe for this target." : "Needs fallback or transpilation.";
}

Using proposals because they look cool

// A blog post mentions a proposal.
// The syntax looks nice.
// The project ships it without checking stage, support or tooling.

shipExperimentalSyntax();

Rules that matter

Version and runtime choices are production decisions.

Modern JavaScript is powerful, but support is never automatic. Choose syntax, APIs and tooling based on the environments that must run the code.

Stage is not support

A proposal stage says how mature the design is, not whether every browser supports it.

Stage 4 is the finish line for standardization

It is the point where the proposal is complete and ready for inclusion.

Runtime support still matters

Even standard features need browser or server runtime implementation.

Avoid experimental syntax in core paths

If a feature requires fragile tooling, keep it away from critical production flows.

Follow the problem, not the hype

A proposal exists to solve a problem. Learn that problem before learning the syntax.

Document nonstandard choices

If a project uses experimental features, future maintainers need to know why.

Production thinking

Support strategy keeps modern JavaScript reliable.

Why does this matter?

TC39 literacy protects you from shiny-object development. You can judge whether a new feature belongs in production, a demo or a watchlist.

Accessibility

Experimental features can break silently in unsupported environments. That can remove behavior users depend on, including validation and keyboard support.

Production note

Production teams should prefer stable language features and use tooling only when the support tradeoff is understood.

SEO note

Search bots and users need stable pages. Experimental syntax in render-critical code can make content unreliable.

Live code lab

Change the HTML, CSS or JavaScript and run the result.

The preview runs inside an isolated iframe. The JavaScript is placed inside the HTML editor for now, so every example stays together and remains easy to understand.

Mini assignment

Try this now.

Change the stage to 4 and supported to true.
Add a second proposal object and compare the output.
Write a message for Stage 0 that clearly says experiment only.

Practice assignment

Do this before moving to the next topic.

Pick one JavaScript proposal you have heard of.
Find its current TC39 stage.
Write whether you would use it in production and why.

HTML + JavaScript CSS

Live preview

Self-check

Before you continue, prove that you understand TC39 Process.