Ten days in May

In May 1995, Brendan Eich joined Netscape Communications and was given an unusual brief: build a programming language for the browser, and do it in two weeks. The competing pressures were specific. Sun Microsystems' Java was going into Netscape Navigator as the "serious" language for applets. Marketing wanted a lightweight scripting language that would feel approachable to designers - "Java's little brother." Eich had ten days.

The first prototype was called Mocha. By September it had been renamed LiveScript. In December 1995, in a co-marketing deal with Sun, it was renamed again to JavaScript - a name chosen to ride Java's hype, and one that has caused thirty years of confusion since.

I had to be done in ten days or something worse than JavaScript would have happened.- Brendan Eich, on the design constraints

The language Eich shipped was a hybrid: C-family syntax (because that was familiar), Scheme-influenced first-class functions and closures (because Eich loved Scheme), and a Self-inspired prototype-based object model (because classical inheritance felt heavy). Most of the things that make JavaScript distinctive - closures, prototypes, dynamic typing - were already there in the first release.

The browser wars

Microsoft saw JavaScript in Netscape and reverse-engineered their own version, calling it JScript, for Internet Explorer 3 in August 1996. The two implementations diverged immediately - in subtle behaviour, in standard library coverage, in which APIs they exposed. The result was an era developers still talk about with grimaces: writing the same feature twice, branching on browser, fighting compatibility bugs that took an afternoon to track down.

To stop the divergence, Netscape submitted JavaScript to Ecma International for standardization in 1996. The standard was named ECMAScript (Oracle owned the JavaScript trademark by then, so the standards body had to pick something else). The first edition shipped in June 1997. Editions 2 and 3 followed by 1999.

Then ECMAScript 4 - an ambitious version that would have added classes, modules, and a static type system - collapsed under political and technical disagreement. The version after that was renamed ECMAScript 3.1 and eventually shipped as ES5 in 2009. The language stood still for almost a decade.

The quiet decade

Between 1999 and 2009, the JavaScript language barely changed. What changed instead was what people built with it. The arrival of XMLHttpRequest (Microsoft, 1999) made it possible for a page to talk to a server without reloading. Gmail (2004) and Google Maps (2005) showed what that could feel like in practice. The acronym AJAX got coined in 2005 to describe the pattern.

Libraries grew up to make the cross-browser pain bearable. jQuery (2006) became the de facto standard - by some measures, the most-deployed JavaScript library in history. Tooling started to matter; bundlers, minifiers, and the first source-map experiments appeared. The language still looked like 1999, but the engineering practices around it had moved decades.

Node and the server

In May 2009, Ryan Dahl announced Node.js at JSConf EU. The premise: take Google's V8 JavaScript engine (then about a year old, shipped with Chrome) and graft it onto a non-blocking I/O runtime. The result was a JavaScript that ran on servers, with access to the filesystem, sockets, and child processes - and that handled concurrent connections through an event loop rather than threads.

Node.js arrived at exactly the right moment. The same year, npm launched as the package manager. Within two years, the registry was the fastest-growing software ecosystem on the planet, and "JavaScript everywhere" stopped being a slogan and started being an architectural choice.

The framework era

The 2010s belonged to frameworks. AngularJS (2010, Google) introduced two-way binding to the mainstream. React (2013, Facebook) introduced the component model and a virtual DOM, an approach that won so completely that every framework since has borrowed from it. Vue (2014, Evan You) split the difference. Svelte (2016, Rich Harris) bet on compilation instead of runtime.

In parallel, the language itself was finally moving again. ES2015 (also called ES6) landed in June 2015 with a huge batch of improvements: let/const, arrow functions, template literals, destructuring, classes, modules, promises, and more. After a decade of stagnation, TC39 committed to yearly releases. Each year since has added small, useful pieces: async/await (2017), spread/rest (2018), optional chaining (2020), top-level await (2022), and a steady incremental drip.

Tooling kept pace. TypeScript (2012, Microsoft) added a static type system. webpack (2012) became the dominant bundler, then in 2020 esbuild showed up with a 100x speedup and started rearranging the field. Vite (2020) packaged native ESM development on top.

The modern stretch

By 2020 a quiet consensus had set in. New frontend projects shipped TypeScript on Vite by default. Backend JavaScript was either Node (the safe choice) or one of the new runtimes - Deno (2018, from Ryan Dahl again, "if I could redesign Node") or Bun (2022, focused on speed). Edge runtimes - Cloudflare Workers, Vercel Edge, Netlify Edge - made it normal to run JavaScript across hundreds of points of presence rather than in one data center.

The framework wars softened. By 2026, the answer to "which framework should I use?" was less religious than ten years earlier. Angular, React, Vue, and Svelte all ship on roughly the same toolchain; what differs is the component model and the team's hiring pool.

Where it is now

  • 1995 Brendan Eich writes the first prototype in ten days. Renamed JavaScript by December.
  • 1996 Microsoft ships JScript. Browser wars begin.
  • 1997 ECMAScript 1 standardized.
  • 1999 XMLHttpRequest ships. The web stops being just documents.
  • 2005 AJAX named. Gmail and Google Maps prove it.
  • 2006 jQuery released.
  • 2008 V8 launches with Chrome.
  • 2009 Node.js released; npm follows. ES5 ratified.
  • 2010 AngularJS released.
  • 2012 TypeScript released.
  • 2013 React released.
  • 2014 Vue released.
  • 2015 ES2015 (ES6) ratified - classes, modules, promises, arrow functions, let/const.
  • 2016 Svelte released.
  • 2017 async/await standardized in ES2017.
  • 2018 Deno announced by Ryan Dahl.
  • 2020 esbuild, Vite, Cloudflare Workers reshape tooling.
  • 2022 Bun released. Top-level await in ES2022.
  • 2026 JavaScript runs in every browser, on every major server runtime, on the edge, and inside AI agent frameworks.

The long arc is one of a language that should not have lasted ten years lasting thirty - because it owned the browser and the browser ate the world. Every other language that wants to reach an end user through a web page still has to come through JavaScript (or through WebAssembly, which JavaScript still supervises).

For what the language looks like in daily use now, read What is JavaScript? For how the typed layer on top works, read What is TypeScript?

References