Promises

Promise a method to reduce the verbosity of the callback, mainly recommended by the community, so it's good to leverage the promise features in our code to make the code less verbose and less number of if/else blocks. But one thing is the libraries that we are using, or the modules we are writing should expose promisified objects or classes, so you can interact with libs as per the promise coding pattern. Currently promise libraries like bluebird provide options to promisify an object which doesn't support promise behavior.

Technically Promise is a kinda method as the word literally means, gives some promise object which will be met in future. Here we don't need to pass callback when we creating the object rather, we create the object first, and then we attach the required handlers, so that when the object actually returns result / error there will be some handler ( callback ) available to deal with it. In the case of promise the way that handler attachment is done is shown bellow. Another benefit is the chaining capabilities of promise object.

Any object with then method can be called promise if that object follows the specification given in Promise/A+ specification. Promise wraps the async operation and gives the response object even though the response is not yet ready, it eventually be ready. Promise object can also be called as thenable object.

promise2 = promise1.then(onFulfilled, onRejected);
// Where onFulfilled and onRejected are callback with single argument
// onFullfiled gets result.
// onRejected gets reason for failure.

Rewriting the above example looks as follows:-

 /*
 * Create your own promise object, that behave like thenable object
 * and can be used other parts of the codebase
 */
var getValuePromise = function() {
        return new Promise(function(onFulfilled, onRejected) {
            var redisPromise = redis.pipeline()
                .get("heightKey")
                .get("weightKey")
                .exec();

            redisPromise.then(function(results) {
                // Both height and weight are packed in `results` object.
                if (results[0][0] || results[1][0]) {
                    // If the redis operation have some error, call the
                    // Promise reject.
                    onRejected(val);
                } else {
                    // Successful promise.
                    let val = {
                        'height': results[0][1],
                        'weight': results[1][1]
                    }
                    onFulfilled(val);
                }
            })
        });
}

var getYourBmi = function() {
    return getValuePromise().then(function(val) {
        //console.log("Bmi calculation: " + val.height)
        return val.weight / (val.height * val.height );
    });
}


getYourBmi().then(function(result) {
    console.log("Your Bmi: " + result );
    process.exit()
}).catch(function(error) {
    console.log("Calculation failed with error: " + error);
    process.exit()
}

NOTE: Here the promise examples are based on the bluebird promise implementation. Any objects or user defined objects can be converted to the promisified version using bluebird library.

I'm surprised to see the specification of the Promise/A+, it is very small and concise text document. It clearly says what a promise implementation should follow. After programming in Node.js with standard node.js callbacks I'm convinced that use of Promise really make the code better and clean.

Main benefits are:-

1. Less nesting levels or less number of callbacks. ie; Don't need to pass callback to each and every methods to properly handle the results from it.
2. We can design the data flow and transformation as a pipeline.
3. Error propagation and handling similar to that of sync code base.
4. Chain the promise with multiple transformation or filters etc.
5. Thenable objects won't throw, it nicely pack the error and can be intercepted via .catch method of the promise object.

What happens Promise when a promise object is ready with its result before a 'then' handler is attached to handle it ?

This won't happen because Promise/A+ insists so :). As the specification guarantee that,this scenario shouldn't happen, the implementation has to ensure this by making the actual code block execution after emptying the current call stack.

Generators

As you guess this is co-routine implementation in Node.js and included in the ES6 specification. If you familiar with python you should know the generators. The concept is same. But with node.js, there is one more things, ie; its inherent asynchronous execution, so combining async with generator give much better way to represent complex flows in easy syntax. See few examples bellow. My current projects we didn't used it, looking forward to try out in future projects. In python3 there is similar behavior available using asyncio stdlib.

Main features of generators are:-

1. Lazy loading
2. Memory efficient due to the lazy loading behavior, best fit to iterate through chunks of big files or streams.
3. Plays well with Asynchronous codes, this is win-win situation for both.

Here is the simple example of how to define a generator and how to consume it.

//Generator functions are defined using "function*" syntax.
function* getList() {
    yield 'a';
    yield 'b';
}

for (let x of getList()) {
    console.log(x)
}
// Prints
a
b


// Another way to retrieve the generator values are making use of 'next'
// method.
var gen = getList();

console.log(gen.next())
console.log(gen.next())
console.log(gen.next())

// Prints
{ value: 'a', done: false }
{ value: 'b', done: false }
{ value: undefined, done: true} // Indicates generator finished.

Lets implement our above example using generator and promise. we are using 'co' library which is a wrapper around generator which internally loop through the generator till it finishes, so outside we only see sequential behavior.

// Here is the generator magic.
// The async calls will be executed synchronously. Ie; it will block till
// the call to async call finishes.

var bmi = co(function*() {

    // First async call

    var setRedis = yield redis.pipeline()
                              .set("heightKey", 1.8)
                              .set("weightKey", 80)
                              .exec();

    // Blocks here till the redis write operation finishes.


    // Second async call
    var res = yield getYourBmi()
    console.log("Your Bmi: " + res);

}).catch(function(err) {
    // Errors are wrapped out ensure no callback way of handling the errors
    // from bottom up fashion.
    console.error(err.stack);

});

You can see how cleanly generators helps to handle the async codes in sequential way. There are lot of other ways you can make use of this feature in your code, please check out the co library's github page for more examples.

References

1. https://2ality.com/2015/03/es6-generators.html
2. https://www.promisejs.org/
3. https://blog.risingstack.com/node-js-at-scale-understanding-node-js-event-loop/
4. https://promisesaplus.com/
5. https://github.com/tj/co