C#, python, javascript async implementations

  function main() {
      var real_time = StopWatch.now();
      parallel_http_ping_sites().then( function(results) {
          times = StopWatch.merge_times(results);
          real_time = StopWatch.now() - real_time;
          print_results(real_time, times);
      })
      .catch( function (error) {
          // The following will not propagate any exception (it will just add another failed promise to the chain
          // throw error;
          // This works because we throw inside a callback on the event loop (but no call stack)
          setImmediate(function() { throw error; });
      });
      // In node.js we do not need to wait for the event loop, the process will end once there is nothing more to do
  }

  function parallel_http_ping_sites () {
      var p1 = sequentially_http_ping_sites('google.fr', 'google.ch');
      var p2 = sequentially_http_ping_sites('google.es', 'google.com');
      return Promise.all([p1, p2]);
  }

  function sequentially_http_ping_sites () {
      var hosts = Array.prototype.slice.call(arguments);
      var times = new StopWatch();
      // Start chain with a resolved promise, it value will be discarted
      var promise_chain = Promise.resolve(null);

      for(var index in hosts) {
          var host = hosts[index];
          promise_chain = promise_chain
              .then( times.onStart(host) )
              .then( single_site_http_ping.bind(null, host) )
              .then( times.onStop(host) )
      }
      // Finish promise chain returning the timing information of the previous calls
      return promise_chain.then( function() { return times; } );
  }

  function single_site_http_ping (host) {
      // Transform the http.request callback api to the promise of a http response
      var response = new Promise( function(accept, reject) {
          var options = {
              'host' : host,
              'method' : 'HEAD'
          };
          var request = Http.request(options, accept);
          request.on('error', reject);
          request.end();
      });
      // Returning a pending promise on the `then` handler will create a proxy for it in consume_response
      // Equivalent to awaiting the result of an already synchronous operation
      var consume_response = response.then( function(response) {
          return new Promise( function(accept, reject) {
              response.on('data', function() { /*discard*/ });
              response.on('error', reject);
              response.on('end', function() { accept(response.headers); });
          });
      });
      return consume_response;
  }

  function print_results(real_time, times) {
      var m = times.measures;
      var keys = Object.keys(m);
      console.log('Real time : ' + real_time
          + "\nTime per site : " + JSON.stringify(m)
          + "\nTotal time : "    + keys.reduce( function(acc, k) { return acc + m[k]; }, 0)
      );
  }

  function StopWatch() { this.measures = {}; }

  StopWatch.now = function() {
      var now = process.hrtime();
      return Math.round(now[0] * 1000 + now[1] / 1000000);
  }

  StopWatch.merge_times = function(sw_list) {
      var result = new StopWatch();
      for(var index in sw_list)
          for (var m in sw_list[index].measures) 
              result.measures[m] = sw_list[index].measures[m];
      return result;
  }

  StopWatch.prototype.onStart = function(tag) {
      var me = this.measures;
      return function() { me[tag] = StopWatch.now(); }
  }

  StopWatch.prototype.onStop = function(tag) {
      var me = this.measures;
      return function() { me[tag] = StopWatch.now() - me[tag]; }
  }