skip to content

In JavaScript's ECMAScript history, why is ES2015 treated as the break, and what changed about how editions are named and released afterwards?

level: juniorimportance: should knowfreq 34%

answer

  1. a long gap, then a giant edition
  2. ES4 abandoned, ES5 the smaller step
  3. syntax old parsers reject
  4. numbers before, years after
  5. one release per year since

basics

~20 s

ES2015, also called ES6, was the first large edition since ES5 in 2009 and added syntax older engines could not parse. Since then editions are named by year and published annually, each collecting the proposals that finished in time.

solid answer

~50 s

ES3 came out in 1999, the ambitious ES4 was abandoned, and ES5 arrived in 2009 as a smaller step. ES2015, the 6th edition and the same thing as ES6, was then a very large jump: `class`, `let` and `const`, arrow functions, modules, promises. Much of it was new syntax, which an older engine rejects at parse time, so compiling modern source down for older runtimes became routine. It also ended the big-bang release model. Before it, editions appeared every several years and are known by number. Since then the standard is named by publishing year, ES2016, ES2017 and so on, and approved yearly by the Ecma General Assembly. An edition is now mainly a snapshot of the proposals that reached Stage 4 by the cut-off, so individual features move on their own schedule instead of waiting for one giant release.

go deeper

for a junior

Recall the sequence: ES3, abandoned ES4, ES5 in 2009, the large ES2015, then one edition a year named by its publishing year. Know that ES6 and ES2015 are the same thing.

for a middle

Explain why new syntax made ES2015 a tooling event as well as a language event: an older parser rejects the file, so teams began compiling modern source down for old runtimes.

for a senior

Show that you do not reason from edition numbers. Features advance individually and engines adopt them individually, so an edition tells you what was standardized, not what your users' browsers can run.

for a principal

The angle worth holding is what the yearly train changed for planning: adoption is now a per-feature decision with continuous tracking, rather than a rare, organization-wide migration to a new language version.

## What an edition is **ECMAScript** is the standardized core of JavaScript: the syntax, the types, and built-ins such as `Array` and `JSON`. It is defined by a specification called **ECMA-262**, maintained by **TC39**, a technical committee of Ecma International. An **edition** is one approved version of that document. In everyday speech the words JavaScript and ECMAScript are often used interchangeably, but when someone says ES5 or ES2015 they are naming a version of the written standard, not a product you install. ## The timeline | Edition | Published | Why it matters | |---|---|---| | ES3 | 1999 | The long-lived baseline of the early web | | ES4 | Never | A very ambitious redesign that was abandoned, which is why the numbers jump from 3 to 5 | | ES5 | 2009 | A smaller step: strict mode, `JSON`, array helpers such as `map` and `forEach` | | ES2015 (ES6) | 2015 | The very large jump, and the last edition commonly known by a number | | ES2016 onward | Yearly | Smaller editions on a fixed annual cycle | For about a decade after ES3 the standard barely moved in practice, and ES5 only partly cleared the backlog. That is a large part of why ES2015 was so big. ## Why ES2015 is the break Three things changed at once, and each still shapes how JavaScript is written. - **Size.** One edition delivered `class`, `let` and `const`, arrow functions, modules, promises, template literals, destructuring, generators, `Map` and `Set`. This page only names them; what each does is a separate subject. - **New syntax at scale.** New built-in objects can often be supplied by ordinary script on an old engine. New syntax cannot, because the engine's parser rejects the source before anything runs. An older browser reading an arrow function does not skip that line. The script fails to parse. - **Routine compilation.** Because users kept old browsers for years, teams began writing ES2015 and compiling it down to ES5 for delivery. Writing one language version and shipping another became normal, and it remains normal for many web builds. ES5 had added some syntax too, such as getters in object literals, so ES2015 was not the first edition with new syntax. The break is the scale of it, combined with the end of the old release model. ## How naming changed Before ES2015, editions appeared every several years and are referred to by major number: ES3, ES5. From ES2015 on, the specification is named by publishing year. Both forms of the name remain in use for the 6th edition, so **ES6 and ES2015 are the same edition**. The arithmetic trips people up, because the numbers keep counting even though year names are now the norm: - ES2015 is the 6th edition, so ES6. - ES2016 is the 7th edition, so ES7. - ES2017 is the 8th edition, not ES7. **ESNext** is not an edition at all. It is a moving name for whatever comes next at the time of writing, and features described that way are more correctly called proposals, because the specification for them has not been finalized. ## How releases changed TC39 now intends to submit a specification for ratification every July. The process document gives an approximate annual timeline: 1. February: a candidate draft is produced, followed by a 60-day royalty-free opt-out period. 2. March TC39 meeting: Stage 4 proposals are incorporated, final semantics are approved, and the new version is branched. Only editorial changes are accepted afterwards. 3. April to June: Ecma's Executive Committee and General Assembly review it. 4. July: the General Assembly approves the new standard. The consequence is the part interviewers care about. A feature no longer waits for a giant release. Each proposal advances through the stages on its own, and an edition mainly records which ones had reached Stage 4 by the March cut-off. A proposal that gets there just after the cut-off simply lands in the following year's edition. That is why a yearly edition is usually modest, and why the edition number says little about what any one engine supports. ## Mistakes to avoid - Treating ES2015 as the latest JavaScript. It is more than a decade old, and many editions have followed it. - Reading a new edition as a new language to migrate to. Editions add to the language, and existing scripts are expected to keep working. - Assuming engines wait for July. Stage 4 itself requires shipping implementations, so features commonly run in engines before the edition that names them is published.

  • Which edition number is ES2017, and how do you work it out?
    ES2017 is the 8th edition. From ES2015 on, subtract 2009 from the year: 2015 gives 6, 2016 gives 7, 2017 gives 8. So ES7 means ES2016, not ES2017, a slip that is common because the two names look like they should line up.
  • Is ESNext an edition you can target as a fixed version?
    No. ESNext is a moving name for whatever comes next when someone writes it. Its meaning changes over time, and features described that way are more correctly called proposals because their specification has not been finalized. Pointing at it means pointing at a changing target.
  • Why is there no ES4 in the list of published editions?
    ES4 was a very ambitious redesign that the committee abandoned without publishing. The smaller track that followed became ES5 in 2009, which is why the numbering skips from 3 to 5. Some of the ideas came back later, in the much larger ES2015.

  • ES6 and ES2015 are two different editions of the standard.
  • ES7 is the same edition as ES2017.
  • ES4 is a published edition that a build could target.
  • ESNext is the name of the current published edition.
  • Engines cannot ship a feature until its edition is published in July.
  • Each yearly edition is a new language version that old code must migrate to.