History of JavaScript - How it came into the existence

Subscribe to my newsletter and never miss my upcoming articles

Javascript is a powerful scripting language. It was mainly developed for improving the interactions on web pages. But it has evolved so massively that it can now be used for mobile and desktop applications along with web applications.

Who created Javascript

Javascript was created within 10 days in May 1995 by Brendan Eich. He worked as a Netscape Engineer at that time.

How it got its name

Javascript was initially named Mocha but it was officially called LiveScript when first shipped as part of the Navigator 2.0 beta release in September 1995. But three months later, after receiving a Sun trademark, the name was changed to JavaScript in Netscape Navigator 2.0 beta 3 release.

Naming it JavaScript was a marketing tactic by Netscape to give the impression that JavaScript was a spin-off of Java since Java was very popular among developers at that time. However, these two languages are not related to each other at all.

Why was JavaScript created?

It was created to add animations and user interactions to make websites dynamic. Netscape wanted to be ahead of the game by introducing this in its browser so they came up with this.

Standardization of JavaScript

In November 1996, Netscape submitted JavaScript to ECMA (European Computer Manufacturers Association), as the starting point for a standard specification that all browser vendors could follow.

They had a technical committee that came up with ECMA-262 for standardizing the syntax and semantics to provide a vendor-neutral scripting language. This committee had developers from Netscape Communications, Microsoft, Sun Microsystems, and many other companies.

ECMA was expanded beyond Europe so they changed their name to Ecma International where Ecma is a name and not an acronym anymore. They are responsible for the development and upkeep of the language to this day. As a result, the scripting language was officially given the name ECMAScript.

ECMAScript Timeline

ECMAScript 1 (June 1997): First version of the standard.

ECMAScript 2 (June 1998): Small update to keep these standards in sync with the ISO standard.

ECMAScript 3 (December 1999): Added many core features like regular expressions, try/catch exception handling, better string handling, do-while, switch, etc.

ECMAScript 4 (abandoned in July 2008): A massive upgrade with static typing, modules, namespaces, etc, but it was never finalized and got abandoned.

ECMAScript 5 (December 2009): Added minor improvements along with JSON support, strict mode, and some array methods.

ECMAScript 5.1 (June 2011): Small update to keep Ecma and ISO standards in sync.

ECMAScript 6 (June 2015): A large update that took a lot of things from the abandoned ECMAScript 4. This was the first version that used the year of publication as its official name - ECMAScript 2015. It added a lot of features like classes, promises, arrow functions, default parameter values, let/const, etc.

ECMAScript 2016 (June 2016): First yearly release with few improvements and new features like exponential operator.

ECMAScript 2017 (June 2017): Second yearly release with new features like string padding, async functions, shared memory, etc.

ECMAScript 2018 (June 2018): New features like asynchronous iteration, Promise.finally, rest/spread operators for object literals, etc.

ECMAScript 2019 (June 2019): New features and some changes in Array and Object prototypes and stability improvement in Array.sort.

ECMAScript 2020 (June 2020): New features that include a BigInt primitive for arbitrary-sized integers, new null coalescing syntax, etc.

Ecma Technical Committee 39 (TC39)

TC-39 is a group of people who are responsible for the standards. They have meetings every two months with member-appointed delegates and invited experts. You can check the minutes of those meetings here GitHub repository

You can also check the proposed features and their stages here GitHub repository.

With each ECMAScript release, there are few important points to note-

  1. New versions are always backward compatible except few occasional minor cleanups which are hardly noticeable.
  2. Old features aren’t removed or fixed. Instead, better versions of them are introduced. For example, let and const were introduced but var wasn't removed.

Keeping old stuff is important here. If a new version is created without any backward compatibility then a lot of work will be required to migrate all these billions of projects and sites. This would wreak havoc and break the entire internet.😁

I hope you found this history interesting.

Watch out for more articles coming in this Javascript Basics series.

Thanks for reading!

No Comments Yet