Javascript is everywhere!.

It's in our browser 🌐. It's on the server ⚙️. It's even in our smart fridge🧊 (because, why not?).

But how did we get here? 🤔

Believe it or not, Brendan Eich created Javascript in just 10 days during the '90s.

Yes, it was chaotic. Yes, it was rushed, as if there was no tomorrow. 🏃

And that glorious messiness is exactly why Javascript is still thriving today.

If you're new to the language (or even if you've been using it for years), understanding Javascript's tangled origin story helps you make sense of the quirks, hacks, and genius that define it today.

Let's dive in. 🏊‍♂️.

🛠️ Origin Story: Built in a Rush

In 1995, Netscape (the browser giant of the 90s) wanted a scripting tool fast, for web interactivity.

They handed the task to Brendan Eich, who had to create something that looked like Java and worked like Scheme. 🧠

With zero time and a lot of pressure, he built the first version of Javascript in 10 days. 😲, a prototype that would forever change programming.

It was initially called Mocha, then Live Script, and finally — thanks to a marketing stunt — Javascript (despite having nothing to do with Java 😅).

🧨 Javascript's Early Days

Browser Wars: Microsoft vs Netscape ⚔️

After Javascript's launch, Microsoft answered with their version: JScript, built into Internet Explorer.

Suddenly, websites behaved differently depending on your browser, creating a compatibility mess.

Different browsers meant different behaviours — This drove developers up the wall. 🤯

🛡️ Need for Standardisation

These different behaviours drove calls for consistency. Developers hit walls writing code that worked in all browsers. The demand for a unified spec intensified.

In 1997, to clean up the mess, the language was handed over to ECMA International, which created a formal standard called ECMAScript. 🧹

🧾 The ECMAScript Standard

ECMAScript was born. It is the official specification by ECMA International.

Just as ISO manages general technical and industrial standards, ECMA International handles the standard for Javascript through ECMAScript specifications.

You can think of it as the rulebook for writing clean, browser-friendly Javascript 📜.

By setting these standards, ECMAScript plays a crucial role in ensuring that all browsers speak the same language, making the web more consistent 🌐 and clearing the path for modern frameworks to thrive 🚀. This unification is a reassuring sign for developers, as it ensures their code will work across various browsers ✨.

The committee responsible for maintaining the ECMAScript standard is called TC39 🧑‍💼, which meets regularly to discuss various topics, including whether semicolons should be optional. (Yes, you read that right!) 🤔.

🔢 ECMAScript Versions Explained (ES3 to ESNext)

ECMAScript 3 or ES3 (1999): The Foundation 💥

Javascript received its first major facelift with ES3, introducing features such as try...catch, regular expressions, do-while loops, and improved string methods.

This is the first widely adopted version, laying the groundwork for Javascript to become more structured and browser-compatible.

The next major update came as ES5 in 2009.

So... what happened to ES4? 🤔

It got scrapped. Back in the mid-2000s, some very smart (and very opinionated) people were working on ECMAScript 4 (ES4). They wanted to add significant, complicated features to Javascript, like classes 🏫, static typing 🧑‍💻 and a bunch of other advanced features, and it broke the web in the planning process. The team agreed to pause ES4 and instead work on a simpler update called ES5.

Later, they incorporated some good ideas from ES4, refined them, and introduced them in ES6 (2015).

ECMAScript 5 or ES5 (2009): Cleanup Release 🐞

This version fixed bugs and added helpful features without breaking the web.

They introduced stricter syntax ("use strict"), JSON support (JSON.parse() and JSON.stringify()), and new object methods (Object.defineProperty() and Object.create()).

ES5 made JS safer, cleaner, and more predictable. Most modern browsers standardised around it.

ECMAScript 6 or ES6 or ES2015 (2015): The Big Bang 🚀

ES6 is a game-changer. This version brought Javascript into the modern age.

They included some powerful features, such as let and const, arrow functions, Classes, Modules, template literals, promises, default parameters, and destructuring, among others.

It reshaped and modernised Javascript into a cleaner, more powerful language.

Modern ECMAScript (ES2016 → ESNext): Fast Annual Updates🧑‍💻

Since ES6, new versions drop every year - ES2016, ES2017, all the way to ES2024 (and beyond) - with progressive updates, keeping Javascript flexible, modular and feature-rich without massive version Jumps.

The updates are increasingly focused on developer-friendly, boosting performance and code readability.

Well, "ESNext" refers to the next version of ECMAScript that the TC39 committee is still building and polishing 🔧. Once they finish the work ✅, they'll give it a proper name, like ES15 or ES2024 🏷️.

🔀 Why Javascript's Messy History Matters

Javascript is backwards compatible 🔙

One of the most unique (and sometimes painful) features of Javascript is that code written in the 1990s still works today. That's because Javascript has always prioritised backwards compatibility, a rarity in the world of programming.

Legacy code might make you cringe 😬, but it works, and understanding it can also help you debug modern apps.

Javascript Grows Organically

Javascript didn't start perfect — it grew and evolved based on what developers actually built in the wild. 💻

When devs created some wild hacks 🤯, ECMAScript looked at them and said, "Hmm... should we make that official?" 🤔

That's how many features made their way into the language — because real developers needed them, and the specification eventually caught up.

Embracing the Mess

Understanding why Javascript is "weird" makes you a better problem-solver 🔥.

It helps you handle quirks like this binding 🧠, async spaghetti 🍝, and browser inconsistencies 🤹.

Instead of scrapping everything and starting over, Javascript has evolved on top of its past — like a very determined crab building a skyscraper out of seashells. 🦀

💡 Is It a Scripting Language or Programming Language?

Good question. Originally, Javascript, seen as a "scripting" language — something to sprinkle on top of your HTML. Quick and dirty.

But those days are long gone.

Javascript now has:

• Modules

• Classes

• Asynchronous capabilities

• Tooling, bundlers, and full frameworks

So yes, it started as a scripting language. However, today, Javascript is a full-fledged programming language.

📘 How to Stay Updated

• Watch the TC39 GitHub proposals repository.

• Explore release notes at ECMA-262

• Try out new features using tools like Babel or TypeScript