Advancements in JavaScript further the frontend craft. Here are some advancements that I believe are important to us today.



## Rapid Spec Improvements

Hasn't it felt like there have been a lot of upgrades to JavaScript itself in recent years?  I feel like the TC39 committee, responsible for evolving the language and sharing a spec that vendors can build to has been very productive.  Browsers and Node.js are all tracking new specs quickly as well.  The [process](https://tc39.github.io/process-document/) seems to be working well.  It feels good to have progress.

The JavaScript language surface area is expanding.  Sometimes I pine for the days when a newb to JavaScript had fewer concepts to grok when first encountering code.  But on the whole, the additions and progress made have seemed worthwhile.

## Transpiling By Default

But not all JavaScript runtimes can keep up with the flood of new language development.  A mainstay in my JavaScript writing experience now seems to be [Babel](https://babeljs.io/).  Babel allows JavaScript transpilation, taking future-state JavaScript and rewriting it as current-day JavaScript that's interpretable by browsers today.  Never before have I or others felt so comfortable using features that are coming but not yet fully cross-browser compatible.

I have mixed feelings about JavaScript transpilation in the long-term.  In some ways, I hope it goes away.  But there are so many features yet to be adopted across major platforms that I see this as a necessity and a strong net-positive at least in the mid term.

## Type Support

As JavaScript projects get bigger and more complex, there seems to be more appetite for a strong type system in JavaScript.  I don't see this coming to the language itself, but who knows. The primo JavaScript flavor for typing is [flowtype](https://flow.org/).

This is welcome and feels like it makes apps better in many situations.  There are still situations, however, where I enjoy the ability to move quickly in JavaScript without first establishing the shapes of all required types.

The tooling here is getting better, but there's still much to be desired.  Typing requirements and error messages can be quite cryptic.

## Compile it All to JS

Is there a language today that doesn't compile to JavaScript?  The fact that is hard to answer with one or many examples is a testament to the fact that writing and deploying JavaScript is a valuable target.

There are many languages around the JS ecosystem that act as feeders for many of the ideas and language advancements that come to JavaScript.  Elm, Purescript, Typescript, Reason, and more. There is a lot of functional philosophy influence here.  They brings ideas for new, expressive syntaxes.

These are few advances that can be felt in the JavaScript language space.  Which developments have you had your eye on and feel are influential?

Advancements in JavaScript further the frontend craft.

Modern Frontend Dev: Language Advances

Modern frontend dev is enabled by growing browser capabilities.  There are many exciting things happening in browserland.  Here are a few that I care about.



## Offline Support

The new approach to handling offline support, embodied in [service workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API), is so much better than what came before.  It's now like you have a little router in the browser that you get to implement. It routes requests to where they should go during on- and off-line moments. It's a giant leap forward, and it's huge for creating web experiences that exist even when you're not connected to the Internet.

## In-browser Databases

We've had most of these storage options for a while now: local storage, session storage, and [IndexedDB](https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API).  But paired with newly-viable offline support, they are _way_ more compelling.  And improved APIs and capabilities, such as IndexedDB 2.0 are starting to land in browsers.

## WebAssembly

I think [WebAssembly](https://developer.mozilla.org/en-US/docs/WebAssembly) has the potential of changing the face of web development.  New, high-performance apps will be accessible over the Internet through browsers, continuing to evolving past the original document sharing network it all start as.  

WebAssembly also has the ability to change the source languages for the web. This will expand the number and kinds of programmers that are involved in creating the next generation of web applications and the form that these web apps take.

## Speed

Browsers are pretty snappy these days.  Vendors are constantly working to refine, enhance, or wholly recreate the engines that power the running of JavaScript, application of CSS, and the rendering of UIs.  You can require your apps to do a lot more and still be performant.

## Layout

New and interesting layouts are possible using specifications that are much more powerful and flexible than before.  CSS Flexbox is widely supported and we see a growing number of applications that can now respond to the wide-ranging form factors that web users come to the web within.  [CSS Grid](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Grid_Layout) is quickly spreading across all browsers, being adopted faster than about any significant CSS spec in the past.  

## Browser APIs

New and interesting browser capabilities are coming to fruition, some long years after conception.  The [web animation API](https://developer.mozilla.org/en-US/docs/Web/API/Animation) expands upon keyframe animations and transitions from CSS and brings that and more to JavaScript.  Support for the [payments API](https://developer.mozilla.org/en-US/docs/Web/API/Payment_Request_API) has just started to land, allowing the browser to natively handle user payment information.  Mixed with a resurgence in talk around micropayments, this could change the way and the ease with which money is exchanged on the web.

## Language Support

Browsers are following the language advances in JavaScript itself, supporting more and more natively.  Native promises, es2015+ syntax, and new data types will allow the browser to do more with less.  As polyfills and runtimes diminish, bundle sizes will shrink, and certain API and data structure implementations should become more performant.

## Tooling

To enhance the developer experience, browser vendors are investing much in developer tooling.  Most noticeable is Chrome, which has a widening and deepening array of useful tools.  Debugging is top-notch.  New performance audits via Lighthouse are awesome.  I've also heard raving about the great animations panel in Firefox.  

Browsers are getting better.  They can do more.  Which of these advances or others are most important to you?

Modern frontend dev is enabled by growing browser capabilities.

webdev