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.
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. 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
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 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.
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).
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
Sources & Links