As a front-end developer, you’re familiar with the word ES6, the oddly pronounced name ECMAScript, and have you ever wondered what the cryptic code for ECMA is, ecMA-262, ESxxx, TC39, etc. What does Stage 3 and Stage 4 mean? Are you confused by the endless new ES20XX features? Do you need to know when the feature was released, where to see these proposals, which ones are available, and where to find the ES standard over the years? Today I’m going to take you through the mystery of ECMAScript, understand the code names and the features of ECMAScript until 2021.

Also: Congratulations on our country’s first JS language proposal entering Stage 3 at ECMA.

ECMAScript history

Let’s start by looking at what ECMA is. ECMA, pronounced “ECMA”, is short for the European Computer Manufacturers Association, an international membership information and telecommunications standards organisation. Since 1994, Ecma has dropped its acronym because the organization’s standards involve so many other countries that it changed its name to Ecma International to reflect its internationality.

With this history in mind, for technical purposes, if Ecma is mentioned in the article, write it as Ecma or Ecma. Do not write it as Ecma unless it is ECMAScript or ecMA-XXX.

In 1995, Brendan Eich of the famed Netscape company developed a scripting language that was first named Mocha, then LiveScript, and finally JavaScript to ride the Java fever of the time.

Knowing Ecma International and JavaScript makes it easy to understand ECMAScript, a scripting language specification defined by Ecma International in the standard ECMA-262. The language is often referred to as JavaScript or JScript, but JavaScript and JScript are actually implementations and extensions of the ECMA-262 standard.

The mystery of the ECMA – 262

What is ecMA-262? Ecma 262 is the Ecma 262 standard that ECMAScript complies with. In November 1996, Netscape submitted JavaScript to Ecma International for standardization. The first version of ECMA-262 was adopted by ECMA International in June 1997.

Although JavaScript and JScript are ECMAScript compatible, they contain capabilities that go beyond ECMAScript.

How to check out the latest and most comprehensive Ecma Standards can be found on the Ecma international website. As of April 2021, the latest Ecma standard is ECMA-418.

The Ecma standard covers a wide range of categories, so the official website provides the ability to sort the ecMA-262 by category and by the latest modification. Let’s see which category ecMA-262 belongs to:

Ecma-262 belongs to the “Software Engineering and Interface” category, which has 12 standards, as shown in the figure above. Note that the latest update date for ECMA-262 is June 2020, and it will be updated in June of this year, after which ES2021 will become an ECMA standard.

Explore the mysterious organization of Ecma TC39

With the mystery of ECMA-262 behind us, we explore a mysterious organization code-named TC39.

In fact, the official website has been very clear, I will briefly summarize in Chinese:

TC39 is short for Technical Committee 39, the Committee that develops the ECMAScript standard. It is composed of representatives from major browser manufacturers, including PayPal, Bloomberg, and Microsoft. It consists of two task groups tc39-TG1 and TC39-TG2.

The TC39-TG1 Working Group focuses on the common ECMAScript® language, including syntax, semantics, class libraries, and technologies that support the language.

Tc39-tg2 Working Group ECMAScript® International API standard.

We often see similar news: XX company became a member of Ecma TC39. To join TC39, you must first become an Ecma member:

So who are the members of Ecma? The answer, according to the Ecma website:

Several big giants stand out in the column! There are five categories: Ordinary Members, Associate Members, SME Members, SPC Members, AND NFP Members. Let’s look at Ordinary members and Associate members:

Associate Members do not have voting rights in the Ecma General Assembly. Among Associate members, Alibaba, Huawei, Tencent and 360 of China are among them.

Wait, CHF 70,000. Is this 70,000 francs? Ecma is indeed one of the European giants, with an annual membership fee of nearly 500,000 RMB. Calculate Ecma’s international membership fee income at 1,134,000 francs a year, or about 8 million yuan.

To learn more about TC39, explore its website TC39 — Specifying JavaScript. · GitHub Ecma TC39 · GitHub Look at Members, and you’ll find wolyeong, Lee Song-bong and Won-Eon.

The familiar ES6

After exploring the mysterious ECMA-262 and TC39, let’s take a breather and take a look at the ESX family we’re most familiar with.

As mentioned above, ECMAScript is a scripting language specification defined by Ecma International in the ecMA-262 standard. By 2015, a total of 7 releases (four of which were scrapped) were released: 1, 2, 3, 4, 5, 5.1, and 6.

We often refer to pre-5.1 versions of ECMAScript as ES5 and post-6 versions as ES6. (Since 2015, ECMAScript has finally gotten back on track with an annual release, and by 2021, there are six, which is way too many. Hence ES6, which revolutionized JavaScript, as the name for the subsequent version).

It’s important to note that ES6 is often used in JD for Web front-end recruitment, not just for ES2015, but for ES2015 and subsequent annual releases of ECMAScript.

Since ECMAScript version 6, one ECMAScript version has been released every year, so there are many names for ECMAScript versions, Includes the full name ECMAScript 6, the abbreviation ES6, the year named ECMAScript 2015, and the abbreviation ES2015. The most common name is ES6, followed by ES7 and ES8.

It is important to note that the ECMAScript version has become much less important since the TC39 process was developed. You don’t have to remember exactly when an ES feature was introduced. What really matters now is what phase the proposal is in: once the proposal reaches Phase 4, then it’s ready to use. But even then, you still need to check if your engine supports this feature.

The concept of TC39 processes and stages is mentioned again. Let’s look at what these two concepts mean.

TC39 process and Stage X

TC39 process is the name of the process, must be issued by the TC39 organization. With the release of ECMAScript 6, there were two obvious issues with the release process at the time:

  • If you pass pre-built functionality multiple times between releases, you’ll have to wait a long time before it’s released. And if the feature is prepared late, it increases the risk of being rushed before the deadline.
  • Many features are designed for a long time before they are implemented and used, and design flaws related to implementation and use can be discovered very late.

To address the above issues, TC39 established a new TC39 process:

  • The ECMAScript feature design is separate from the annual release of the ECMAScript version and uses stages to distinguish the state of the feature. There are five stages, starting with Stage 0 (strawman) and ending with Stage 4 (Finished).
  • Later stages require prototype implementation and real machine testing, and feedback mechanisms between design and implementation can be established.
  • The ECMAScript version is released once a year, containing all the features that reached Stage 4 prior to the release deadline.

  • Stage 0: The draft Stage
  • Stage 1: Codename “Proposal”, TC39 help Stage
  • Stage 2: Codenamed “Draft”, this Stage is likely to become the standard
  • Stage 3: Codename “candidate”, completed, needs feedback from the implementation
  • Stage 4: Code-named “Finished”, ready to become standard

The first JS language proposal in China has entered Stage 3 in ECMA.

How do you view proposals at each stage? Check out the REPO github-TC39 / ECMA262: Status, Process, and Documents for ECMA-262.

All previous ES features are included in ES2016-ES2022

There are so many scattered ES feature summaries online that many students would like to know: is there an official ECMAScript feature list?

Of course, the TC39 repository lists completed proposals and their versions.

Although 6 years have passed, there are not many ES functions added. As of April 23, 2021, including the functions in the draft, there are altogether 39 ES functions:

ES2016

  • Array.prototype.includes

    • Author: Domenic Denicola
    • Defenders: Domenic Denicola, Rick Waldron
    • Minutes of TC39 Meeting: November 2015
    • Release time: 2016

  • Exponentiation operator

    • By Rick Waldron
    • Defender: Rick Waldron
    • Minutes of TC39 Meeting: January 2016
    • Release time: 2016

ES2017

  • Object. The values/Object. Entr…

    • By Jordan Harband
    • Maintainer: Jordan Harband
    • TC39 Minutes: March 2016
    • Release time: 2017

  • String padding

    • By Jordan Harband
    • Defenders: Jordan Harband, Rick Waldron
    • TC39 Minutes: May 2016
    • Release time: 2017

  • Object.getOwnPropertyDescriptors

    • By Jordan Harband and Andrea Giammarchi
    • Defenders: Jordan Harband, Andrea Giammarchi
    • TC39 Minutes: May 2016
    • Release time: 2017

  • Trailing commas in function parameter lists and calls

    • By Jeff Morrison
    • Defender: Jeff Morrison
    • Minutes of TC39 Meeting: July 2016
    • Release time: 2017

  • Async functions

    • By Brian Terlson
    • Defender: Brian Terlson
    • Minutes of TC39 Meeting: July 2016
    • Release time: 2017

  • Shared memory and atomics

    • By Lars T Hansen
    • Defender: Lars T Hansen
    • Minutes of TC39 Meeting: January 2017
    • Release time: 2017

ES2018

  • Lifting template literal restriction

    • By Tim Disney
    • Maintainer: Tim Disney
    • TC39 Minutes: March 2017
    • Release time: 2018

  • s (dotAll) flag for regular expressions

    • By Mathias Bynens
    • Defenders: Brian Terlson, Mathias Bynens
    • TC39 Minutes: November 2017
    • Release time: 2018

  • RegExp named capture groups

    • By Gorkem Yakin and Daniel Ehrenberg
    • Maintainers: Daniel Ehrenberg, Brian Terlson, Mathias Bynens
    • TC39 Minutes: November 2017
    • Release time: 2018

  • Rest/Spread Properties

    • By Sebastian Markbage
    • Defender: Sebastian Markbage
    • Minutes of TC39 Meeting: January 2018
    • Release time: 2018

  • RegExp Lookbehind Assertions

    • By Gorkem Yakin, Nozomu Katō and Daniel Ehrenberg
    • Supported by: Daniel Ehrenberg, Mathias Bynens
    • Minutes of TC39 Meeting: January 2018
    • Release time: 2018

  • RegExp Unicode Property Escapes

    • By Mathias Bynens
    • Maintainers: Brian Terlson, Daniel Ehrenberg, Mathias Bynens
    • Minutes of TC39 Meeting: January 2018
    • Release time: 2018

  • Promise.prototype.finally

    • By Jordan Harband
    • Maintainer: Jordan Harband
    • Minutes of TC39 Meeting: January 2018
    • Release time: 2018

  • Asynchronous Iteration

    • By Jordan Harband
    • Maintainer: Jordan Harband
    • Minutes of TC39 Meeting: January 2018
    • Release time: 2018

ES2019

  • Optional catch binding

    • By Michael Ficarra
    • Defender: Michael Ficarra
    • Minutes of TC39 Meeting: May 2018
    • Release time: 2019

  • JSON superset

    • By Richard Gibson
    • Defenders: Mark Miller, Mathias Bynens
    • Minutes of TC39 Meeting: May 2018
    • Release time: 2019

  • Symbol.prototype.description

    • By Michael Ficarra
    • Defender: Michael Ficarra
    • Minutes of TC39 Meeting: November 2018
    • Release time: 2019

  • Function.prototype.toString revision

    • By Michael Ficarra
    • Defender: Michael Ficarra
    • Minutes of TC39 Meeting: November 2018
    • Release time: 2019

  • Object.fromEntries

    • By Darien Maillet Valentine
    • Defenders: Jordan Harband, Kevin Gibbons
    • Minutes of TC39 Meeting: January 2019
    • Release time: 2019

  • Well-formed JSON.stringify

    • By Richard Gibson
    • Maintained by: Mathias Bynens
    • Minutes of TC39 Meeting: January 2019
    • Release time: 2019

  • String.prototype.{trimStart,trimEnd}

    • By Sebastian Markbage
    • Defenders: Sebastian Markbage and Mathias Bynens
    • Minutes of TC39 Meeting: January 2019
    • Release time: 2019

  • Array.prototype.{flat,flatMap}

    • By Brian Terlson, Michael Ficarra and Mathias Bynens
    • Defenders: Brian Terlson, Michael Ficarra
    • Minutes of TC39 Meeting: January 2019
    • Release time: 2019

ES2020

  • String.prototype.matchAll

    • By Jordan Harband
    • Maintainer: Jordan Harband
    • TC39 Minutes: March 2019
    • Release time: 2020

  • BigInt

    • By Daniel Ehrenberg
    • Maintained by: Daniel Ehrenberg
    • Minutes of TC39: June 2019
    • Release time: 2020

  • Promise.allSettled

    • By Jason Williams, Robert Pamely and Mathias Bynens
    • Maintained by: Mathias Bynens
    • Minutes of TC39 Meeting: July 2019
    • Release time: 2020

  • globalThis

    • By Jordan Harband
    • Maintainer: Jordan Harband
    • Minutes of TC39: October 2019
    • Release time: 2020

  • for-in mechanics

    • By Kevin Gibbons
    • Defender: Kevin Gibbons
    • Minutes of TC39: December 2019
    • Release time: 2020

  • Optional Chaining

    • By Gabriel Isenberg, Claude Pache and Dustin Savery
    • Defenders: Gabriel Isenberg, Dustin Savery, Justin Ridgewell, Daniel Rosenwasser
    • Minutes of TC39: December 2019
    • Release time: 2020

  • Nullish coalescing Operator

    • By Gabriel Isenberg
    • Defenders: Gabriel Isenberg, Justin Ridgewell, Daniel Rosenwasser
    • Minutes of TC39: December 2019
    • Release time: 2020

  • import.meta

    • Author: Domenic Denicola
    • Maintainer: Gus Caplan
    • TC39 Minutes: March 2020
    • Release time: 2020

ES2021

  • String.prototype.replaceAll

    • By Peter Marshall, Jakob Gruber and Mathias Bynens
    • Maintained by: Mathias Bynens
    • Minutes of TC39 meeting: June 2020
    • Expected release date: 2021

  • Promise.any

    • By Mathias Bynens, Kevin Gibbons and Sergey Rubanov
    • Maintained by: Mathias Bynens
    • Minutes of TC39 Meeting: July 2020
    • Expected release date: 2021

  • WeakRefs

    • Dean Tribble and Sathya Gunasekaran
    • Defenders: Dean Tribble, Mark Miller, Till Schneidereit, Sathya Gunasekaran, Daniel Ehrenberg
    • Minutes of TC39 Meeting: July 2020
    • Expected release date: 2021

  • Logical Assignment Operators

    • By Justin Ridgewell
    • Defenders: Justin Ridgewell, Hemanth HM
    • Minutes of TC39 Meeting: July 2020
    • Expected release date: 2021

  • Numeric separators

    • By Sam Goto and Rick Waldron
    • Defenders: Sam Goto, Rick Waldron, Leo Balter
    • Minutes of TC39 Meeting: July 2020
    • Expected release date: 2021

ES2022

  • Class Fields ( Private instance methods and accessors , Class Public Instance Fields & Private Instance Fields , Static class fields and private static methods )
    • By Daniel Ehrenberg
    • Defenders: Daniel Ehrenberg, Kevin Gibbons
    • Minutes of TC39 meeting: April 2021
    • Expected release date: 2022

conclusion

It is better to teach people how to fish than to teach people how to fish. I hope this article can trace back to the source and lead students into the world of ECMAScript, so that ES mysterious code will no longer be mysterious and ES new features will no longer hesitate.

I am Qingqiu, a Web front-end atypical programmer with a teacher’s dream. Frontend Radio has just started. I hope my article can help more students, let us grow up together, and become Frontend Master as soon as possible.

The resources

  • Ecma International – Wikipedia, the free encyclopedia
  • History and evolution of JavaScript
  • ECMAScript 2021: Final feature set determination