JavaScript's Story & Ecosystem

JavaScript was designed in ten days. That fact gets used as an insult, but it's really the setup for the most improbable success story in software: a language sketched in a week and a half now runs on more devices than any other in history. Knowing how that happened will make a dozen of the language's quirks make sense later — so here's the story.

Ten days in 1995

In 1995, Netscape — maker of the dominant web browser — wanted web pages to be more than static documents. They hired Brendan Eich and asked for a small scripting language for the browser. Under absurd deadline pressure, he designed and built the first version in ten days in May 1995.

The name came last, and it was pure marketing. The language was called Mocha, then LiveScript — and then, in December 1995, renamed JavaScript to ride the hype wave of Java, the hot language of the moment. Let's settle this forever: JavaScript is not Java. They're unrelated languages that share four syllables and some curly braces; the name was a co-marketing deal, not a family tree. (The classic line: Java is to JavaScript as ham is to hamster.)

Those ten days also mean some early design decisions were rushed — and because the web never breaks old pages, they're still in the language. You'll meet a few of them in this course, clearly flagged as ⚠️ traps. The language grew wildly better; the fossils stayed.

ECMAScript: the standard behind the language

By 1996, JavaScript needed a neutral referee — Microsoft had already shipped its own copy for Internet Explorer. Netscape took the language to the standards body Ecma International, and the official specification was named ECMAScript (a trademark compromise nobody loves).

The practical version: ECMAScript is the spec; JavaScript is the language you write. The spec is maintained by a committee called TC39 — engineers from browser makers, universities, and companies that live on the web. Anyone can propose a feature, and each proposal climbs a public ladder: Stage 0 (idea) → Stage 1 (worth exploring) → Stage 2 (draft) → Stage 3 (nearly done, engines start shipping it) → Stage 4 (finished — it's officially in the language). Every feature you'll learn in this course climbed that ladder.

The great leap: ES5 → ES6 → the yearly train

The language's history has one giant hinge:

• ES5 (2009) — a careful cleanup of the old language. The web ran on this for years.
• ES6, officially ES2015 — the big bang: a huge modernization (let, const, classes, template literals, arrow functions, promises, modules — most of what this course teaches arrived here).
• ES2016, ES2017, … ES2025 — after the ES6 mega-release, TC39 switched to a yearly release train: whatever proposals reach Stage 4 by spring ship in that year's edition. Small, steady upgrades instead of decade-long waits.

That's why you'll hear people say "modern JavaScript" — they mean ES2015 and everything after. It's the JavaScript this course teaches from day one; the older patterns appear only as history you'll recognize in old code.

// 1995-flavored JavaScript still runs today — the web never breaks old pages:
var oldGreeting = "Hello from the 90s";
console.log(oldGreeting);
 
// Modern (ES2015+) JavaScript, same engine, same page — you'll learn
// let and `${...}` templates properly in lessons 2.1 and 3.3:
let year = 2026;
console.log(`Hello from ${year}`);

→ Hello from the 90s, then Hello from 2026. Three decades of language history, one engine, zero complaints — backwards compatibility is the web's sacred rule.

One language, many runtimes

For its first 14 years, JavaScript lived only in browsers. Then in 2009, Node.js took Chrome's V8 engine out of the browser and put it on servers — suddenly the same language could write back ends, command-line tools, and build systems. Today there are several major runtimes (places JavaScript can run):

• Browsers — Chrome, Firefox, Safari, Edge; each ships its own engine (V8, SpiderMonkey, JavaScriptCore).
• Node.js — the server-side standard, powering APIs and tooling nearly everywhere.
• Deno and Bun — newer runtimes rethinking security, speed, and developer experience.

Same language, different superpowers attached. In this course you'll live mostly in the browser (Part IV is all about it) and meet Node properly in Part V.

Try it — the yearly train, live

Your browser's engine implements the modern spec. Run this to watch features from three different ECMAScript years work in one program — then try changing the values.

The community: npm, MDN, and looking things up like a pro

No language is just syntax — it's an ecosystem, and JavaScript's is the largest in software history:

• npm — the package registry: millions of free, reusable code packages, one command away (Part V teaches you to wield it).
• MDN Web Docs — the reference for JavaScript and the web platform. When you want the authoritative answer on any feature, search "mdn" plus the feature name. Bookmark it now.
• GitHub — where the ecosystem's code actually lives, including the TC39 proposals themselves.

Here's a professional habit to start today: nobody memorizes this language. Working developers look things up constantly — the skill is knowing where (MDN first) and what to ask. Fifteen seconds of "mdn string padStart" beats ten minutes of guessing, every time.

Next up: setting up your own workshop — the editor, the terminal, and the developer tools you'll live in for the rest of this course.