Want to know How to Build (and Scale) with Microservices? Download the Whitepaper from AppDynamics: Grab it now!
ES6 is a major update to the JavaScript language, the first since the adoption of ES5 in 2009. The features of ES6 are being incorporated into JavaScript engines around the web right now, and the changes are far reaching.
The new features in ES6 show how far JavaScript has come over the last two decades. Originally designed to define some functions and variables in order to build applications that could run in the browser, it continues to grow rapidly based on its flexibility and adaptability. ES6 contains new functionality that will move JavaScript to a whole new level of adoption and performance.
In this article, you will gain insight into the history of Javascript, how ECMA began to standardize its specification, the advantages of new ES6 features and some of the challenges the language faces in the future.
Evolution of JavaScript
ECMA, an industry association that began in the early 60s, is responsible for specifying the standards for JavaScript. Originally called the European Computer Manufacturers Association, it is now known as simply ECMA. JavaScript began life as a project named Mocha, which was created by Brendan Eich, who also co-founded the Mozilla Foundation. Mocha later became LiveScript and ultimately evolved into JavaScript.
JavaScript was a tremendous success as a scripting language for web pages on client programs. Netscape and Sun Microsystems released it officially in late 1995. A few months later, version 2.0 of Netscape Navigator came out on the market, including full JavaScript support. Microsoft shortly released their own version, avoiding trademark problems by calling it JScript, and bundled that into version 3.0 of Internet Explorer in the summer of 1996.
In late 1996, Netscape submitted JavaScript to ECMA International to set standardization specifications. ECMA-262, the first edition of the specification, was adopted in June 1997. Due to disagreements about standardization between Microsoft and Netscape, ECMA called their standard version of the language “ECMAScript.”
Six Major Releases of ECMA-262
Since then, there have been five more major releases of ECMA-262.
- Second edition. The second edition in June 1998 consisted of mostly editorial changes.
- Third edition. The third edition came out in December 1999, adding features such as regular expressions and formats for numeric output.
- Fourth edition. The fourth edition was abandoned due to differences of opinion on the complexity of the language.
- Fifth edition. Version five was released in December 2009. It added “strict mode,” which gave the specification better error checking. It also added support for JavaScript Object Notation (JSON) and other features.
- Sixth edition. The sixth edition was approved by the summer of 2015. Commonly called ES6, the official name is ECMAScript 2015. Future releases will follow this format: “ECMAScript” followed by the release year. Hence, the next version will be ECMAScript 2016, and that pattern will continue.
The sixth edition adds essential syntax for creating complex applications. Other new components include binary data, generators and generator expressions similar to the Python language, error functions, proxies, for/or loops and collections.
The next edition is still at the beginning of its development. It is scheduled to include new features such as operator overloading, promises/concurrency, pattern matching and more.
Limitations of ES6
While ECMA members say ES6 is an effort to bring a simpler syntax back to JavaScript, there are still several challenges facing the language:
- Difficult for outsiders to suggest changes. Some programming experts believe that the process of influencing changes in the standards is too complicated. Rob Eisenberg, who developed the Aurelia JavaScript framework, told InfoWorld that at one point he was trying to get a hook added to the specification for the JavaScript module loader. He told the magazine the standardization body does not have an efficient way of providing feedback, which limits the ability of outsiders to influence what is being considered.
- Lack of 64-bit numeric type. Despite the continuing evolution of the language, some nagging technical problems remain. One sore spot is the continuing absence of 64-bit numeric type. Currently, it only supports doubles due to its support for floating-point operations.
7 Major ES6 Features
Despite these ongoing challenges, the new features inside ES6 are extensive and impressive. They include:
- Modules. Modules allow you to reuse parts of your application in other areas. Using new import and export keywords, you can load dependencies and manage them. While you could cobble together similar functionality in ES5 using external libraries such as CommonJS, modularity is so important for today’s large programs, it is a significant benefit that it was built in as a core feature in ES6.
- Promises. Errors arising from asynchronous operations can now be handled with promises. While you can handle the same situation with callbacks, promises are much more readable due to concise error handling and method chaining.
- Arrows. This function shorthand uses the syntax =>. While not a monumental addition, this simple improvement provides lexical scoping of the keyword “this.”
- Const. Const makes it easier to ensure your code is accurate. Const lets anyone scanning the code see any variables that should not be modified, and throws off an error if he or she are. This helps reduce bugs because values keep their meaning and prevent a team member from changing a variable inadvertently.
- Property Names. In the previous version, ES5, you could not use a variable right in an object literal. ES6 allows this with specific syntax.
- Template Literals. Allows changing variables into strings. Template strings show much promise as a useful feature, such as using a tag for auto-escaping SQL strings.
- “Sugar Syntax”. As mentioned previously, ES6 has made a concerted effort to simplify the syntax. A new class syntax is “syntactic sugar” because it makes the language simpler and more readable. It does not change how the system works but provides a cleaner syntax for developers who prefer it.
Other features include:
- Block Level Scoping. Using the “let” keyword, ES6 lets you scope variables directly to blocks.
- Generators. Functions that make iterators utilizing “function*” and the keyword “yield.”
- Rest Parameters. Now you do not have to use arguments to access arguments for functions. You can access arrays that represent the remaining parameters.
- Set. You can store a data values list inside a collection object.
- Default Parameters. If you’ve ever wanted a function parameter that could be set default value, you are in luck, because ES6 has this functionality.
Classes is a feature of ES6 that has garnered a love/hate reaction from developers because it adds syntactic sugar on Javascript’s prototypical inheritance. It is meant to make Javascript more appealing to developers who may not have worked with a language that uses prototype chains. However, some developers complain classes lock you in and cover up inheritance, i.e. the original nature of JavaScript. A few JavaScript veterans feel the hard part about the language is constructors, not its prototypical inheritance.
Moreover, in truth, some components in ES6 are syntactic sugar. Classes are a good example as they use method signature notation to declare older coding methods with a shorter, more readable syntax. Programmers coming to JavaScript from class-based languages are usually glad they do not have to worry about strange inheritance mechanisms.
A Major Upgrade With Room To Grow
The reason JavaScript remains viable is it fits nicely in traditional web browsers while also playing well in new environments like Node.js. Despite its limitations, its flexibility allows it to thrive. ES6, or ECMAScript 2015, provides exciting new tools and functionality for developers to work faster, cleaner and more efficiently.
At the same time, ECMA needs to figure out a way for outside programmers to offer useful ideas and implement necessary features like 64-bit numeric type. If anything, ECMA needs to work faster. ES5 was adopted in 2009, and some industry watchers think it did not offer enough new features to be rolled out as a major upgrade. Indeed, some saw ES5 as nothing more than a warmed-over version of ES3. From that point of view, there haven’t been any significant advancements in the specification for many years.
If that picture is accurate, ECMA must adopt a faster approval process. They have to figure out how to incorporate new ideas rapidly, resolve political stalemates among stakeholders efficiently and make the syntax even friendlier to those new to the language. If they can meet these and other challenges effectively, JavaScript will remain a cornerstone of our mobile, always-on and hyper-connected world.
Want to know How to Build (and Scale) with Microservices? Download the Whitepaper from AppDynamics: Grab it now!
