Hopefully, it’s clear by now that Envato and Tuts+ are dedicated to education. In addition to the various Tuts+ sites like this one, we also offer Tuts+ Premium, which provides the best web development courses and ebooks available today for a small monthly cost. Members of Premium help to contribute back to Tuts+ and ensure that we can continue offering as much free content as possible.

Speaking of free: each month, we release one new entirely free course. This month, I’m proud to announce that you can learn Ember with us for free!

Lessons

Introduction

• Introduction
• Installation and Bootstrap

The Object Model

• Classes and Objects
• Computed Properties

Application Components

• Observers

Demonstration

• Ember Architecture Explained
• Router
• Controllers
• Views
• Templates
• Models

Conclusion

• Let’s Build an Ember App: Part 1
• Let’s Build an Ember App: Part 2
• Final Tips

There Will Always Be More!

Be sure to bookmark freecourses.tutsplus.com (and subscribe to the newsletter) to stay updated on each new free course that we offer to the community!

If you’d like to learn more, of course a Tuts+ Premium membership is only $19 a month, and includes countless courses and downloadable eBooks on the topics that I guarantee you’re most interested in learning: HTML5, jQuery, Ember, Laravel, PHP 5.5, Rails 4, architecture, design patterns, and so much more.

Node v0.11.2 was released recently, and with it support for v8 generators. Generators can be hard to grasp, but essentially they’re decorated functions that you can execute multiple times and resume execution at different points inside the function.

What this means in practice is that we can get rid of the callback hell that has plagued node applications, and write code in a synchronous style, while it’s executed asynchronously behind the scenes.

Using yield

A code example is worth a thousand words, so let’s dive right in. We’re going to need Node v0.11.2, which you can easily install with nvm.

nvm install 0.11.2
    

We’re going to use a promise based server called Mach, and a promise library called Q. Install both of those with npm if you haven’t already.

Since we’re using bleeding edge v8 features, you’ll need to pass the --harmony flag through to Node whenever you invoke it.

node --harmony ./generators.js
    

Let’s define a sleep() function that takes an amount in milliseconds to sleep, and returns a promise. The promise will be resolved when the timeout completes.

function sleep(millis) {
      var deferredResult = Q.defer();
      setTimeout(function() {
        deferredResult.resolve();
      }, millis);
      return deferredResult.promise;
    };
    

A traditional callback based server would use promise chaining, and look like the following.

var mach = require('../lib');
    var app  = mach.stack();
    var Q    = require('q');
    
    app.run(function(request) {
      return sleep(2000).then(function(){
        return 'Good day to you sir';
      });
    });
    
    mach.serve(app, 3333);
    

Now let’s see what this looks like using generators. We’re going to define a generator function using the * notation. Then inside the function we can use yield, passing the sleep() promise.

app.run(Q.async(function *(request) {
      yield sleep(2000);
      return 'Good day to you sir';
    }));
    

As soon as yield is invoked, execution will pause and jump back up to Q.async(). Q will ensure that execution is resumed as soon as the promise is complete, which in our case will happen as soon as the timeout finishes. Q.async() itself returns a promise to Mach, which serves the request.

Real world yield

Now sleeping might be a fairly useless example, but let’s take a look at a better one – accessing a request’s parsed content. Mach let’s you do this with the request.parseContent() function. Since it returns a promise we can pipe that straight into yield:

app.run(Q.async(function *(request) {
      var body = yield request.parseContent();
      return JSON.stringify(body);
    }));
    

You can start to see how yield is cleaning up your Node handlers. Let’s take a look at another example – saving a model.

app.post('/users', Q.async(function *(request) {
      var user = new User(request.params);
    
      if (yield user.save()) {
        return JSON.stringify(user);
      } else {
        return 422;
      }
    }));
    

Next steps for yield

I honestly think yield is going to really transform the way Node applications are written, and cleanup up some of the traditional callback spaghetti you find in asynchronous code. I also can’t wait until it’s available in more browsers, although I suspect that will take a while.

You can find a full example of using Mach and generators in my fork.