code: function executePerform(err) {
        var self = this;
        if (err && callback) {
          callback.call(this, err);
        } else {
          //
          // Remark (indexzero): Should we console.warn if `arguments.length > 1` here?
          //
          performFn.call(this, function afterPerform(err) {
            var performArgs, afterArgs;
            if (err && callback) {
              callback.call(self, err);
            } else {
  
              //
              // Specifically for the `after` hooks, we call it with the result of
              // the perform function to be able to do any modifications to the
              // result of the work!
              //
              performArgs = Array.prototype.slice.call(arguments);
              //
              // If we are waterfalling we need to pass the performArgs
              //
              afterArgs = waterfall ? performArgs : args;
              iterate(self, self._after_interceptors && self._after_interceptors['*'].concat(self._after_interceptors[action]), afterArgs, function (err) {
                if (err && callback) {
                  callback.call(self, err);
                } else if (callback) {
                  //
                  // Just to be sure we dont get javascript mad with object
                  // references, we check the length of the arguments to see if
                  // there is one, if not we default to whatever the performArgs.
                  // Remark: I want to note here that each c
                  //
                  return arguments.length > 1 && waterfall
                    ? callback.apply(self, arguments)
                    : callback.apply(self, performArgs);
                  }
              });
            }
          })
        }
      }
docs: Remark (jcrugzz): Is this the most optimized way to do this?