From Ten Days to Everywhere: The Improbable History of JavaScript

Christmas Day 1990. The world sees its first web browser, developed by Sir Tim Berners-Lee in Switzerland on a NeXT computer. And if that weren’t enough, the same man built the first web server around the same time.

There was just one small problem: nobody knew what the internet was yet.

That’s where this story begins — and it ends with a programming language that now affects almost every human being on the planet.

Before the Language

Our timeline really starts in December 1991, when Al Gore — as he famously put it — “took the initiative in creating the internet.” What he actually did was introduce the Gore Bill, which provided funding for the first mainstream browser: Mosaic. Developed by Marc Andreessen and Eric Bina at the University of Illinois, it was released for Unix systems in January 1993, with ports for Macintosh and Windows later that year.

Mosaic was the first browser to bring the internet to the mainstream. But there was no JavaScript. Just the DOM — the Document Object Model — which wasn’t even close to being standardised yet.

In 1993, Andreessen graduated and moved to California to co-found Netscape. Within a couple of years, Netscape Navigator controlled around 80% of the browser market.

And that’s when the trouble started.

Ten Days in May

Andreessen realised browsers needed to become more dynamic. Web designers needed some kind of glue language to make pages interactive. Naturally, the first thing they turned to was Java, the trendy language from Sun Microsystems. They quickly decided that idea sucked.

Plan B: recruit a guy named Brendan Eich. His job was to put the Scheme programming language in the browser while keeping a syntax that resembled Java. And he needed it done by yesterday.

Ten days later, the first version of JavaScript was born. It wasn’t called JavaScript. It was called Mocha.

Syntactically it was a curly-bracket language like Java or C. But under the hood it already contained many features we know today: first-class functions, dynamic typing, and prototypal inheritance — inspired by the Self programming language, also developed by Sun.

Writing a perfect language in ten days is basically impossible, and Eich knew it. So he didn’t write a highly specialised language designed only for browsers of the 90s. He wrote a flexible, multi-paradigm language developers could apply their own patterns to.

There was still a very good chance the language would fail. And there was no way he could have predicted the extremes developers would take it to over the next twenty years.

Any application that can be written in JavaScript will eventually be written in JavaScript.

But let’s not get ahead of ourselves. It wasn’t even called JavaScript yet.

The Naming, the Clone, and the Standard

By September 1995, Mocha had been renamed LiveScript and shipped in the first beta releases of Netscape Navigator 2.0. A few months later, in December, it became JavaScript — because that made it sound like the cool lightweight cousin of the hottest language of the day.

It started making an impact on user experience from day one, mostly with annoying pop-up windows.

Meanwhile, a company launching its own browser — Internet Explorer — reverse-engineered JavaScript. Their legal team, or rather marketing team, gave it the name JScript. So by 1996 there were two almost identical languages: JavaScript and JScript.

With the internet growing rapidly, people realised standardisation was needed. Netscape turned to the European Computer Manufacturers Association — ECMA — a neutral party since 1961. By June 1997 there was the first version of ECMA-262, or ECMAScript as it’s commonly known.

It gave browser vendors a consistent specification. The document was about 100 pages long, and it looks very similar to modern JavaScript — just missing things like try/catch exception handling, regular expressions, and the strict equality operator.

And that equality problem, incidentally, is one of Brendan Eich’s biggest regrets. Early web designers testing JavaScript thought it would be convenient if a number could equal a string. To make the language more accessible to non-programmers, they implemented a lenient abstract equality operator. It would take years to fix.

Y2K and the Ten-Year Silence

Fast forward to December 1999 — one of the most interesting years in tech history. The dot-com bubble was inflating, and everyone was preparing for the world to end: the Year 2000 problem, described as the most complex and expensive problem mankind had ever faced.

Luckily, right before Y2K and the eventual stock market crash, we got ECMAScript 3. It brought better error handling, and crucially, the strict equality operator to make comparisons a little less weird.

JavaScript was evolving nicely. And then things went south. No new version of ECMAScript would be published for another ten years.

Three months later, in March 2000, the tech bubble burst. The Nasdaq lost over a trillion dollars in value in a single month. High-profile companies folded. But the internet was here to stay.

Netscape had been acquired by AOL a year earlier, and its browser market share was being devoured by Microsoft. Internet Explorer controlled at least 80% of the market, and Microsoft didn’t particularly care about playing by the spec. It implemented its own extensions, creating fragmentation that developers are still dealing with today.

But that same period produced something revolutionary: Ajax, which allowed JavaScript to be used asynchronously — the precursor to modern single-page applications.

The Dark Ages and the War Over ES4

In the early 2000s, work began on ECMAScript 4, and it was heading in a direction that looks a lot like modern TypeScript — optional type annotations, classes, interfaces, features designed for enterprise-scale JavaScript.

One committee member, Douglas Crockford of Yahoo, was deeply concerned. He had created JSON in 2003, and he thought ES4 was becoming bloated and out of control. Microsoft agreed and refused to participate.

The result was two competing proposals running simultaneously: ES3.1, a simpler version without major language changes, and ES4. The saga continued until 2008, when ES4 was scrapped for good.

But it did find its way into the market as ActionScript, the scripting language behind Flash. And we all know what happened to Flash.

The early to mid-2000s were the dark ages for JavaScript. But a renaissance was coming.

jQuery, Chrome, and Node

Developers in the mid-2000s were frustrated trying to build applications that ran across all browsers. Then in 2006 came jQuery — a library that deserves far more credit than it gets. It had extremely well-written documentation and empowered developers to build complex, interactive applications that worked reliably across browsers.

jQuery was a big deal. But 2008 was bigger.

On September 2nd, 2008, Google released Chrome and the V8 engine together. V8 changed how JavaScript was compiled and interpreted, making it viable for high-performance applications — both in the browser and on the server.

Less than a year later, in May 2009, Ryan Dahl introduced Node.js: a server-side runtime built on V8, with an event loop that was a unique concept at the time. It allowed event-driven, non-blocking code, and made Node.js a great fit for real-time web applications that scale. It also made it possible to build an entire web stack with a single language — the “JavaScript everywhere” paradigm.

Around the same time, the standards authorities finally got their act together in Oslo, Norway, taking ES3.1 as the starting point for ES5. It was released in December 2009 — exactly ten years after the previous spec. It brought JSON support, functional array and object methods, strict mode, and accessors.

Single-Page Applications and the Framework Wars

In 2010, frameworks designed specifically for single-page applications arrived. Two of the most popular were Backbone and AngularJS, both released in October.

They solved a similar problem in very different ways. Backbone was lightweight and handled DOM updates imperatively. AngularJS was more all-inclusive and declarative. Backbone’s creator, Jeremy Ashkenas, is a legend of the period — he also created CoffeeScript and Underscore.js.

CoffeeScript matters because it was the first language that really made transpiling mainstream. And transpiling goes all the way back to Eich’s original 1995 vision: a language malleable enough that others could build on top of it.

Transpilers became essential with ES6 — ES2015 — which landed a huge set of features: promises, let and const, arrow functions, spread syntax, destructuring. These were a leap forward, but difficult to use because legacy browsers didn’t support them. That’s why Babel and TypeScript became so prolific — they can target any flavour of JavaScript, all the way back to ES3, while developers write modern code.

2015 also saw the rise of React, which took AngularJS’s declarative UI concepts and improved them with unidirectional data flow, immutability, and the virtual DOM. React solidified the modern declarative UI pattern. Competing frameworks followed: Angular, Vue, Svelte, and many others.

And with heavyweight apps came heavyweight tooling: Rollup and webpack for bundling, TypeScript and Flow for types, Immutable.js and RxJS for functional patterns. That’s just the tip of the iceberg of modern ecosystem complexity.

Where We Are Now

Today, TC39 — the committee in charge of ECMAScript — is on a regular schedule of annual updates. Each year brings new features, not flashy but practical.

A far more interesting development is WebAssembly: a binary format that low-level languages like C++ can compile to, delivering high-performance applications to the web. It’s not a replacement for JavaScript, but it represents a whole new way to build web applications.

But if there’s one thing the last thirty years have taught us, it’s to always bet on JavaScript. It’s a language that has consistently evolved from its very first prototype, and it has a massive, diverse community unlike any other programming language.

It was written in ten days. It has been rewritten, standardised, fragmented, rescued, and reinvented ever since. And it is still running — on servers, in browsers, on phones, in IDEs, at the edge of networks, and in spacecraft dashboards.

Not bad for a glue language nobody asked for.