• Home
  • >
  • Software Development
  • >
  • JavaScript Standard Moves to Yearly Release Schedule; Here is What’s New for ES16 – InApps 2022

JavaScript Standard Moves to Yearly Release Schedule; Here is What’s New for ES16 – InApps is an article under the topic Software Development Many of you are most interested in today !! Today, let’s InApps.net learn JavaScript Standard Moves to Yearly Release Schedule; Here is What’s New for ES16 – InApps in today’s post !

Read more about JavaScript Standard Moves to Yearly Release Schedule; Here is What’s New for ES16 – InApps at Wikipedia

You can find content about JavaScript Standard Moves to Yearly Release Schedule; Here is What’s New for ES16 – InApps from the Wikipedia website

ECMAScript 6, officially known as ES2015, was the largest and longest-running update to JavaScript ever. The official name included the year rather than the version number because subsequent updates will be annual, with the first due this June.

And the first of those annual updates, ES2016 or ES16 for short, might be one of the smallest official updates to JavaScript; it has just two new features. Though very small, ES16 perfectly illustrates the shift to the new way of evolving the language based on interoperability and what’s ready to use.

“It’s very tiny,” said David Herman, Mozilla’s representative on the TC39 committee that standardizes JavaScript. “It adds the exponentiation operator as a syntactic affordance for Math.pow [for raising a number to the power of an exponent], and it adds Array.prototype.includes (something we wanted to include in ES15 but couldn’t due to web compatibility concerns).”

The Array.prototype.includes method – which checks if a value is included in an array or not — was originally going to be named Array.prototype.contains; it changed because that name was already used by the MooTools library, so reusing it might break some websites. There’s been some discussion as to whether that was the best decision, but it certainly reflects the emphasis the ECMAScript committee puts on not breaking code that’s already on the web.

“TC39 and the JavaScript engine implementers go to great lengths to ensure that new language features do not introduce incompatibilities,” explained Brian Terlson, editor of the ECMAScript standard, and a senior program manager on the Microsoft Edge team.

Read More:   Meroxa Aims to Provide the Easy Button for Data Pipelines – InApps Technology 2022

Async functions were expected in ES16, but Terlson (who is what T39 calls the ‘feature champion’ for async) explained that the delay is due to the new requirement that new ECMAScript features have already been implemented.

“They’ve been implemented in transpilers for some time; Babel and TypeScript both support them, but today Edge is the only browser implementation. Until a couple of months ago that had a significant piece lacking, and the feeling on the committee was that without that we don’t really know that this is going to work on the web.” That should be addressed when Firefox adds async support and Herman predicts that “Async functions will hopefully get into the ES17 spec.”

Small and Ready to Use

The fact that ES2016 is “super small” isn’t a problem with the new process, Terlson said. “It’s very small, but that’s actually the process working. After ES2015, we had to get the pipeline filled with new proposals and those proposals had to go through the process and this year we could only get two of those things done in time.”

In fact, he suggests, the process is perhaps the most important thing about the new spec. “While the spec wasn’t that big in terms of new features, there were huge amounts of work done in other areas. We had on the order of a hundred web fixes, perhaps more even, and probably thousands of individual editorial fixes and tweaks. And that was all made possible by our transition to GitHub.”

Previously, although you could see it in PDF and HTML formats, the ECMAScript standard had been “lovingly maintained” in the same Word document, all the way from the original version one to ES2015. “That development method wasn’t scaling,” said Terlson (which sounds like something of an understatement).

“It was hard for the community to participate and hard for implementers to keep track of what was going on. We got out of Word and moved everything to GitHub, using a custom HTML dialect, Ecmarkup,” Terlson said.

Read More:   Google’s Flutter Beefs up Web Support, So How Does It Compare to React Native Now?

That means that both proposals and the specification itself are in the same format; People can send pull requests for both bug fixes and editorial requests. “If you track where most of the work happened, it was building up the tooling and getting on board with the new tooling process, and that’s going to continue paying huge dividends,” Terlson believes.

The ES2016 requirement that features have to have had multiple interoperable implementations before they make it into the standard should save time further down the line.

“ES6 didn’t have the implementation requirement,” explained Terlson, “and as a result after it was ratified, as we got around to implementing certain features like proxies, there were issues implementers came across that were just not reflected in the spec, so we had to make changes after the fact. That really reflects the important of making sure a feature can be implemented as specified before ratifying the standard.”

There’s some debate about the level of implementation experience that should be required for a feature, and the process doesn’t specify that; “it’s done on a case by case basis,” said Terlson. “For certain features we can be pretty certain that they’re going to work if we get a transpiler implementation plus a browser and having them implemented behind an experimental flag is probably OK.”

Opinions vary but demanding more implementation would involve tradeoffs, he suggests. “We could require an implementation in two browsers shipping it, but that may mean when you discover an issue it’s too late, because it’s already shipped, and the standard would move more slowly because it would be gated by the implementers,” Terlson said.

What the new process does add are tests. “When ES2015 was ratified, there were no tests, so it took huge efforts to backfill them so implementations could test when they started building out features, that they were conforming to the specification.” For ES2016, there’s an official test suite and tests are required before a feature can become part of the standard. “We will never again be in a situation where implementers can read the spec but not know what the implications are,” claimed Terlson.

Read More:   New Security Frameworks Bolster SecOps and the Modern SOC – InApps 2022

Take the Next Train

Terlson suggests looking at ECMAScript in a different way going forward because of the new process. “Developers shouldn’t be looking at the version of the standard as much; it’s really on a feature by feature basis,” he said.  “On the GitHub repo, we have a table of proposals, and those proposals have varying level of maturity. If something is in stage three, that’s a good indication that it’s going to be a thing, and it’s something to be aware of. If a transpiler supports it, maybe turn that on and try it and give feedback, on a feature by feature basis.”

Herman suggests thinking of the yearly schedules like train timetables; whatever features are ready to use (which means they’ve reached stage four when the scope of the release is finalized, around January each year) go on the next train.

“The principal benefit of the “train schedule” to developers is that features can be finalized more independently and shipped sooner. The new process also provides clearer signals about the relative stability of individual features, allowing developers to test-drive experimental features in their apps via transpilers. This not only means developers get to take advantage of exciting language features sooner, but it also provides a feedback channel for improving experimental designs and amplifies developers’ voices in the standardization process.”

There’re other advantages, pointed out Jonathan Turner, now at Mozilla and former program manager of Microsoft’s TypeScript transpiler. “If each update were the size of the ECMAScript 6 update, that would be a gargantuan task to keep up with.”

That fits the way the JavaScript development community is willing to experiment with the plethora of new tools and frameworks and pick out the ones that deliver, he believes.

“There’s a new technology idea almost every day; there’s a new framework that comes out almost every month. You can’t pick up every single one and run with it, but the community as a whole gets used to trying things out. Developers have side projects where they try technologies out, and they say ‘Oh that really did make things better’ or ‘Oh no, that’s got some rough edges,’ Turner said.  “It’s really natural for things to grow organically across the community as people listen to each other and try little demos out with technology before they start rocking with it.”

Feature image: Unsplash.

Source: InApps.net

Rate this post
As a Senior Tech Enthusiast, I bring a decade of experience to the realm of tech writing, blending deep industry knowledge with a passion for storytelling. With expertise in software development to emerging tech trends like AI and IoT—my articles not only inform but also inspire. My journey in tech writing has been marked by a commitment to accuracy, clarity, and engaging storytelling, making me a trusted voice in the tech community.

Let’s create the next big thing together!

Coming together is a beginning. Keeping together is progress. Working together is success.

Let’s talk

Get a custom Proposal

Please fill in your information and your need to get a suitable solution.

    You need to enter your email to download


      Success. Downloading...