JavaScript History

HISTORY OF JavaScript

What is JavaScript?

                Javascript is a text-based programming language used both on the client-side and server-side that allows you to make web pages interactive. 

 

Who invented JS?

                JavaScript was created by Brendan Eich in may 1995 during his time at Netscape Communications. It was inspired by Java, Scheme and Self.

                Netscape, for a time, made the best browser in the world and enjoyed market dominance.

                

                In late 1995, when Microsoft cottoned-on to the competitive threat the Web posed, the Internet Explorer project was started in an all-out attempt to wrestle control of the emerging platform from Netscape.

                In so doing Microsoft became a mortal threat, compelling Netscape to respond. First, they started a standardization process to prevent Microsoft gaining control of the JavaScript language. 

            

                Second, they partnered with Sun to leverage their shared interest in breaking the Microsoft monopoly.

                Sun began development of Java in 1990 in an attempt to write a language for “smart appliances”. This approach floundered and in 1994, Sun regrouped and set sights on the Web as the delivery platform of choice.

                The idea was that major interactive parts of the client-side web were to be implemented in Java. JavaScript was supposed to be a glue language for those parts and to also make HTML slightly more interactive. Given its role of assisting Java, JavaScript had to look like Java. That ruled out existing solutions such as Perl, Python, TCL, and others.

Initially, JavaScript’s name changed several times:

• Its code name was Mocha.
• In the Netscape Navigator 2.0 betas (September 1995), it was called LiveScript.
• In Netscape Navigator 2.0 beta 3 (December 1995), it got its final name, JavaScript.     

Standardizing JavaScript :

There are two standards for JavaScript:

1. ECMA-262 is hosted by Ecma International. It is the primary standard.
2. ISO/IEC 16262 is hosted by the International Organization for Standardization (ISO) and the International Electrotechnical Commission (IEC). This is a secondary standard.

                The language described by these standards is called ECMAScript, not JavaScript. A different name was chosen because Sun (now Oracle) had a trademark for the latter name. The “ECMA” in “ECMAScript” comes from the organization that hosts the primary standard.

                The original name of that organization was ECMA, an acronym for European Computer Manufacturers Association. It was later changed to Ecma International (with “Ecma” being a proper name, not an acronym) because the organization’s activities had expanded beyond Europe. The initial all-caps acronym explains the spelling of ECMAScript.

In principle, JavaScript and ECMAScript mean the same thing. Sometimes the following distinction is made:

• The term JavaScript refers to the language and its implementations.
• The term ECMAScript refers to the language standard and language versions.
• Therefore, ECMAScript 6 is a version of the language (its 6th edition).

Timeline of ECMAScript versions :

• ECMAScript 1 (June 1997): First version of the standard.
• ECMAScript 2 (June 1998): Small update to keep ECMA-262 in sync with the ISO standard.
• ECMAScript 3 (December 1999): Adds many core features – “[…] regular expressions, better string handling, new control statements [do-while, switch], try/catch exception handling, […]”.
• ECMAScript 4 (abandoned in July 2008): Would have been a massive upgrade (with static typing, modules, namespaces, and more), but ended up being too ambitious and dividing the language’s stewards.
• ECMAScript 5 (December 2009): Brought minor improvements – a few standard library features and strict mode.
• ECMAScript 5.1 (June 2011): Another small update to keep Ecma and ISO standards in sync.
• ECMAScript 6 (June 2015): A large update that fulfilled many of the promises of ECMAScript 4. This version is the first one whose official name – ECMAScript 2015 – is based on the year of publication.
• ECMAScript 2016 (June 2016): First yearly release. The shorter release life cycle resulted in fewer new features compared to the large ES6.
• ECMAScript 2017 (June 2017). Second yearly release.
• Subsequent ECMAScript versions (ES2018, etc.) are always ratified in June.

 Evolving JavaScript: Don’t break the web 

                    One idea that occasionally comes up is to clean up JavaScript by removing old features and quirks. While the appeal of that idea is obvious, it has significant downsides.

                    Let’s assume we create a new version of JavaScript that is not backward compatible and fix all of its flaws. As a result, we’d encounter the following problems:

                    JavaScript engines become bloated: they need to support both the old and the new version. The same is true for tools such as IDEs and build tools.

                    Programmers need to know, and be continually conscious of, the differences between the versions.

                    You can either migrate all of an existing code base to the new version (which can be a lot of work). Or you can mix versions and refactoring becomes harder because you can’t move code between versions without changing it.

                    You somehow have to specify per piece of code – be it a file or code embedded in a web page – what version it is written in. Every conceivable solution has pros and cons. For example, strict mode is a slightly cleaner version of ES5. One of the reasons why it wasn’t as popular as it should have been: it was a hassle to opt in via a directive at the beginning of a file or a function.

                    So what is the solution? Can we have our cake and eat it? The approach that was chosen for ES6 is called “One JavaScript”:

                    New versions are always completely backward compatible (but there may occasionally be minor, hardly noticeable clean-ups).

                    Old features aren’t removed or fixed. Instead, better versions of them are introduced. One example is declaring variables via let – which is an improved version of var.

                    If aspects of the language are changed, it is done inside new syntactic constructs. That is, you opt in implicitly. For example, yield is only a keyword inside generators (which were introduced in ES6). And all code inside modules and classes (both introduced in ES6) is implicitly in strict mode.