Rsvp.js

The suite I used for this project has a primary suite and a series of extensions that I personally thought was a very good articulation of the currently accepted API, even such as it is.

Currently, only RSVP and Q pass the entire suite.

Same basic principle, it's a Promise library, but this one is by wycats.

I'd be curious to know if jQuery Deferred object passes the same promise test that RSVP.js mentions. (Not quite curious enough to run the test myself though, work is a bit to crazy today. Wait, what am I still doing on HN!)

Deferred pattern isn't from jQuery. It's from Twisted and the first JavaScript library to use it was MochiKit. A nitpick I know, but I think it's good to know where things really come from ;-)

My goal was to have a small, lightweight promises implementation that could be easily embedded in other browser-based libraries. I specifically wanted a very small API surface area, essentially limited to the surface area described by the Promises/A spec.

My requirements matched closely with the promises test-suite recently released, including a requirement that all promises be delivered asynchronously and efficiently if possible (`when` does not satisfy this requirement).

I could not find any existing small, embeddable libraries that satisfied all of these requirements.

I'm not sure the wheel has really been invented yet, at least in the case of JS. One of the things I found was that all the libraries had little or nothing to say about "error handling". Error handler bodies are always given with a comment like this -

    function (error) {
        // handle error
    }

What do you do there? Exit the process? How to recover and continue from some critical point? Can you retry some part of the action? Can you try some alternative actions if something fails?

So I felt we can do better and .... surprise .... wrote my own heavy weight (1 kloc) library that provides a richer-than-usual set of composeable async primitives emphasizing error management including recovery, restarts, alternatives, etc.

So, here is yet another "wheel" :)

https://github.com/srikumarks/IO.js

I've been using promises for my work lately, and I really like them. This doesn't have it, but one construct I use is the `when` function. It's useful for situations that may return non-promise values, and works like this:

    Promise.when(func(), function(val) {
        alert(val);
    });

So if `func` returns a normal value, the cb runs immediately. If it returns a promise, the cb runs on fulfillment.

Nested callbacks are a problem that every javascript/node.js developer runs in to. A common library to help with this and other issues is Async: https://github.com/caolan/async

Sometimes, it's just better to give your functions names, and pull them out.

RSVP.js looks nice. Also, I like jQuery's implantation of promises specifically with the ajax function.

They are both trying to solve the problem of handling asynchronous operations in an easier way than nested callbacks.

Promises are a different abstraction of async operations. I am still trying to wrap my head around them fully, but one of the advantages seems to be writing code that looks a little more sequential.

Not having tested it personally I can't say, but I'd imagine it's a lot faster.

I'd be more interested in how it compares to using postMessage which, from testing, is definitely a lot faster than setTimeout (like fast enough to be worth switching to if available).