I know it's 11th hour, but perhaps this is a bit better explanation-wise? (or is it overkill)

Calling the "then" function on an existing promise:

```javascript
// let's call the existing promise promise1, so you'd write:
promise1.then(fulfillmentCallback, rejectionCallback);

function fulfillmentCallback(successfulResults) {
  // do something wonderful with the results
}

function rejectionCallback(failureResults) {
  // tell someone important about the failure
}

```

In the case that promise1 succeeds, then the fulfillmentCallback function will be called and passed the successful results of promise1 as its argument. If the promise rejects (ie failure) then the rejectionCallback will be called with the failure reason as its argument. 

An additional way of working with Promises, however, is called chaining promises. Instead of passing callback **functions** into the call to then, you pass in callback **Promises**:

```javascript
// let's call the existing promise promise1, so you'd write:
promise1.then(fulfillmentPromise, rejectionPromise);

var fulfillmentPromise = Em.RSVP.Promise.new(function(resolve, reject) {
  // do something, and if it works then:
  resolve(results);
  // otherwise, it didn't work, so:
  reject(errors);
});
var rejectionPromise = Em.RSVP.Promise.new(function(resolve, reject) {
  // now that this hasn't work, we need to try something else, and it worked, so:
  resolve(results);
  // otherwise both things failed. Times are sad, so we need to tell someone:
  reject(errors);
});

```

None of this will work at all if the run loop isn't working because all of these callbacks and/or chained promises get scheduled on the runloop when they're called (including this first promise).