DEV Community

Cover image for History of JavaScript - How it came into the existence

Posted on • Originally published at


History of JavaScript - How it came into the existence

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!

Top comments (0)

The JavaScript Brief

1. Top 5 MERN STACK projects to improve your practical understanding

Boost your MERN Stack development skills by undertaking interesting beginner projects. These five engaging projects cover web applications and range from social media website applications to geo-social networking maps. Hone your understanding and apply modern techniques backed up by hands-on experience.

2. How To Optimize Your React App’s Performance

Learn the best optimizing techniques to make your React applications faster and more efficient. Focusing on the identification of performance bottlenecks and common pitfalls to avoid, these optimization strategies will keep your applications running smoothly even when faced with growing complexity.

3. A story of let, const, object mutation, and a bug in my code

In the pursuit of bug-free code, explore an incident involving a mix-up between const and let, making sure your custom code works effectively with third

party documentation. Discover best practices on program flow and learn about JavaScript's unpredictable aspects to ensure your core code is robust.