@Sam: Pour la culture, C++11 voit l’introduction dans le standard C++ de std::future, std::promise, std::async, et toute la famille qui va bien. Ces concepts sont donc aussi présents en C++ en standard.

Pour plus de détail sur la POO :

http://sametmax.com/le-guide-ultime-et-definitif-sur-la-programmation-orientee-objet-en-python-a-lusage-des-debutants-qui-sont-rassures-par-les-textes-detailles-qui-prennent-le-temps-de-tout-expliquer-partie-1/

Mais c’est un exemple très avancé ici, donc ne t’inquiète pas si @promise.then ne te parle pas.

C’est assez bien expliqué ici : http://jakub.fedyczak.net/post/async-auto-best-feature-of-node-async/ avec un graphique qui permet de visualiser dans quel ordre vont s’exécuter les fonctions.

Notamment on voit les chemins d’exécution en parallèle, dans l’exemple du lien il y en a trois qui se lancent dès que les dépendances sont exécutées, et qui se rejoignent à la fin pour obtenir le résultat voulu.

PS : En parlant des tampons … en aurais-tu un à la sphaigne ou en en cheveux de cherokee ?

– je ne dis pas que les promis vient de jquery, mais qu’on les retrouve dedans et aussi ailleurs. Je ne parle pas d’origine.
– l’article est clairement pédagogique, le but n’est pas de faire au mieux mais de faire passer une notion. Les exemples sont volontairement imparfaits pour faire passer la notion.
– pour l’implémentation Python, je dis en toute lettre à la fin que ça n’adresse pas ce problème.

Bref, un tampon pour toi.

Je subodore que tu es très jeune, puisque tu ne reconnais pas le trombonne. Ce qui explique sans doute le côté emporté.

Le premier code est infect non pas parce qu’il utilise des callback mais parce qu’il est juste mal pensé. Le callback-hell est assez souvent un problème de la part du développeur pas du principe. D’ailleurs le javascript à des mécanismes simple pour l’évite.

En fait, juste en séparant simplement le code du premier en actions atomiques, on arrive ça :

$(function(){
  function fetchSession(){
    $.get('/sessions/last', manageSession);  
  }
 
  function startAppAndInitUI(){
    startApp(initUi);
  }
 
  function manageSession(session){
    if (session.device != currentDevice){
      fetchAndLoadContext(session.id);
    else {
      startAppAndInitUI();
    }
  }
 
  function fetchAndLoadContext(sid) {
    $.get('/session/ ' + sid + '/context', function(context){loadContext(startAppAndInitUI)});
  }
 
  $.post('/auth/token', function(token){
    saveToken(token);
    fetchSession();  
  })
});

Je suis sûr qu’avec le vrai contexte de l’application on peut faire un meilleur truc que ça d’ailleurs.

Le second exemple, est pas bon, les deux callbacks sont lancés en même temps et non l’un après l’autre. Il aurait fallut récupérer la nouvelle promise pour faire le second then.

Le “plus beau code” utilise pas vraiment bien les promises.
Voila une meilleure utilisation :

$(function(){
  // create new token
  $.post('/auth/token') 
  // then save token and get last session
  .then(function(token){
    saveToken(token);
    return $.get('/sessions/last');
  }) 
  // then init session
  .then(function(session){
    if (session.device != currentDevice){
      return $.get('/session/ ' + session.id + '/context').then(loadContext);
    }
  })
  .then(function(){
    startApp(initUi);
  });
});

Quelle différence ? Les appels de then à partir du deuxième.
Globalement, on finit par faire tout le temps la même chose. Pourquoi écrire deux fois l’appel quand on peut juste le chaîner ?

Et pour finir, il me semble (je suis pas spécialiste en Python) que ta classe promise ne fait pas son boulot.
L’un des avantages (occulté de cet article) des promises est qu’il permet aussi de stocker le résultat d’une opération asynchrone. Et donc si on ajoute un callback après que l’opération asynchrone soit finie, le callback est quand même lancé. Ça permet de mutualiser une opération asynchrone récurrente (comme par exemple à tout hasard une authentification).

Au final, l’article montre pas vraiment les meilleurs points des promises ce qui est juste dommage. (le parrallélisme, le race, la gestion d’erreur, la réutilisation… d’ailleurs l’article de HTML5rocks montre des usages plus intéressants (Article sur les promises))

PS: ce trombone est chiant.