code: function createParallellCommandsExecutor (tasks, workingDir, envVars, watchMode, host) {
      return new Observable(observer => {  
          const exitCodes = tasks.map(()=>undefined);
          let completeCount = 0;
  
          tasks.forEach((commands, i) => {
              const observable = createSequencialCommandExecutor(
                  commands, workingDir, envVars, watchMode, host);
              
              observable.subscribe({
                  next ({command, exitCode}) {
                      exitCodes[i] = exitCode || 0;
                      if (!!exitCode) {
                          // Partial failure. Emit the error directly to output to console
                          // which command that failed. May be repaired by a watcher watching changed
                          // source.
                          observer.next({command, exitCode});
                          return;
                      }
                      if (exitCodes.every(code => code === 0)) {
                          observer.next({exitCode: 0});
                      }
                  },
                  error(err) {
                      observer.error(err);
                  },
                  complete() {
                      if (++completeCount === tasks.length) {
                          observer.complete();
                      }
                  }
              });
          });
      });
  }
docs: Create an Observable that will execute all tasks in parallell and emit exitCode
  whenever one of the tasks fails, or whenever all tasks emits successful exit code.
  If then a command is rerun and complete successfully, it will emit again.
  The final subscription will complete when (and if) all tasks completes.
  
  @param tasks {string[][]} Array of tasks (sequences of commands) to execute
  @param workingDir {string} Initial Working Directory
  @param envVars {Object} Initial environment variables
  @param watchMode {boolean} Whether to execute watchers or not
  @param host {{spawn: Function, log: Function}} Mockable host environment (mimicking child_process.spawn() and console.log())
  @returns Observable