Online Resource

Online Resource

Online Resource

Online Resource

Online Resource

Online Resource

A willingness to experiment with new foods and ways of foraging may make some birds less vulnerable to extinction.

Estigmatizados como focos de contagio en algunos países, los trabajadores de la salud han sido agredidos, maltratados y marginados.

The streets have suddenly come alive, especially at night, in many areas where social distancing is impossible.

In this post I will talk about Events and Promise limits, trying to fill all gaps with a 498 bytes sized library called notify-js.

Update
The awesome Lie function got improved and became an official module (yet 30 lines of code thought). Its name is Dodgy, and it's tested and even more awesome!

Not today though, today is just fine

1. if we are in charge of creating the Promise, we are the only one that could possibly make it abortable and only if we want to, it's an opt in rather than a default or a "boring to write" subclass
2. it's widely agreed that cancellation should be rather synonymous of a rejection, there's no forever pending issue there, just a plain simple rejection
3. one of the Promise strength is its private scope callback, which is inevitably the only place where defining abortability would make sense. Take a request, a timer, an event handler defined inside that callback, where else would you provide the ability to explicitly abort and cleanup the behavior if not there?
4. being the callback the best pace to resolve, reject, and optionally to abort, that's also the very same place we want to be sure that if there was a reason to abort we can pass it along the rejection, so that we could simply ignore it in our optionally abort aware Promises, and yet drop out from any other in the chain whenever the rejection occurs or it's simply ignored
5. the moment we make the promise malleable from the outer world through a p.abort() ability, is also the very same moment we could just decide to resolve, or fully fail the promise via p.resolve(value) or p.reject(error)

var p = new Lie(function (resolve, reject, onAbort) {
  var timeout = setTimeout(resolve, 1000, 'OK');
  // invoking onAbort will explicit our intent to opt-in
  onAbort(function () {
    clearTimeout(timeout);
    return 'aborted'; // will be used as rejected error
                      // it could even be undefined
                      // so it's easier to distinguish
                      // between real errors and aborts
  });
});

p.then(
  console.log.bind(console),
  console.warn.bind(console)
).catch(
  console.error.bind(console)
);

var toTheOuterWorld = p.then(
  function (data) {return data},
  function (error) {return error}
);
// or even ...
var toTheOuterWorld = Promise.resolve(p);

// abortable promise
var cancelable = new Lie(function (r, e, a) {
  var t = setTimeout(r, 5000, 'all good');
  a(function () { clearTimeout(t); });
});

// testing purpose, will it resolve or not?
setTimeout(cancelable.reject, 1000, 'nope');
// and what if we abort before?
setTimeout(cancelable.abort, 750);



// generic promise, let's log what happens
var derived = cancelable.then(
  function (result) { console.log('resolved', result); },
  function (error)  { error ?
    console.warn('rejected', error) :
    console.log('ignoring the .abort() call');
  }
).catch(
  function (error)  { console.error('cought', error); }
);

// being just a Promise, no method will be exposed
console.log(
  derived.resolve,
  derived.reject,
  derived.abort
);

Lie.more = function more(lie) {
  function wrap(previous) {
    return function () {
      var l = previous.apply(lie, arguments);
      l.resolve = lie.resolve;  // optional bonus
      l.reject = lie.reject;    // optional bonus
      l.abort = lie.abort;
      return Lie.more(l);
    };
  }
  if (lie.abort) {
    lie.then = wrap(lie.then);
    lie.catch = wrap(lie.catch);
  }
  return lie;
};

var chainedLie = new Lie(function (res, rej, onAbort) {
  var t = setTimeout(res, 1000, 'OK');
  onAbort(function (why) {
    clearTimeout(t);
    return why;
  });
})
.then(
  console.log.bind(console),
  console.warn.bind(console)
)
.catch(
  console.error.bind(console)
);

// check this out
chainedLie.abort('because');

var justPromise = Promise.resolve(chainedLie);

I think I've talked already few times about this problems but I don't see anything happening ... actually, it's getting worst and worst.

Who Is Directly Affected And Is Wasting Money

• Companies paying for Online Advertisement
• Companies selling online
• Companies providing online services

Who Is Responsible

• every service that is addressing users through their current IP address, without asking permission, and assuming if you travel to any country in this world you automatically speak that country language
• every service that completely ignores Accept-Language on the server side, and navigator.language on the client side

For a first contact, using the Accept-Language value to infer regional settings may be a good starting point, but be sure to allow them to change the language as needed and specify their cultural settings more exactly if necessary. Store the results in a database or a cookie for later visits.
...
By the way
Using the Accept-Language header is also a good starting point for determining the language of the user, rather than the locale ...

Nobody Is Doing It Right

Google