javascript

History of JavaScript

Explore the complete history of JavaScript — from its creation in 10 days in 1995 to the powerhouse language it is today. Learn about ECMAScript versions, key milestones, and how JS evolved.

13 min read 11 sections Tutorial

On This Page

1The Origins of JavaScript
2Birth of JavaScript — 1995
3The Browser Wars — 1996–1999
4ECMAScript Versions
5Key Milestones
6How JavaScript Code Evolved
7People Who Shaped JavaScript
8Why JavaScript Has Quirks
930-Year Timeline at a Glance
10Test Your Knowledge
11Key Takeaways

The Origins of JavaScript

History of JavaScript

JavaScript's story is one of the most remarkable in software history — a language born in just **10 days**, shaped by necessity, controversy, and community, and now the most widely used programming language on the planet. Understanding where JavaScript came from helps explain its quirks, design decisions, and why it works the way it does today.

Did You Know?

JavaScript was created in 10 days in May 1995. Despite its rushed origin, it has become the backbone of the modern web. No other language runs natively in every browser on Earth.

🎂

Born in 1995

Created at Netscape by Brendan Eich. Originally called Mocha, then LiveScript, then JavaScript.

📜

Standardized in 1997

Submitted to ECMA International. The standard is called ECMAScript — the official name of the language.

🌐

Web Revolution (2005)

Ajax & Google Maps proved JS could build real apps, not just add sparkle to pages.

🚀

Modern Era (2015+)

ES6 transformed the language. Today JS powers everything from browsers to servers to mobile apps.

Birth of JavaScript — 1995

In 1995, Netscape Navigator was the dominant web browser. The web was static — HTML pages with no interactivity. Netscape wanted a scripting language that non-programmers could use directly in HTML to make pages dynamic.

The 10-Day Sprint

Brendan Eich, a Netscape engineer, was given 10 days in May 1995 to create a scripting language for the browser. He took inspiration from three languages:

Scheme — functional programming & closures
Self — prototype-based object model
Java — syntax (for marketing reasons)

The result was a language with Java's look, Scheme's soul, and Self's prototypes.

Mocha (May 1995)

The first internal prototype was codenamed Mocha. Eich created the initial version in 10 days. It was a working scripting language embedded in Netscape Navigator 2.0.

LiveScript (September 1995)

Before shipping, the name was changed to LiveScript to reflect its dynamic, "live" nature on web pages.

JavaScript (December 1995)

Just before release, Netscape struck a partnership deal with Sun Microsystems (creators of Java). The language was renamed JavaScript purely as a marketing move — Java was the hottest language at the time. This naming decision causes confusion to this day.

The Name is Misleading

JavaScript has no relation to Java. They have different syntax, different purposes, different runtime environments. The name was a marketing stunt. As Brendan Eich put it: 'Java is to JavaScript as car is to carpet.'

The Browser Wars — 1996–1999

Shortly after Netscape released JavaScript, Microsoft responded with their own version — **JScript** — shipped in Internet Explorer 3 in 1996. This kicked off the infamous Browser Wars.

Netscape — JavaScript

Microsoft — JScript

Netscape — JavaScript

- Created by Brendan Eich
- Shipped in Navigator 2.0 (1995)
- Based on ECMAScript standard
- Drove ECMA standardization
- Used by ~80% of users (1996)

Microsoft — JScript

- Microsoft's reverse-engineered clone
- Shipped in IE 3.0 (1996)
- Similar but subtly different
- Proprietary extensions (ActiveX etc.)
- Used in Windows-bundled IE

- Created by Brendan Eich
- Shipped in Navigator 2.0 (1995)
- Based on ECMAScript standard
- Drove ECMA standardization
- Used by ~80% of users (1996)

- Microsoft's reverse-engineered clone
- Shipped in IE 3.0 (1996)
- Similar but subtly different
- Proprietary extensions (ActiveX etc.)
- Used in Windows-bundled IE

The two incompatible implementations of JavaScript caused enormous pain for web developers. Code that worked in Netscape often broke in IE and vice versa. This era is why `if (document.getElementById)` checks became common — developers had to detect which browser they were running in.

Why ECMAScript Exists

To prevent the fragmentation from getting worse, Netscape submitted JavaScript to ECMA International (a standards body) in November 1996. The resulting standard, published in June 1997, was named ECMAScript (ES) — because Sun owned the trademark on "JavaScript".

All modern browsers implement ECMAScript. When you see ES5, ES6, ES2020 — that's ECMAScript version numbers.

ECMAScript Versions

ECMAScript Versions — The Evolution

ECMAScript has gone through many versions since 1997. Each version added features that shaped how JavaScript is written today.

Version	Year	Key Features Added
ES1	1997	First standard — basic language features
ES2	1998	Minor editorial changes to align with ISO standard
ES3	1999	Regular expressions, try/catch, do-while, string methods
ES4	Abandoned	Too ambitious — abandoned due to disagreements (typed arrays, classes)
ES5	2009	strict mode, JSON support, Array methods (forEach, map, filter), Object.create
ES6 / ES2015	2015	let/const, arrow functions, classes, modules, promises, template literals, destructuring, spread/rest, for...of
ES2016	2016	Array.includes(), ** exponentiation operator
ES2017	2017	async/await, Object.entries/values, String padding
ES2018	2018	Rest/spread for objects, async iteration, Promise.finally
ES2019	2019	Array.flat/flatMap, Object.fromEntries, optional catch binding
ES2020	2020	Nullish coalescing (??), optional chaining (?.), BigInt, Promise.allSettled
ES2021	2021	String.replaceAll, Promise.any, logical assignment (&&=, \|\|=, ??=)
ES2022	2022	Top-level await, class fields, Array.at(), Object.hasOwn
ES2023	2023	Array.findLast, Array.toSorted/toReversed (non-mutating methods)
ES2024	2024	Promise.withResolvers, Object.groupBy, RegExp /v flag

Why ES6 was the Game Changer

ES6 (2015) was the largest update in JavaScript history. It introduced classes, modules, arrow functions, promises, let/const, destructuring, and dozens more features. ES6 is considered the dividing line between "old JavaScript" and "Modern JavaScript". Most tutorials teach ES6+ syntax today.

Key Milestones

Key Milestones in JavaScript History

1995 — Born at Netscape

Brendan Eich created JavaScript in 10 days for the Netscape Navigator browser. Originally called Mocha, then LiveScript, finally JavaScript as a marketing move to ride Java's popularity.

1997 — ECMAScript Standard

JavaScript submitted to ECMA International for standardization. The standard is called ECMAScript (ES). This is why you'll see terms like ES5, ES6, ES2020 — they all refer to official JavaScript.

2001–2004 — Dark Ages

IE6 dominated with ~90% market share. Microsoft stopped developing IE after winning the browser war, stagnating web standards. Developers wrote browser-specific code using if (window.attachEvent) checks everywhere.

2005 — Ajax Revolution

Gmail and Google Maps launched using XMLHttpRequest — loading data without page reloads. Jesse James Garrett coined the term Ajax (Asynchronous JavaScript and XML). This proved JS could build real web applications.

2006 — jQuery Released

John Resig released jQuery, a library that solved cross-browser inconsistencies with a simple $() API. jQuery became the most widely used JavaScript library in history — still found on millions of sites today.

2008 — V8 Engine

Google released the V8 JavaScript engine with Chrome. V8 used JIT (Just-In-Time) compilation to run JavaScript dramatically faster than previous engines — 10–100x improvements in benchmarks.

2009 — Node.js

Ryan Dahl built Node.js using V8, allowing JavaScript to run on the server. JavaScript was no longer just a browser language — it became a full-stack language. npm (Node Package Manager) followed, enabling the largest package ecosystem in any language.

2010 — Framework Explosion

Backbone.js, Knockout.js, AngularJS all launched. The concept of Single Page Applications (SPAs) emerged — full web apps in JavaScript without page reloads.

2013 — React Released

Facebook open-sourced React — a component-based UI library using a virtual DOM. React introduced a fundamentally new way to build UIs and triggered the modern frontend era.

2015 — ES6 (Modern JavaScript)

ECMAScript 2015 was a massive update introducing let, const, arrow functions, classes, promises, modules, template literals, destructuring, and much more. This is the turning point to Modern JS. Annual releases began from this point.

2017 — async/await

ES2017 introduced async/await — syntactic sugar over Promises that made asynchronous code look synchronous. This dramatically simplified complex async operations.

2020 — Optional Chaining & Nullish Coalescing

ES2020 brought ?. (optional chaining) and ?? (nullish coalescing) — two features that eliminated massive amounts of defensive boilerplate code from JavaScript codebases.

2024+ — Everywhere

JavaScript now powers frontend apps (React, Vue, Angular), backend servers (Node, Deno, Bun), mobile apps (React Native), desktop apps (Electron), edge computing, IoT, game development, and AI/ML tooling.

How JavaScript Code Evolved

The syntax you write in JavaScript today is dramatically different from what was written in 1995–2009. Here's a side-by-side comparison showing the evolution:

✗ BadOld JS (ES5, pre-2015)

// Variables
var name = 'Alice';
var age = 25;

// Functions
function greet(name) {
  return 'Hello, ' + name + '!';
}

// Callbacks (async hell)
getUser(function(user) {
  getPosts(user.id, function(posts) {
    getComments(posts[0].id, function(comments) {
      console.log(comments);
    });
  });
});

// Classes (prototype-based)
function Person(name, age) {
  this.name = name;
  this.age = age;
}
Person.prototype.greet = function() {
  return 'Hi, I am ' + this.name;
};

✓ GoodModern JS (ES6+, 2015+)

// Variables
const name = 'Alice';
let age = 25;

// Arrow functions + template literals
const greet = (name) => `Hello, ${name}!`;

// async/await (clean async code)
async function loadData() {
  const user = await getUser();
  const posts = await getPosts(user.id);
  const comments = await getComments(posts[0].id);
  console.log(comments);
}

// Classes (clean syntax)
class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  greet() {
    return `Hi, I am ${this.name}`;
  }
}

javascriptES6+ Features Demo

1// Destructuring
2const person = { name: 'Alice', age: 25, city: 'London' };
3const { name, age } = person;
4console.log(name, age); // Alice 25
5
6// Spread operator
7const nums = [1, 2, 3];
8const moreNums = [...nums, 4, 5];
9console.log(moreNums); // [1, 2, 3, 4, 5]
10
11// Template literals
12const greeting = `Hello, ${name}! You are ${age} years old.`;
13console.log(greeting);
14
15// Arrow functions
16const double = x => x * 2;
17const doubled = [1, 2, 3].map(double);
18console.log(doubled); // [2, 4, 6]
19
20// Optional chaining (ES2020)
21const user = { profile: { avatar: 'photo.jpg' } };
22console.log(user?.profile?.avatar);  // 'photo.jpg'
23console.log(user?.settings?.theme); // undefined (no crash!)
24
25// Nullish coalescing (ES2020)
26const theme = user?.settings?.theme ?? 'dark';
27console.log(theme); // 'dark' (default)

People Who Shaped JavaScript

👨‍💻

Brendan Eich

Created JavaScript in 10 days at Netscape (1995). Later co-founded Mozilla and created Brave browser.

🔧

Ryan Dahl

Created Node.js in 2009 by embedding V8 in a server runtime. Made JS viable for backend development. Later created Deno.

⚛️

Jordan Walke

Facebook engineer who created React (2013). React's component model fundamentally changed how UIs are built.

📦

John Resig

Created jQuery (2006). Made cross-browser JavaScript accessible to millions of developers.

🔷

Anders Hejlsberg

Microsoft's lead architect who created TypeScript (2012) — typed JavaScript that compiles to JS.

🎯

TC39 Committee

The technical committee responsible for evolving ECMAScript. Made up of browser vendors, companies, and community representatives.

Why JavaScript Has Quirks

JavaScript's unusual behaviors (like `typeof null === 'object'`) are **historical artifacts** — bugs from the original 10-day implementation that could never be fixed because millions of websites already depended on them.

javascriptFamous JS Quirks

1// Quirk 1: typeof null (a 30-year-old bug)
2console.log(typeof null);        // 'object' (should be 'null')
3
4// Quirk 2: == vs === type coercion
5console.log(0 == false);         // true (type coercion)
6console.log(0 === false);        // false (strict, no coercion)
7console.log('' == false);        // true (!)
8console.log(null == undefined);  // true
9console.log(null === undefined); // false
10
11// Quirk 3: NaN is not equal to itself
12console.log(NaN === NaN);        // false (!)
13console.log(isNaN(NaN));         // true
14
15// Quirk 4: String + Number
16console.log('5' + 3);            // '53' (string concat!)
17console.log('5' - 3);            // 2 (math, - only works on numbers)
18
19// Quirk 5: Floating point
20console.log(0.1 + 0.2);          // 0.30000000000000004 (!)
21console.log(0.1 + 0.2 === 0.3); // false
22
23// These aren't 'wrong' — they're design decisions
24// from 1995 that can't be changed for backward compatibility

Always use === instead of ==

Because of type coercion, always use === (strict equality) instead of == in your code. === checks both value AND type. == performs automatic type conversion which leads to surprising results.

30-Year Timeline at a Glance

Year	Event	Impact
1995	JavaScript created (Netscape)	First scripting language for browsers
1996	JScript released (Microsoft)	Browser wars begin, compatibility nightmare
1997	ECMAScript 1 standardized	Official language standard created
1999	ES3 released	Regular expressions, try/catch — usable language
2001	IE6 dominates (90% market share)	Dark age — web standards stagnated for years
2005	Ajax popularized by Google Maps/Gmail	JS proven capable of real applications
2006	jQuery released	Cross-browser dev accessible to millions
2008	V8 engine & Chrome launched (Google)	10–100x performance improvement
2009	Node.js created (Ryan Dahl)	JS on the server — full-stack JavaScript
2009	ES5 released	strict mode, JSON, Array methods
2010	AngularJS, Backbone.js launch	SPA frameworks — frontend apps take off
2012	TypeScript released (Microsoft)	Typed JavaScript for large-scale apps
2013	React released (Facebook)	Component model revolutionizes frontend
2014	Vue.js released	Lightweight progressive framework
2015	ES6/ES2015 released	BIGGEST update: classes, modules, promises, let/const
2017	async/await (ES2017)	Clean async code — replaced callback hell
2019	Deno released (Ryan Dahl)	Modern Node.js alternative with TypeScript support
2020	Optional chaining, nullish coalescing	Massive boilerplate reduction
2021	Bun runtime announced	All-in-one JS runtime/bundler/package manager
2024+	JS powers AI tooling, edge computing	Used in every computing domain

Test Your Knowledge

Quick Check

Who created JavaScript and how long did it take?

Quick Check

What is the official name of the JavaScript standard?

Quick Check

Which ECMAScript version is considered the turning point to 'Modern JavaScript'?

Quick Check

What did Ryan Dahl create that allowed JavaScript to run on servers?

Quick Check

Why does `typeof null === 'object'` return true in JavaScript?

Key Takeaways

Key Takeaways from JavaScript History

Pro Tips

1JavaScript was created in 10 days — its quirks are historical artifacts, not intentional design.
2ECMAScript is the official standard. 'JavaScript' is just the popular name (and a trademark of Oracle, who acquired Sun).
3ES6 (2015) was the largest update — if you see a tutorial using `var` everywhere, it's teaching old JavaScript.
4Node.js (2009) was a paradigm shift — the same language now runs everywhere, from browser to server to mobile.
5The browser wars (1996–2006) are why we have cross-browser compatibility quirks. Modern browsers are much more consistent.
6Always use `===` over `==` to avoid type coercion surprises from JavaScript's early design.
7TypeScript (2012) adds types to JavaScript. It compiles to plain JS and doesn't change the runtime — the quirks still exist.
8JavaScript's greatest strength is backward compatibility — code written in 1999 still runs in 2024. This is also why quirks can never be removed.

What's Next?

Continue Your JavaScript Journey

📦

Variables & Data Types

Learn let, const, and the 8 data types: string, number, boolean, null, undefined, symbol, bigint, object.

➕

Operators

Arithmetic, comparison, logical, and assignment operators — the tools for all computations.

🔀

Control Flow

if/else, switch, ternary operator — making decisions in code.

🔁

Functions

Function declarations, arrow functions, parameters, return values — the building blocks of programs.

You now understand where JavaScript comes from!

Knowing the history of JavaScript helps you understand why the language is the way it is. The quirks make sense in context, and the modern features were introduced to solve real problems developers faced over 30 years.

Try it in the Javascript Compiler

Run and experiment with Javascript code right in your browser — no setup needed.

Open Javascript Compiler

Continue Learning

Previous Next