The History of JavaScript

#javascript #webdev #programming #web3

On Christmas Day 1990, Sir Tim Berners-Lee introduced the world to the first web browser he had created in Switzerland on the NeXT computer system and around the same time, he also created the first web server.

In this article, we'll walk back in time to see how JavaScript evolved from a simple scripting language famously built in ten days to a technology that touches nearly every human being on the globe.

The story begins in December of 1991, when Al Gore invented the internet. What he actually did was introduce the Gore bill, which provided funding for the first mainstream browser mosaic, which was developed by Marc Andreessen and Eric Bina at the University of Illinois.

In January 1993, it was published for UNIX systems, with Macintosh and Windows ports following later that year.

Mosaic was the first web browser to introduce the Internet to the masses, but there is no JavaScript yet, only the DOM or document object model, which was not even close to being standardised.

After graduating in 1993, Andreessen moved to California to co-found Netscape, and within a few years, the Netscape Navigator would hold over 80% of the browser market share.
Andreessen noticed about this time that browsers needed to become more dynamic, and that web designers required some sort of glue language to make their webpages more interactive.

The super trendy Java programming language from Sun Microsystems would be the first thing they'd turn to, but they quickly decided that idea sucked, so Plan B was to hire this guy named Brendan Eich, whose job it was to put the scheme programming language in the browser while maintaining a syntax that still resembled Java.

Just ten days later, the first version of JavaScript was born, but it wasn't called JavaScript yet; it was mocha.
Syntactically, it was a curly bracket language like Java or C, but under the hood, it already contained many of the features that we know and love in modern JavaScript, such as first-class functions, dynamic typing, and prototypal inheritance, which was inspired by Sun Microsystems' self programming language.

Writing a perfect programming language in ten days is practically impossible, and Brendan Eich was well aware of this. Instead of writing a highly specialised language designed only for browsers from the 1990s, he wrote a flexible multi-paradigm language that developers could use to apply their own language patterns to, but there was still a very good chance that the language would fail, and there was no way he could have predicted the extremes developers would experience.

Mocha was renamed to live script by September 1995, and it was included in the initial beta releases of Netscape Navigator 2.0. However, only a few months later, in December, they decided to change the name to JavaScript because it sounded more hip and trendy than the hottest programming language of the time.

When Javascript first came out, it had a negative impact on user experience, mostly through the use of intrusive pop-up windows. During this time, a firm that was growing rapidly was introducing their own browser, called Internet Explorer.

In 1996, we have two nearly identical languages, javascript and jscript, as a result of Microsoft reverse engineering JavaScript and calling it jscript.

People realised that JavaScript would need to be standardised due to the internet's rapid expansion, so Netscape approached the European Computer Manufacturers Association (ECMA), which has been a neutral party since 1961 for setting standards in the IT industry.

By June 1997, we had the first version of ECMA script, and this provided browser vendors and server-side applications with a consistent spec or set of guidelines for implementing JavaScript.

At the same time that everyone was preparing for the end of the world, 1999 was one of the most interesting years in the history of technology.

We received ECMAScript version 3 just before y2k and the eventual stock market crisis.
However, things are about to turn worse, and we won't see another version of ECMAScript published for another 10 years. It included features like better error handling and the string equality operator to make equality comparisons a little less strange. However, the internet was here to stay and at this point we have a solid standard for JavaScript but the company behind this push Netscape was acquired by AOL a year prior. Just three months later, in March 2000, the tech bubble started to burst. The Nasdaq lost over a trillion dollars in value in that month alone, and high-profile companies started to fold but the internet was here to stay.

Microsoft Internet Explorer devoured the browser market share, and Microsoft didn't care about following the rules specification. In the early 2000s, Explorer owned at least 80% of the browser market share.
Microsoft basically went off and did its own thing, implementing its own JavaScript extensions. This resulted in fragmentation, which we still have to deal with today when supporting these legacy versions of Internet Explorer, but it also resulted in some very revolutionary features, such as Ajax, which allowed JavaScript to be implemented asynchronously, which was a precursor to modern single page applications.

Now, in the early 2000s, work had begun on ECMA script version 4, which was moving in a direction that looks a lot more like modern-day typescript with features like optional type annotations, classes, interfaces, and a bunch of other features designed to use JavaScript at the enterprise scale, but one of the committee members was Douglas Crockford from Yahoo who had created JSON in 2003 and was very concerned that the ES for proposal was growing to be very large.

This led to two proposals running concurrently, one for version 3.1 and the other for version 3.1 was a much simpler version without significant language changes. The saga would continue until 2008, when ES 4 was finally abandoned for good, but it did in fact enter the market as a language called ActionScript ** created by **Adobe.

Developers in the mid 2000s were extremely frustrated trying to build web applications that ran on all browsers, but we saw a huge leap forward in 2006 with the release of jQuery. This is a library that deserves a lot more credit than it gets because it's one of the first JS libraries to have extremely well done documentation and it empowered developers to build cross-browser web applications.

The release of Google Chrome and the v8 engine on September 2, 2008, was another significant milestone. v8 engine fundamentally changed how javascript was generated and interpreted, making it an attractive alternative for high-performance applications on both the client and server sides of the application stack.

Less than a year later, in May 2009, Ryan Dahl would introduce nodejs, a server-side runtime for JavaScript built on top of v8 that included an event loop, a novel idea at the time that allowed you to write event-driven and non-blocking code. Because of those features, nodejs became known as a great solution for building real-time, scalable web applications, and it also allowed developers to build their entire web application from scratch.

ES 3.1 was chosen as the foundation for ES 5, which was eventually released in December 2009, exactly 10 years after the last official spec from a technical standpoint. This decision was made around the same time that the JavaScript authorities were finally getting their act together for the next version of ECMA script.
ES 5 has a few crucial characteristics. JSON, for instance, supports functional object and array methods, strictmode accessors, and many other features.

Moving forward to 2010, we begin to see JavaScript frameworks designed specifically for single page applications, the most popular of which were Backbone and Angularjs, both of which were released in October of 2010. Both of these frameworks attempted to solve a similar problem but did so in very different ways.

Backbone was lightweight and utilised an imperative programming approach to manage Dom changes, whereas Angularjs was more all-encompassing and used a declarative programming language.
The designer of backbone Jeremy Ashe is a JavaScript legend who also created CoffeeScript and Underscore.js. Speaking of CoffeeScript, it's a very important part of JavaScript history because it's the first language that really made transpiling go mainstream, dating all the way back to Brendon Ike's original vision in 1995 to create a programming language that was malleable and transpilers would become very important.

With the next version of JavaScript ES6 plenty of new features arrived in this version things like promises let and Const arrow functions spread syntax D structuring to name a few these new features were a huge leap forward for JavaScript developers but it's really difficult for developers to actually use them because they're not supported in many legacy browsers and that's why today we see widespread use of things like babel and typescript because they can target any flavor of Javascript going all the way back to ES 3 while developers can still write their code with modern features.

Another significant development in 2015 was the emergence of respond React js. It took some of the concepts of angularjs with declarative UI but improved them with unidirectional dataflow immutability and the use of the virtual DOM and it's truly been the framework that has solidified modern day declarative UI patterns but there are many other frameworks out there competing for the mind share of developers like angular view.

That gets us to the present 2022; the ECMA script committee is on a regular schedule of updating JavaScript, at this time, we have ES 2022, which has added some excellent new features to the language.

If there's one thing I've learnt over the years, it's to always bet on JavaScript. It's a language that has progressed steadily from its initial prototype and has a large and diverse community unlike any other programming language.