HomepageExploring JavaScript (ES2024 Edition)
You can support this book: buy it or donate
(Ad, please don’t block.)

5 History and evolution of JavaScript

5.1 How JavaScript was created

JavaScript was created in May 1995 in 10 days, by Brendan Eich. Eich worked at Netscape and implemented JavaScript for their web browser, Netscape Navigator.

The idea was that major interactive parts of the client-side web were to be implemented in Java. JavaScript was supposed to be a glue language for those parts and to also make HTML slightly more interactive. Given its role of assisting Java, JavaScript had to look like Java. That ruled out existing solutions such as Perl, Python, TCL, and others.

Initially, JavaScript’s name changed several times:

5.2 Standardization: JavaScript vs. ECMAScript

There are two standards for JavaScript:

The language described by these standards is called ECMAScript, not JavaScript. A different name was chosen because Sun (now Oracle) had a trademark for the latter name. The “ECMA” in “ECMAScript” comes from the organization that hosts the primary standard.

The original name of that organization was ECMA, an acronym for European Computer Manufacturers Association. It was later changed to Ecma International (with “Ecma” being a proper name, not an acronym) because the organization’s activities had expanded beyond Europe. The initial all-caps acronym explains the spelling of ECMAScript.

Often, JavaScript and ECMAScript mean the same thing. Sometimes the following distinction is made:

Therefore, ECMAScript 6 is a version of the language (its 6th edition).

5.3 Timeline of ECMAScript versions

This is a brief timeline of ECMAScript versions:

5.4 Evolving JavaScript: TC39 (Ecma Technical Committee 39)

TC39 is the committee that evolves JavaScript. Its members are, strictly speaking, companies: Adobe, Apple, Facebook, Google, Microsoft, Mozilla, Opera, Twitter, and others. That is, companies that are usually competitors are working together on JavaScript.

Every two months, TC39 has meetings that member-appointed delegates and invited experts attend. The minutes of those meetings are public in a GitHub repository.

Outside of meetings, TC39 also collaborates with various members and groups of the JavaScript community.

5.5 The TC39 process for proposed ECMAScript features

With ECMAScript 6, two issues with the release process used at that time became obvious:

In response to these issues, TC39 instituted the new TC39 process:

The result: smaller, incremental releases, whose features have already been field-tested.

ES2016 was the first ECMAScript version that was designed according to the TC39 process.

5.5.1 Tip: Think in individual features and stages, not ECMAScript versions

Up to and including ES6, it was most common to think about JavaScript in terms of ECMAScript versions – for example, “Does this browser support ES6 yet?”

Starting with ES2016, it’s better to think in individual features: once a feature reaches stage 4, we can safely use it (if it’s supported by the JavaScript engines we are targeting). We don’t have to wait until the next ECMAScript release.

5.5.2 The details of the TC39 process (advanced)

ECMAScript features are designed via proposals that go through the so-called TC39 process. That process comprises six stages: Artifacts associated with an ECMAScript proposal

The following artifacts are associated with an ECMAScript proposal:

Each stage has entrance criteria regarding the state of the artifacts:

42 implementations Roles of the people that manage a proposal The stages of a proposal

Figure 5.1 illustrates the TC39 process.

Figure 5.1: Each ECMAScript feature proposal goes through stages that are numbered from 0 to 4.

Sources of this section:

5.6 How to not break the web while changing JavaScript

One idea that occasionally comes up is to clean up JavaScript by removing old features and quirks. While the appeal of that idea is obvious, it has significant downsides.

Let’s assume we create a new version of JavaScript that is not backward compatible and fixes all of its flaws. As a result, we’d encounter the following problems:

So what is the solution? This is how JavaScript is evolved:

5.7 FAQ: ECMAScript and TC39

5.7.1 Where can I look up which features were added in a given ECMAScript version?

There are several places where you can look up what’s new in each ECMAScript version:

5.7.2 How is [my favorite proposed JavaScript feature] doing?

If you are wondering what stages various proposed features are in, consult the GitHub repository proposals.

5.7.3 Why does stage 2.7 have such a peculiar number?

Stage 2.7 was added in late 2023, after stages 0, 1, 2, 3, 4 had already been in use for years.

Source: TC39 discussion on 2023-11-30