     commands = []
     for name, version of @getPackageDependencies()
       do (name, version) =>
-        commands.push (callback) =>
-          @installRegisteredPackage({name, version}, options, callback)
-
-    async.waterfall(commands, callback)
+        commands.push (next) =>
+          @installRegisteredPackage({name, version}, options, next)
+
+    async.series(commands, callback)
 
   installDependencies: (options, callback) ->
     options.installGlobally = false

        unless packageVersion
          @logFailure()
          callback("No available version compatible with the installed Atom version: #{@installedAtomVersion}")

        {tarball} = pack.versions[packageVersion]?.dist ? {}
        unless tarball

          return

        commands = []
        commands.push (next) =>
          @getPackageCachePath packageName, packageVersion, (error, packagePath) =>
            if packagePath
              next(null, packagePath)
            else
              @downloadPackage(tarball, installGlobally, next)
        installNode = options.installNode ? true
        if installNode
          commands.push (packagePath, next) =>
            @installNode (error) -> next(error, packagePath)
        commands.push (packagePath, next) =>
          @installModule(options, pack, packagePath, next)
        commands.push ({installPath}, next) ->
          if installPath?
            metadata = JSON.parse(fs.readFileSync(path.join(installPath, 'package.json'), 'utf8'))
            json = {installPath, metadata}
            next(null, json)
          else
            next(null, {}) # installed locally, no install path data

        async.waterfall commands, (error, json) =>
          unless installGlobally
