JavaScript for Line of Business Applications

JavaScript, in particular Node.js, has been frequently associated with callback hell. If you've written code that deals with a lot async I/O, you're probably familiar with this pattern:

...

It turns out, this code can be much easier and safer to write.

I'll show you how Promise combined with async / await enables this, but also some of the lessons we've learned from using these new features in production.

What is concurrency? How is it different from parallelism? JavaScript is single-threaded on the event loop, so how does its asynchrony fit into the mix?

These are great questions, but sadly, I think most JS developers are not really asking them enough. The concepts behind writing concurrent code are incredibly important, but we tend to only focus on the API provided to us by some library or framework. These APIs have a tremendous capability to shape our thoughts about the underlying functionalities, and often not in accurate or productive ways.

I want us to talk first about the concepts around concurrency before we focus on what we can do with some API or pattern. Don’t worry: following parts of this blog post series will talk more about APIs, if that’s what really gets you excited. But don’t skip over these concepts.

Cody Lindley explains why you should ditch non-standard JavaScript module formats and move to the ECMAScript 6 module format with examples.

By using jspm.io you can make use of the official JavaScript module control system (and its syntax) today – all while not having to wait for older modules to be re-written or having to limit yourself to one particular module format or package manager. In other words, you shouldn’t have to care from where a package comes and in what format it’s being provided.

The ideal, and yes we have arrived, is to just use ES6 modules and let a tool like jspm.io sort out all of the ugly details as it pertains to non-es6 modules from multiple endpoints. Not to mention, by using jspm (and a ES6 transpiler like traceur or Babel) you get most everything that ES6 offers, not just modules. Writing ES6 code in your ES6 modules sounds good, right!

This blog post describes the options you have for deploying ECMAScript 6 in current JavaScript environments. It is selective w.r.t. the amount of tools it covers. If you want a comprehensive list of tools, I suggest you look at Addy Osmani’s “ECMAScript 6 Tools”.

Content:

1. Using ECMAScript 6 today
2. Transpilation tools
3. Other useful ES6 tools and libraries
4. ES6 REPLs
5. What ES6 features can be transpiled?

Step 1: minimal Webpack, Babel and React setup

Step 2: trivial server-side rendering with Express

Step 3: add styles

Step 3a: switch to CSS modules

Step 3b: save the day by making webpack to render server-side code

Step 4a: asyncronously fetching data

Step 4b: use react-transmit to declaratively define data deps

Generators are a new feature in ES6. You declare a generator function which returns generator objects g that can then be iterated using any of Array.from(g), [...g], or for value of g loops. Generator functions allow you to declare a special kind of iterator. These iterators can suspend execution while retaining their context. We already examined iterators in the previous article and how their .next() method is called once at a time to pull values from a sequence.

Learn how to create a real world angular 2 app using Pipes, Directives, Components, DI, ES6 and much more! We'll implement from Authentication to calling an API and everything in between.

Let's talk about the setup first. ES6 is great and after much time reading about it and listening various presentations on it I have decided to roll up my sleeves and give it a go. This has resulted in a great application for a project I was working on and it also served as a good practice to get up and running with ES6. 

We crafted this post to share our approach to making ES6 support as transparent as possible for our users and our team in three easy steps.

To take advantage of ES6 features in browsers that don't natively support it, we needed to use a transpiler such as Babel (formerly known as 6to5). Babel alone has many features, however for further feature support, we also used the Babel polyfill, which allows support for features such as for..of loops, promises, and symbols.

This means our code is forward-compatible (when most modern browsers support ES6 natively, we'll be able to drop the transpiler). Another great reason for doing this is that it won't break existing code. The transpiler won't change much existing code (in the case of supporting iterators, it needs to change loops). Rather, it will pass most of it through, un-touched. This means that you can keep your existing code and begin writing ES6 right along-side it. Our workflow now involves writing ES6 syntax and upgrading pieces of older code we come across.

In order to support this, we needed automatic/transparent transpiling in three environments:

• ES6 in development mode
• ES6 in unit tests
• ES6 in production