Facebook EmaiInACirclel
Software Development

ECMAScript Versions: From Roots to Present

Adrian Tudor
Adrian Tudor
React Developer

Since its first release as part of Netscape Navigator 2.0 in 1995 to the present, JavaScript has had a fascinating journey. The programming language had some crazy days early on with the explosion of the internet, appearance on different browsers, and adoption of mobile phones.

ecmascript versions - evolution

A brief history of popular ECMAScript versions from 1997 to 2019.

We all needed a standard (ECMAScript) to follow in our implementations because JavaScript wasn’t the only programming language that we used. Jscript – developed by Microsoft – and ActionScript were JavaScript’s main competitors.

The truly experienced developers who used IE6/7/8 in the early days may remember late nights trying to fix compatibility issues between browsers. Let’s take a look at the engines behind the most popular browsers and how they’ve evolved.

And by engine, I mean the main source code that contains the actual JavaScript implementation:

  • Internet Explorer – Chakra engines -> Edge – next version will be based on Chromium (a web browser – based on Blink Engine)
  • Chrome – Original WebKit – then forked in ‘Blink Engine’
  • Safari – Webkit – transformed into Nitro
  • Opera – Presto Own Engine, then switched to Blink Rendering Engine (which contains V8 Engine)

There are several browsers, each one trying to implement the rules set by ECMAScript.


That’s cool, but who sets the rules in ECMAScript, and how are they selected?

For example, as a JavaScript developer, have you ever wanted an easier way of working with context or having classes? At some point, other developers wanted this, too, so they followed the so-called “TC39 Process”, a standard that specifies how to add features.

There are five necessary steps to accelerate a feature from idea to implementation:

ecmascript versions - stages

As with all projects, every feature developed along the way is included in a big, stable release. In the beginning, ECMA International didn’t release new features in a very organized way. But since 2015, the organization has provided regular, stable releases each year, often in June.

We’ve seen how the process works, now let’s take a look at which features ECMA International improved or added in each ECMAScript version:

#June 1997 – Initial ECMAScript Version

#June 1998 – aligned with ISO/IEC 16262 international standard

#December 1999 – regular expressions added; try-catch block; better string manipulation

ECMA International abandoned version 4 due to some complexities. New features that were added to this edition were either completely dropped or included in the sixth edition.

#December 2009 – The fifth edition came out after a 10-year break. “Strict Mode” was added, some features were removed, and access to the global object was cut. This version offered better support for JSON object (parse and stringify functions), new functions on arrays (map, filter, reduce, every, some, indexOf, lastIndexOf, forEach, and others), new functions for strings (trim, charAt), Object.defineProperty, getters and setters.

#June 2015 – ES6 edition started a REVOLUTION and a new generation of JavaScript emerged, an advancement of great interest to any respectable frontend developer. We’re back in business! Many new features were added such as:

  • Default parameters
  • Rest/Spread Parameters (but only for arrays)
  • Arrow functions (no more binding functions to context)
  • Modules
  • Classes (Don’t worry, it’s only syntactic sugar)
  • Iterators and Symbols (You should probably look into these – they’re very cool)
  • Generators (If you’ve worked with React-Redux-Saga, in saga files they can be beneficial)
  • Promises
  • String Literals
  • Destructuring
  • Shorthand Properties
  • Let and Const
  • Set
  • Map
  • Proxies
  • Reflect
  • Binary and Octal and some other new methods and constants.

Starting from now on, all the releases will be made each year, so we will not have versions that contain as many features as the one from 2015.

#June 2016 – ES7 edition was launched with just two new additions: Array.prototype.includes() and Exponentiation operator **

#June 2017 – ES8 edition included Async/await (new way of writing asynchronous code, an alternative to Promises), New methods (Object.values(), Object.entries(), String.prototype.padEnd(), String.prototype.padStart(), Object.getOwnPropertyDescriptors()), Trailing commas.

#June 2018 – Also known as ECMAScript version 2018, this release offered new features: Rest operator (in object destructuring), Spread operator (in object literal), Asynchronous iteration, Promise.finally, Tagged string template, new regex functionality.

#June 2019 – ES10 version included New Methods (Array.flat, Array.flatMap, String.trimStart/trimEnd, Object.fromEntries), try…catch (e – OPTIONAL PARAM), .toString method revised, Symbol class update.

It’s interesting to see why each feature ended up as an ECMAScript standard. You can always take a look at the feature proposals and see intriguing features that were proposed but didn’t survive the T39 process.


I’m curious to know what kinds of features would be useful in the future. What do you think? Can you guess the features of the next release?
I’d be happy to know your thoughts on this topic, so post a comment.

Leave a Reply

Your email address will not be published. Required fields are marked *