📜 JavaScript History and Evolution

The Birth of JavaScript

In May 1995, Brendan Eich was hired by Netscape and given a now-legendary assignment: produce a scripting language for the Netscape Navigator browser — in about ten days. The result was first called Mocha, shipped briefly as LiveScript, and finally renamed JavaScript. That last change was a pure marketing move to ride the hype around Sun's Java; the two languages are largely unrelated, which is why "Java is to JavaScript as ham is to hamster" became a running joke.

The goal was specific: make web pages dynamic and interactive. Before JavaScript, a page was a static document — whatever the server sent is what you saw until you clicked a link to fetch a whole new page.

Standardization Through ECMAScript

JavaScript's early success created a problem: Microsoft shipped its own near-clone (JScript) in Internet Explorer, and browsers began to diverge. In 1996 Netscape submitted the language to Ecma International for standardization, producing a specification named ECMAScript (standard ECMA-262).

It helps to keep the vocabulary straight: ECMAScript is the specification — the rulebook — and JavaScript is the most popular implementation of that rulebook. When people say "ES6" or "ES2015" they mean a particular edition of the spec. The name "JavaScript" is even trademarked (originally by Sun, now Oracle), which is part of why the standard uses the neutral term ECMAScript.

Two editions matter most as you learn:

• ES5 (2009) — added "use strict", native JSON support, and the array iteration methods (map, filter, reduce, forEach) that made functional-style code practical.
• ES6 / ES2015 — the largest single upgrade in the language's history (covered next).

Since 2015, TC39 (the committee that governs the spec) ships a new edition every year with whatever proposals have reached maturity, so "modern JavaScript" is a moving target rather than a fixed version.

The ES6 Turning Point

ES2015 (still commonly called ES6) is the dividing line between "old" and "modern" JavaScript. It arrived after a fraught, abandoned "ES4" effort, so it bundled years of pent-up demand into one release. The headline additions were:

Everything after ES6 has been incremental polish on this foundation: async/await (2017) made promises read like synchronous code, and optional chaining ?. plus nullish coalescing ?? (2020) removed whole categories of defensive boilerplate.

Modern Syntax in Practice

Here are the modern features you will use every single day, each shown next to the older style it replaces.

Arrow functions

// Traditional function expression
const addOld = function (a, b) {
  return a + b;
};

// Arrow function — implicit return for one expression
const add = (a, b) => a + b;

Template literals

const name = 'JavaScript';

// Old: string concatenation
const oldGreeting = 'Hello, ' + name + '!';

// Modern: interpolation with backticks
const greeting = `Hello, ${name}!`; // "Hello, JavaScript!"

Destructuring

// Array destructuring
const [first, second] = [1, 2];

// Object destructuring, with a default value
const { name = 'Anonymous', age } = { name: 'Alice', age: 25 };

Promises and async/await

Both snippets do the same thing — fetch JSON from an API and handle errors — but async/await reads top-to-bottom like ordinary code.

// Promise chaining (ES6)
fetch('https://api.example.com/data')
  .then((response) => response.json())
  .then((data) => console.log(data))
  .catch((error) => console.error(error));

// async / await (ES2017) — same behavior, flatter shape
async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error(error);
  }
}

Beyond the Browser

For its first 14 years, JavaScript lived only inside browsers. Then in 2009 Ryan Dahl paired Chrome's V8 engine with system-level APIs to create Node.js, letting JavaScript run on servers. That unlocked an explosion of reach:

Key milestones in that expansion:

• Node.js (2009) — JavaScript on the server, using the V8 engine.
• npm (2010) — the package registry that is now the largest software registry in the world.
• TypeScript (2012) — Microsoft's typed superset of JavaScript, now the default for large codebases.
• Deno (2018) and Bun (2022) — modern runtimes from a new generation, with built-in tooling and TypeScript support.

💡 The Swiss Army knife. JavaScript began with a single "blade" — form validation in the browser. Developers kept adding tools until it could power servers, phone apps, desktop programs like VS Code and Slack, and functions running at the network edge. Same language, an ever-growing toolset.

What Makes JavaScript Unusual

Three design choices from 1995 still shape how the language feels today.

Prototype-based objects

Unlike class-based languages such as Java, JavaScript objects can inherit directly from other objects through a prototype chain. ES6 class syntax is friendlier sugar over this same machinery — the prototypes are still there underneath.

class Person {
  constructor(name) {
    this.name = name;
  }
  greet() {
    return `Hello, my name is ${this.name}`;
  }
}

const alice = new Person('Alice');
console.log(alice.greet()); // "Hello, my name is Alice"

First-class functions

Functions are values. You can store them in variables, pass them as arguments, and return them from other functions — the foundation of callbacks, array methods, and event handlers.

function executeOperation(operation, a, b) {
  return operation(a, b);
}

const sum = executeOperation((a, b) => a + b, 5, 3); // 8

Dynamic typing

A variable can hold any type, and that type can change at runtime.

let value = 42;      // number
value = 'forty-two'; // string
value = true;        // boolean

Hands-on Exercise

var numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
var evenNumbers = [];

for (var i = 0; i < numbers.length; i++) {
  if (numbers[i] % 2 === 0) {
    evenNumbers.push(numbers[i]);
  }
}

var report = 'Found ' + evenNumbers.length + ' even numbers';
console.log(report, evenNumbers);

const numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
const evenNumbers = numbers.filter((n) => n % 2 === 0);

const report = `Found ${evenNumbers.length} even numbers`;
console.log(report, evenNumbers);
// Found 5 even numbers [2, 4, 6, 8, 10]

Summary & Quiz

📚 Further Reading

• MDN — A re-introduction to JavaScript
• TC39 — the ECMAScript specification
• You Don't Know JS (book series)

🚀 What's Next?

Now that you know what JavaScript is and how it evolved, the next lesson looks at where it actually runs — the execution environment, the engine, the call stack, and the event loop that make asynchronous code possible.