JavaScript: from callback hell through then-hell to generators+promises

Lately I’ve been refactoring and then refactoring and then some one of my JS apps every time I find a better way to handle the asynchronicity of the language. The app is a MEAN stack app but I am working mostly on the back-end built for Node.js with the intention to do the same for the front-end when I am satisfied with the back-end code.

So I started writing a Node.js code using the callbacks everywhere even some of my custom functions(in other apps) were made to receive and call callbacks. I was very happy how the callbacks looked like and I was writing them as the second parameter of the functions without thinking: callAsync(params, function(err, data)) all the way!

However little by little I started to add new and more complicated features and the need to nest multiple callbacks did arise. Add to that the checking for error on every callback first line and the code started to be hard to read.

At some time I discovered Promises. I decided to use the bluebird Promises package. It follows the standard and also provides additional functions that at some time are really needed. I was in love and probably still am with the then-chaining, calling async functions, attaching then() to them, returning a new async call that provides a Promise and checking the result in the next then, adding a catch() function to handle any error in the promises chain and avoiding the need to check for an error in every then(). The code was beautiful again and no pyramid of doom existed anymore.

However Promises and then-chaining created a little overhead where every then() needs a callback function and also this callback doesn’t have access to variables in the previous callback – only the result from the previous promise call. There was a need to declare helper variables in the outer scope: the function where the Promise chain is.

Then I discovered generator functions. Their basic usage doesn’t show that you can use them in place of callbacks or Promises but the fact that yield can receive a Promise makes them very interesting. Of course there is a need of a wrapper function to call the generator’s .next() and check its .done status. I decided to use the co package for that.

After all of this the code I use is similar to this one:

co(function* () {

  let user = yield User.findOneAsync({ _id: 12345678 });
  console.log('user', user);

  let user2 = yield User.findOneAsync({ _id: 112233 });
  console.log('user2', user2);

}).catch(function (err) {
  console.error(err);
});

The code above will execute synchronously. Pretty cool, huh?
User.findOneAsync() returns a Promise. yield-ing a Promise will make this type of configuration to wait for the Promise to be resolved/rejected. The resolved Promise’s value will be assigned to the variable on the left(user/user2).

Now the next thing for me is to use ES7’s async functions. I can run ES6 and ES7 code with transpilers like Babel on the back and front-end.
Async functions’ syntax is similar to the one with the generator above without the need to use a wrapper function. I am thinking to wait a little before using them and keeping the code close to what is available natively in the latest Node.js/io.js which is ES5/ES6 syntax at least until the near future(next year?) when the ES7 will be finalized and ready to be used/implemented in the JS engines.

Performance Showdown: Node.js vs. io.js v2.0.0

We benchmarked two versions of Node.js, and two versions of io.js. Here we’ll share with you what what we found out and detail the full results!

Source: Performance Showdown: Node.js vs. io.js v2.0.0

Also check the comments there for better charts.

Update: check these graphs too.