Javascript, JS, ECMAscript, ES, ECMA, TC39 the tongue-twister nobody asked for, explained
Tags: javascript, tc39, ecmascript
Published: 2020-07-14 21:55:03

JS versioning, naming, the specification, the standard, TC39, ECMA... all these concepts may sound really confusing to you, so I will make an attempt to make it clear in as few lines as possible.


## Core definitions

Let's start defining some important concepts and then relate them further. Try to read through them, cause they are deeply interrelated, make a rough picture in your head and then read them again one by one more carefully.

**ECMA**: It is a [standards organization](https://en.wikipedia.org/wiki/Ecma_International). In case you don't know it, it's similar to the probably more famous ISO Organization. Both of them manage standards across a variety of topics

**Standard/Specification**: It refers to the document where the spec of the language are detailed to be implemented

**JS**: It's the programming language most widely used that implements the ECMAScript standard. There have been other implementations like JScript and ActionScript

**TC39**: The committee that decides how the ECMAScript standard evolves which they then submit to ECMA

**JS naming and versions**: Javascript name is a trademark owned by Oracle, so TC39 is trying to move away from this naming and formalize ECMAScript instead. Since 2016, the official language name has also been suffixed by the revision year (ECMAScript 2016, ECMAScript 2017, etc, and abbreviated like ES2019, ES2020, etc). Other names you may have heard are ES6, JS6, etc, but it is better to keep away from them in order to avoid confusion and ensure future consistency

**ECMA-262**: It is the name that ECMA gives to the ECMAScript language standard

**JS versions**: According to what we just said, TC39 versions the standard every year (ES2018, ES2019, etc). Also, ECMA-262 gets versioned every time the TC39 committee presents a new document to the ECMA organization. As of this writing, the most up-to-date version is 11.0 (11th edition) (https://www.ecma-international.org/ecma-262/11.0/). So ES2019 is equivalent to 10th edition of ECMA-262. 

NOTE: You can also check some of the previous ECMAScript editions changing the version in the URL (https://www.ecma-international.org/ecma-262/9.0/)


## The Process of Releasing a New ECMAScript Version

The process of releasing a new ECMAScript version is: Let's pretend it is June 2020. TC39 gathers and agrees to add some features to the ECMAScript standard (how they do it's a topic for another day). They come up with this new standard and name it ECMAScript suffixed by the revision year (2020, in our case) which conforms ECMAScript 2020 (ES2020). Then they submit it to ECMA (remember that the code-name ECMA has for ECMAScript is ECMA-262) and then ECMA-262 gets versioned. It would receive version 11.0 (11th edition) since ECMA-262 previous version was 10.0.

![Release process](https://dev-to-uploads.s3.amazonaws.com/i/y5a7zfmyj4t1pahjrec6.png)


## The relation between the standard and the language

Like many other things, this is different in JS. 

In other languages, you are not used to referring to the standard directly, but to the language itself (for instance, Java 11 has this feature, or PHP 7 behaves this way, but you talk about the language itself). Basically the relation specification - language is 1 to 1, so from the point of view of the programmer, this is transparent.

In ECMAScript ecosystem, on the other hand, you have 1 standard (ECMAScript standard), and several implementations (ECMAScript, ActionScript, JScript, etc). This is confusing especially for novice JS developers. TC39 is now pushing towards naming ECMAScript to both the standard and the language. This makes sense since the other implementations of the standard are not that relevant nowadays. This way you would say: ECMAScript 2019 (ES2019) implements the 10th edition of the ECMAScript standard (version 10.0 published in ECMA standard organization under the name ECMA-262).

![Standard-language relationship](https://dev-to-uploads.s3.amazonaws.com/i/c9ng7nuzwvm2f4dqzko4.png)

## Conclusion

And that's it. Hopefully, this brought some light into a quite confusing matter regarding the language. It is not easy to understand and to relate all these concepts at first, but eventually, this gibberish starts making some sense.


Please leave any comments behind speaking your mind. Happy coding!

PS: Diagrams created with [excalidraw](https://excalidraw.com/)


**Sources & Links**

https://en.wikipedia.org/wiki/ECMAScript
https://github.com/getify/You-Dont-Know-JS/blob/2nd-ed/get-started/ch1.md
https://www.ecma-international.org/ecma-262/10.0/