JavaScript brief history and ECMAScript(ES6,ES7,ES8,ES9) features
JavaScript is most widely used now a days and most preferable language for development as front-end as well back-end(Nodejs),if we want to learn JavaScript we need to understand the basics of JavaScript and ECMAScript(ES), ECMAScript is an simple standard for JavaScript and adding new features to JavaScript,
ECMAScript is a subset of JavaScript. JavaScript is basically ECMAScript at its core but builds upon it. Languages such as ActionScript, JavaScript, JScript all use ECMAScript as its core. As a comparison, AS/JS/JScript are 3 different cars, but they all use the same engine… each of their exteriors is different though, and there have been several modifications done to each to make it unique.
The history is, Brendan Eich created Mocha which became LiveScript, and later JavaScript. Netscape presented JavaScript to Ecma International, which develops standards and it was renamed to ECMA-262 aka ECMAScript.
It’s important to note that Brendan Eich’s “JavaScript” is not the same JavaScript that is a dialect of ECMAScript. He built the core language which was renamed to ECMAScript, which differs from the JavaScript which browser-vendors implement nowadays, so below content for why javascript has created,evolved to read more about history.
Javascript birth:
It all happened in six months from May to December 1995. Netscape Communications Corporation had a strong presence in the young web. Its browser, Netscape Communicator, was gaining traction as a competitor to NCSA Mosaic, the first popular web browser. Netscape was founded by the very same people that took part in the development of Mosaic during the early 90s, and now, with money and independence, they had the necessary freedom to seek further ways to expand the web. And that is precisely what gave birth to JavaScript.
javascript History:
Marc Andreessen, founder of Netscape Communications and part of the ex-Mosaic team, had the vision that the web needed a way to become more dynamic. Animations, interaction and other forms of small automation should be part of the web of the future. So the web needed a small scripting language that could interact with the DOM (which was not set in stone as it is right now). But, and this was an important strategic call at the time, this scripting language should not be oriented to big-shot developers and people with experience in the software engineering side of things. Java was on the rise as well, and Java applets were to be a reality soon. So the scripting language for the web would need to cater to a different type of audience: designers. Indeed, the web was static. HTML was still young and simple enough for non-developers to pick up. So whatever was to be part of the browser to make the web more dynamic should be accessible to non-programmers. And so the idea of Mocha was born. Mocha was to become a scripting language for the web. Simple, dynamic, and accessible to non-developers, there`s an need to more Words about javaScript history but you can read further in blogs.
javascript implementations:
When Sun and Netscape closed the deal to change the name of Mocha/LiveScript to JavaScript a big question was raised: what would happen to alternative implementations? Indeed, although Netscape was quickly becoming the preferred browser at the time, Internet Explorer was also being developed by Microsoft. From the very first days, JavaScript made such a considerable difference in user experience that competing browsers had no choice but to come up with a working solution, a working implementation of JavaScript. At the moment (and for a very long time), web standards were not strong. So Microsoft implemented their own version of JavaScript, called JScript. Keeping “Java” off the name avoided possible trademark issues. However, JScript was different in more than just name. Slight differences in implementation, in particular with regards to certain DOM functions, caused ripples that would still be felt many years into the future. JavaScript wars were fought in more fronts than just names and timelines and many of its quirks are just the wounds of these wars. The first version of JScript was included with Internet Explorer 3.0, released in August 1996.
JAVA-LIKE SYNTAX
Although keeping the syntax close to Java was not the original idea behind JavaScript, marketing forces changed that. In retrospective, although a different syntax might have been more convenient for certain features, it is undeniable that a familiar syntax has helper JavaScript gain ground easily.
Compare this Java example:
public class Sample {
public static void main(String[] args) {
System.out.println("Hello world!");
try {
final MissileSilo silo = new MissileSilo("silo.weapons.mil");
silo.launchMissile(args[0]);
} catch(Exception e) {
System.out.println("Unexpected exception: " + e);
}
}
}To this (modern) JavaScript example:
console.log('Hello world');
try {
const silo = new MissileSilo('silo.weapons.mil');
silo.launchMissile(process.argv[0]);
} catch(e) {
console.log('Unexpected exception' + e);
}FUNCTIONS AS FIRST-CLASS OBJECTS
In JavaScript, functions are simply one more object type. They can be passed around just like any other element. They can be bound to variables, and, in later version of JavaScript, they can even be thrown as exceptions. This feature is a probable result of the strong influence Scheme had in JavaScript development.
var myFunction = function() {
console.log('hello');
}
otherFunction(myFunction);
myFunction.property = '1';By making function first-class objects, certain functional programming patterns are possible. For instance, later versions of JavaScript make use of certain functional patterns:
var a = [1, 2, 3];
a.forEach(function(e) {
console.log(e);
});These patterns have been exploited to great success by many libraries, such as underscore and immutable.js.
ECMAScript as Standard:
- ECMAScript: Sun (now Oracle) had a trademark on the name“JavaScript” (which led to Microsoft calling its JavaScript dialect “JScript”). Thus, when it came to standardizing the language, a different name had to be used. Instead, “ECMAScript” was chosen, because the corresponding standard is hosted by Ecma International (see below). In practice, the terms “ECMAScript” and “JavaScript” are interchangeable. If JavaScript means “ECMAScript as implemented by Mozilla and others” then the the former is a dialect of the latter. The term “ECMAScript” is also frequently used to denote language versions (such as ECMAScript 5).
- ECMA-262: The Ecma International (a standards organization) has created the ECMA-262 standard which is the official specification of the ECMAScript language.
- Ecma’s Technical Committee 39 (TC39): is the group of people (Brendan Eich and others) who develop the ECMA-262 standard.
- ECMAScript 3 (December 1999). This is the version of ECMAScript that most browsers support today. It introduced many features that have become an inherent part of the language:
regular expressions, better string handling, new control statements, try/catch exception handling, tighter definition of errors, formatting for numeric output and other enhancements.
- ECMAScript 4 (abandoned July 2008). ECMAScript 4 was developed as the next version of JavaScript, with a prototype written in ML. However, TC39 could not agree on its feature set. To prevent an impasse, the committee met at the end of July 2008 and came to an accord, summarized in four points
- Develop an incremental update of ECMAScript [which became ECMAScript 5.
- Develop a major new release, which was to be more modest than ECMAScript 4, but much larger in scope than the version after ECMAScript 3. This version has been code-named Harmony, due to the nature of the meeting in which it was conceived.
- Features from ECMAScript 4 that would be dropped: packages, namespaces, early binding.
- Other ideas were to be developed in consensus with all of TC39.
- Thus: The ECMAScript 4 developers agreed to make Harmony less radical than ECMAScript 4, the rest of TC39 agreed to keep moving things forward.
- ECMAScript 5 (December 2009). This version brings several enhancements to the standard library and even updated language semantics via a strict mode.
- currently browsers are supporting upto ES5 only.
ECMAScript 6(2015)
ES6 is an next-gen of JavaScript, the ecma technical committee 39 governs ecma specification, they discovered new features to the javascript.
ES6 can`t compile directly in browsers, so need an compiler from ES6 to ES5, for that compiling using babel, it produce the browser compatible javascript.
ES6 includes the following new features:
- arrows
- classes
- enhanced object literals
- template strings
- destructuring
- default + rest + spread
- let + const
- iterators + for..of
- generators
- unicode
- modules
- module loaders
- map + set + weakmap + weakset
- proxies
- symbols
- subclassable built-ins
- promises
- math + number + string + array + object APIs
- binary and octal literals
- reflect api
- tail calls
So above I have mentioned only list of features you can read it further,
ECMAScript 7(2016)
They decided to release a new version of ECMAScript every year starting in 2015. A yearly update means no more big releases like ES6.
ECMAScript 2016(ES7) introduced only two new features:
- Array.prototype.includes()
- Exponentiation operator
ECMAScript 8(2017)
At the TC39 meeting in January 2017, the last feature of ECMAScript 2017, “Shared memory and atomics” .
Major new features:
Minor new features:
- Object.values/Object.entries (Jordan Harband)
- String padding (Jordan Harband, Rick Waldron)
Object.getOwnPropertyDescriptors()(Jordan Harband, Andrea Giammarchi)- Trailing commas in function parameter lists and calls (Jeff Morrison)
ECMAScript 9(2018)
Major new features:
- Asynchronous Iteration (Domenic Denicola, Kevin Smith)
- Rest/Spread Properties (Sebastian Markbåge)
New regular expression features:
- RegExp named capture groups (Gorkem Yakin, Daniel Ehrenberg)
- RegExp Unicode Property Escapes (Mathias Bynens)
- RegExp Lookbehind Assertions (Gorkem Yakin, Nozomu Katō, Daniel Ehrenberg)
s(dotAll) flag for regular expressions (Mathias Bynens)
Other new features:
Promise.prototype.finally()(Jordan Harband)- Template Literal Revision (Tim Disney)
Summary:
- ECMAScript is the “standard for” of the JavaScript language.
EcmaScript is the “official” name for JavaScript. It was eventually abandoned and ES3.1 became ES5, which is the JavaScript version used in the “HTML5” world.
we just known JavaScript history,why JavaScript evolved,In over the years javascript has changed through ECMAScript,
The main understanding of ES5 and ES6 can explore your JavaScript knowledge as well ES7,ES8,ES9 .
Thanks for Reading!!.
My other posts are !.
