Promise patterns: http://taoofcode.net/promise-anti-patterns/

broken chain.js

// bad
function anAsyncCall() {
    var promise = doSomethingAsync();
    promise.then(function() {
        somethingComplicated();
    });
    
    return promise;
}

// good
function anAsyncCall() {
    var promise = doSomethingAsync();
    return promise.then(function() {
        somethingComplicated()
    });   
}

collection kerfuffle.js

// bad
function workMyCollection(arr) {
    var resultArr = [];
    function _recursive(idx) {
        if (idx >= resultArr.length) return resultArr;
            
        return doSomethingAsync(arr[idx]).then(function(res) {
            resultArr.push(res);
            return _recursive(idx + 1);
        });
    }

    return _recursive(0);
}

// good
// Unlike the recursive non-solution, this will kick off all the async calls in parallel
function workMyCollection(arr) {
    return q.all(arr.map(function(item) {
        return doSomethingAsync(item);
    }));    
}

// good
// If you need to run your promises in series, you can use reduce.
function workMyCollection(arr) {
    return arr.reduce(function(promise, item) {
        return promise.then(function(result) {
            return doSomethingAsyncWithResult(item, result);
        });        
    }, q());
}

forgotten promise.js

// bad
var deferred = Q.defer();
doSomethingAsync().then(function(res) {
    res = manipulateMeInSomeWay(res);
    deferred.resolve(res);
}, function(err) {
    deferred.reject(err);
});
    
return deferred.promise;

// good
return doSomethingAsync().then(function(res) {
    return manipulateMeInSomeWay(res);
});

ghost promise.js

// bad
var promise;
if (asyncCallNeeded) 
    promise = doSomethingAsync();
else
    promise = Q.resolve(42);
        
promise.then(function() {
    doSomethingCool();
});

// good

nested promises.js

// Bad
loadSomething().then(function(something) {
  loadAnotherthing().then(function(another) {
      DoSomethingOnThem(something, another);
  });
});

// Good
q.all([loadSomething(), loadAnotherThing()])
  .spread(function(something, another) {
    DoSomethingOnThem(something, another);
});

overly keen error handle.js

// bad
somethingAsync.then(
    function() {
        return somethingElseAsync();
    },
    function(err) {
        handleMyError(err);
});

// good
somethingAsync
    .then(function() {
        return somethingElseAsync();
    })
    .then(null,
        function(err) {
            handleMyError(err);
        });
        
// or
somethingAsync
    .then(function() {
        return somethingElseAsync();
    })
    .catch(function(err) {
        handleMyError(err);
    });