History of JavaScript – From 10 Days to the World's Most Used Language

The Birth of JavaScript – 10 Days in 1995

In early 1995, Netscape Communications Corporation — creators of the dominant web browser Netscape Navigator — decided they needed a scripting language that non-programmers could use to add dynamic behaviour to web pages. They hired Brendan Eich, a programmer who had been working on a Scheme-like language for the browser. In May 1995, under intense deadline pressure, Brendan Eich created the first version of JavaScript in just 10 days.

The speed of its creation explains many of JavaScript's well-known quirks and inconsistencies. Eich later said he knew the language was imperfect but had no choice — Netscape needed it shipped. Despite its rushed birth, the core ideas were sound: a lightweight, prototype-based scripting language for the browser.

Mocha → LiveScript → JavaScript

The language had three names in quick succession. It was first called Mocha internally at Netscape. Before its public release it was renamed LiveScript. Then, in a move that has caused confusion ever since, it was renamed JavaScript — largely as a marketing strategy to capitalise on the enormous buzz around Sun Microsystems' Java language, which was taking the tech world by storm in late 1995.

JavaScript shipped in Netscape Navigator 2.0 in September 1995. It was an immediate hit. Web developers could suddenly validate forms without a server round-trip, show and hide page elements, and create simple animations. The web felt alive for the first time.

// Early JavaScript (mid-1990s style) — form validation before submission
function validateForm() {
  var name = document.forms["myForm"]["username"].value;
  if (name === "" || name === null) {
    alert("Name must be filled out");
    return false;
  }
  return true;
}

The Browser Wars and JScript (1996–2001)

Microsoft recognised the threat JavaScript posed to its dominance and released its own implementation called JScript in Internet Explorer 3.0 in August 1996. JScript was mostly compatible with JavaScript but had deliberate differences — Microsoft wanted to lock developers into Internet Explorer rather than the open web.

This began the infamous browser wars. Developers had to write code that worked in both Netscape Navigator and Internet Explorer, leading to nightmarish compatibility issues. Many pages displayed badges saying "Best viewed in Netscape 4" or "Best viewed in Internet Explorer." This fragmentation nearly killed JavaScript as a serious development language.

ECMAScript Standardisation – ES1 to ES5 (1997–2009)

To prevent fragmentation, Netscape submitted JavaScript to ECMA International, a European standards body, in November 1996. The result was ECMAScript 1 (ES1), published in June 1997. The name "ECMAScript" was a compromise — Sun owned the "Java" trademark, so "JavaScript" could not be used as the official standard name.

ES3 (1999) was a major milestone, adding regular expressions, better string handling, try/catch, and more. It became the baseline that developers targeted for years. ES4 was proposed but never released due to political disagreements between stakeholders. ES5 (2009) finally added strict mode, JSON support, array methods like forEach and map, and property descriptors — a significant modernisation.

// ES5 (2009) — modern features for the time
"use strict"; // Enable strict mode

var numbers = [1, 2, 3, 4, 5];

// New array methods
var doubled = numbers.map(function (n) { return n * 2; });
var evens   = numbers.filter(function (n) { return n % 2 === 0; });
var sum     = numbers.reduce(function (acc, n) { return acc + n; }, 0);

console.log(doubled); // [2, 4, 6, 8, 10]
console.log(evens);   // [2, 4]
console.log(sum);     // 15

// JSON built into the language
var json = JSON.stringify({ name: "Alice", age: 28 });
console.log(json); // {"name":"Alice","age":28}

The jQuery Era and AJAX (2006–2012)

In 2006, John Resig released jQuery, a library that made cross-browser DOM manipulation simple with a clean, consistent API. jQuery became the most widely used JavaScript library in history — at its peak it was used on over 70% of all websites. For an entire generation of developers, "jQuery" and "JavaScript" were nearly synonymous.

The same era saw the rise of AJAX (Asynchronous JavaScript and XML), which allowed pages to fetch data from servers and update only part of the page without a full reload. Gmail (launched 2004) was the landmark demonstration of AJAX's power, proving that complex, desktop-like applications could live in the browser. Google Maps (2005) reinforced this. Suddenly, the web was a platform for applications, not just documents.

Node.js Changes Everything (2009)

In 2009, Ryan Dahl created Node.js — a runtime that took Google's V8 JavaScript engine out of the browser and let it run on servers. This was revolutionary. For the first time, JavaScript could be used to write back-end servers, command-line tools, build systems, and scripts outside the browser.

Node.js used a non-blocking, event-driven architecture that made it exceptionally good at handling many simultaneous connections — perfect for web APIs and real-time applications. The npm (Node Package Manager) ecosystem that grew around Node.js became the largest software registry in the world, with over 2 million packages today.

// Node.js (2009) — JavaScript on the server
const http = require("http");

const server = http.createServer((req, res) => {
  res.writeHead(200, { "Content-Type": "text/plain" });
  res.end("Hello from Node.js!\n");
});

server.listen(3000, () => {
  console.log("Server running at http://localhost:3000/");
});

The ES6 Revolution (2015)

ES6 (ECMAScript 2015) was the most significant update to JavaScript since its creation. It added a massive set of new features that made the language feel modern and expressive: let and const, arrow functions, classes, template literals, destructuring, default parameters, rest/spread operators, Promises, modules (import/export), and much more.

ES6 transformed how developers wrote JavaScript. Frameworks like React (2013), Angular (2010/2016), and Vue (2014) were able to flourish because ES6 gave them a solid, modern language foundation to build on.

// ES6 (2015) — before and after comparison

// Before ES6 (ES5)
var name = "Alice";
var greeting = "Hello, " + name + "!";
var square = function (x) { return x * x; };

// After ES6
const userName = "Alice";
const modernGreeting = `Hello, ${userName}!`; // template literal
const modernSquare = (x) => x * x;            // arrow function

// ES6 destructuring
const [first, second, ...rest] = [10, 20, 30, 40, 50];
console.log(first);  // 10
console.log(second); // 20
console.log(rest);   // [30, 40, 50]

// ES6 Promises
fetch("https://api.example.com/users")
  .then((response) => response.json())
  .then((data) => console.log(data))
  .catch((err) => console.error(err));

Modern JavaScript – 2016 to 2026

After ES2015, TC39 adopted a yearly release cadence. Each year a new version of ECMAScript ships with incremental but valuable additions. ES2017 introduced async/await, making asynchronous code far cleaner. ES2020 brought optional chaining (?.) and nullish coalescing (??). ES2022 added top-level await and class fields. The language steadily improves every year.

TypeScript, Microsoft's typed superset of JavaScript (released 2012, went mainstream ~2018), became enormously popular by adding static type checking. WebAssembly arrived in 2017, letting other languages run at near-native speed in the browser alongside JavaScript. In 2026, JavaScript remains the most widely used programming language in the world according to the Stack Overflow Developer Survey, used by over 65% of all developers.