IanRamosC · August 31, 2017 02:59 · Aug 31, 2017 · Aug 31, 2017 · Aug 31, 2017 · Aug 31, 2017
diff --git a/promises.md b/promises.md
@@ -130,10 +130,10 @@ o compilador adiciona as identações automaticamente, e o código fica muito ma
         var blabla2_p = request("blabla2");
         var blabla3_p = request("blabla3");
 
-        // combina os promises em um único promise em paralelo
+        // combine os promises em um único promise em paralelo
         var allBlablas_p = Promise.all([blabla1_p, blabla2_p, blabla3_p]);
 
-        // aí sim usa await
+        // aí sim use await
         var [blabla1, blabla2, blabla3] = await allBlablas_p;
 
         console.log(blabla1, blabla2, blabla3);

diff --git a/promises.md b/promises.md
@@ -139,7 +139,7 @@ o compilador adiciona as identações automaticamente, e o código fica muito ma
         console.log(blabla1, blabla2, blabla3);
 
       } catch (error) {
-        // handle error
+        // seja educado e trate os erros corretamente
       }
 
     })();

diff --git a/promises.md b/promises.md
@@ -118,23 +118,29 @@ o compilador adiciona as identações automaticamente, e o código fica muito ma
 
 3. sempre que fizer uma chamada assincrona numa função `async`, coloque `await` antes
 
-4. bonus: se suas chamadas async puderem ser feitas em paralelo, use `Promise.all`. ex:
+4. bonus: A. use `try/catch`. B. se suas chamadas async puderem ser feitas em paralelo, use `Promise.all`. ex:
 
     ```javascript
     (async () => {
-
-     // não vamos usar await ainda
-     var blabla1_p = request("blabla1");
-     var blabla2_p = request("blabla2");
-     var blabla3_p = request("blabla3");
-
-     // combina os promises em um único promise em paralelo
-     var allBlablas_p = Promise.all([blabla1_p, blabla2_p, blabla3_p]);
-
-     // aí sim usa await
-     var [blabla1, blabla2, blabla3] = await allBlablas_p;
-
-     console.log(blabla1, blabla2, blabla3);
+
+      try {
+
+        // não vamos usar await ainda
+        var blabla1_p = request("blabla1");
+        var blabla2_p = request("blabla2");
+        var blabla3_p = request("blabla3");
+
+        // combina os promises em um único promise em paralelo
+        var allBlablas_p = Promise.all([blabla1_p, blabla2_p, blabla3_p]);
+
+        // aí sim usa await
+        var [blabla1, blabla2, blabla3] = await allBlablas_p;
+
+        console.log(blabla1, blabla2, blabla3);
+
+      } catch (error) {
+        // handle error
+      }
 
     })();
     ```

diff --git a/promises.md b/promises.md
@@ -141,4 +141,4 @@ o compilador adiciona as identações automaticamente, e o código fica muito ma
 
     esse último código seria a melhor versão dessa nossa função
 
-5. [para Haskellers: Promises são monads, `.then` é o `>>=`, e `async\await` é o `do {}`](https://gist.github.com/MaiaVictor/bc0c02b6d1fbc7e3dbae838fb1376c80)
+5. para Haskellers: [Promises são monads, `.then` é o `>>=`, e `async\await` é o `do {}`](https://gist.github.com/MaiaVictor/bc0c02b6d1fbc7e3dbae838fb1376c80)
diff --git a/promises.md b/promises.md
@@ -125,16 +125,16 @@ o compilador adiciona as identações automaticamente, e o código fica muito ma
 
      // não vamos usar await ainda
      var blabla1_p = request("blabla1");
-      var blabla2_p = request("blabla2");
-      var blabla3_p = request("blabla3");
+     var blabla2_p = request("blabla2");
+     var blabla3_p = request("blabla3");
 
      // combina os promises em um único promise em paralelo
-      var allBlablas_p = Promise.all([blabla1_p, blabla2_p, blabla3_p]);
+     var allBlablas_p = Promise.all([blabla1_p, blabla2_p, blabla3_p]);
 
      // aí sim usa await
      var [blabla1, blabla2, blabla3] = await allBlablas_p;
 
-      console.log(blabla1, blabla2, blabla3);
+     console.log(blabla1, blabla2, blabla3);
 
     })();
     ```

diff --git a/promises.md b/promises.md
@@ -141,4 +141,4 @@ o compilador adiciona as identações automaticamente, e o código fica muito ma
 
     esse último código seria a melhor versão dessa nossa função
 
-5. para uma explicação mais elaborada, clique [aqui](https://gist.github.com/MaiaVictor/bc0c02b6d1fbc7e3dbae838fb1376c80)
+5. [para Haskellers: Promises são monads, `.then` é o `>>=`, e `async\await` é o `do {}`](https://gist.github.com/MaiaVictor/bc0c02b6d1fbc7e3dbae838fb1376c80)
diff --git a/promises.md b/promises.md
@@ -137,7 +137,7 @@ o compilador adiciona as identações automaticamente, e o código fica muito ma
       console.log(blabla1, blabla2, blabla3);
 
     })();
-```
+    ```
 
     esse último código seria a melhor versão dessa nossa função
 

diff --git a/promises.md b/promises.md
@@ -119,26 +119,26 @@ o compilador adiciona as identações automaticamente, e o código fica muito ma
 3. sempre que fizer uma chamada assincrona numa função `async`, coloque `await` antes
 
 4. bonus: se suas chamadas async puderem ser feitas em paralelo, use `Promise.all`. ex:
-
-```javascript
-(async () => {
-
-  // não vamos usar await ainda
-  var blabla1_p = request("blabla1");
-  var blabla2_p = request("blabla2");
-  var blabla3_p = request("blabla3");
-
-  // combina os promises em um único promise em paralelo
-  var allBlablas_p = Promise.all([blabla1_p, blabla2_p, blabla3_p]);
-
-  // aí sim usa await
-  var [blabla1, blabla2, blabla3] = await allBlablas_p;
 
-  console.log(blabla1, blabla2, blabla3);
-
-})();
+    ```javascript
+    (async () => {
+
+     // não vamos usar await ainda
+     var blabla1_p = request("blabla1");
+      var blabla2_p = request("blabla2");
+      var blabla3_p = request("blabla3");
+
+     // combina os promises em um único promise em paralelo
+      var allBlablas_p = Promise.all([blabla1_p, blabla2_p, blabla3_p]);
+
+     // aí sim usa await
+     var [blabla1, blabla2, blabla3] = await allBlablas_p;
+
+      console.log(blabla1, blabla2, blabla3);
+
+    })();
 ```
 
-esse último código seria a melhor versão dessa nossa função
+    esse último código seria a melhor versão dessa nossa função
 
-5. para uma explicação mais profunda, clique [aqui](https://gist.github.com/MaiaVictor/bc0c02b6d1fbc7e3dbae838fb1376c80)
+5. para uma explicação mais elaborada, clique [aqui](https://gist.github.com/MaiaVictor/bc0c02b6d1fbc7e3dbae838fb1376c80)
diff --git a/promises.md b/promises.md
@@ -139,4 +139,6 @@ o compilador adiciona as identações automaticamente, e o código fica muito ma
 })();
 ```
 
-esse último código seria a melhor versão dessa nossa função
+esse último código seria a melhor versão dessa nossa função
+
+5. para uma explicação mais profunda, clique [aqui](https://gist.github.com/MaiaVictor/bc0c02b6d1fbc7e3dbae838fb1376c80)
diff --git a/promises.md b/promises.md
@@ -129,10 +129,10 @@ o compilador adiciona as identações automaticamente, e o código fica muito ma
   var blabla3_p = request("blabla3");
 
   // combina os promises em um único promise em paralelo
-  var allBlablas = Promise.all([blabla1_p, blabla2_p, blabla3_p]);
+  var allBlablas_p = Promise.all([blabla1_p, blabla2_p, blabla3_p]);
 
   // aí sim usa await
-  var [blabla1, blabla2, blabla3] = await allBlablas;
+  var [blabla1, blabla2, blabla3] = await allBlablas_p;
 
   console.log(blabla1, blabla2, blabla3);
 

diff --git a/promises.md b/promises.md
@@ -63,7 +63,7 @@ request("blabla1")
 
 como vc pode ver, o primeiro é uma bosta de ler, e o segundo traz o mesmo problema dos callbacks. a solução definitiva disso é o `async/await`. 
 
-PS: nesse caso vc poderia usar `Promise.all`, mas não poderia se os requests dependessem dos valores dos blablas intermediários. o ponto é: `.then` não resolve todos os casos
+PS: nesse caso vc poderia usar `Promise.all` nos 3 requests logo no início, mas não daria pra fazer isso se os requests dependessem dos valores dos blablas intermediários. o ponto é: `.then` não resolve todos os casos
 
 ### async: simplificando promises
 

diff --git a/promises.md b/promises.md
@@ -118,7 +118,7 @@ o compilador adiciona as identações automaticamente, e o código fica muito ma
 
 3. sempre que fizer uma chamada assincrona numa função `async`, coloque `await` antes
 
-4. se suas chamadas assíncronas puderem ser feitas em paralelo, use `Promise.all`. ex:
+4. bonus: se suas chamadas async puderem ser feitas em paralelo, use `Promise.all`. ex:
 
 ```javascript
 (async () => {

diff --git a/promises.md b/promises.md
@@ -63,7 +63,7 @@ request("blabla1")
 
 como vc pode ver, o primeiro é uma bosta de ler, e o segundo traz o mesmo problema dos callbacks. a solução definitiva disso é o `async/await`. 
 
-PS: nesse caso vc poderia usar `Promise.all`, mas não poderia se os requests dependessem dos valores dos blablas intermediários. o ponto é: promises não resolvem todos os casos
+PS: nesse caso vc poderia usar `Promise.all`, mas não poderia se os requests dependessem dos valores dos blablas intermediários. o ponto é: `.then` não resolve todos os casos
 
 ### async: simplificando promises
 

diff --git a/promises.md b/promises.md
@@ -20,7 +20,7 @@ request("blabla1", function callback(blabla1) {
 
 ### promises: simplificando funcões assíncronas
 
-eventualmente inventaram promises, que são "valores que serão resolvidos futuramente". eles podem ser passados por aí como valores normais de JS, e vc pode usar `.then(...)` para "esperar" o resultado. além do que, eles podem ser encadeados. cada `.then` tem acesso ao valor retornado pelo then anterior. por fim, vc pode capturar todos os erros no final da cadeia, com um `.catch`.
+eventualmente inventaram promises, que são "valores que serão resolvidos futuramente". eles podem ser passados por aí como valores normais de JS, e vc pode usar `.then(...)` para "esperar" o resultado. além do que, eles podem ser encadeados. cada `.then` tem acesso ao valor retornado pelo `.then` anterior. por fim, vc pode capturar todos os erros no final da cadeia, com um `.catch`.
 
 ```javascript
 request("blabla1")
@@ -63,6 +63,8 @@ request("blabla1")
 
 como vc pode ver, o primeiro é uma bosta de ler, e o segundo traz o mesmo problema dos callbacks. a solução definitiva disso é o `async/await`. 
 
+PS: nesse caso vc poderia usar `Promise.all`, mas não poderia se os requests dependessem dos valores dos blablas intermediários. o ponto é: promises não resolvem todos os casos
+
 ### async: simplificando promises
 
 asyncs funcionam junto com Promises. basicamente, toda função que tem `async` retorna um promise. por ex:

diff --git a/promises.md b/promises.md
@@ -126,7 +126,7 @@ o compilador adiciona as identações automaticamente, e o código fica muito ma
   var blabla2_p = request("blabla2");
   var blabla3_p = request("blabla3");
 
-  // combina os requests em um único request em paralelo
+  // combina os promises em um único promise em paralelo
   var allBlablas = Promise.all([blabla1_p, blabla2_p, blabla3_p]);
 
   // aí sim usa await

diff --git a/promises.md b/promises.md
@@ -121,12 +121,16 @@ o compilador adiciona as identações automaticamente, e o código fica muito ma
 ```javascript
 (async () => {
 
-  var blabla1_p = request("blabla1");
+  // não vamos usar await ainda
+  var blabla1_p = request("blabla1");
   var blabla2_p = request("blabla2");
   var blabla3_p = request("blabla3");
 
-  // faz os requests acima em paralelo
-  var [blabla1, blabla2, blabla3] = Promise.all([blabla1_p, blabla2_p, blabla3_p]);
+  // combina os requests em um único request em paralelo
+  var allBlablas = Promise.all([blabla1_p, blabla2_p, blabla3_p]);
+
+  // aí sim usa await
+  var [blabla1, blabla2, blabla3] = await allBlablas;
 
   console.log(blabla1, blabla2, blabla3);
 

diff --git a/promises.md b/promises.md
@@ -107,3 +107,30 @@ request("blabla1")
 ```
 
 o compilador adiciona as identações automaticamente, e o código fica muito mais normal e legível.
+
+### resumo
+
+1. nao use `.then`
+
+2. se a função que vc está escrevendo vai usar algo assíncrono, comece ela com `async`
+
+3. sempre que fizer uma chamada assincrona numa função `async`, coloque `await` antes
+
+4. se suas chamadas assíncronas puderem ser feitas em paralelo, use `Promise.all`. ex:
+
+```javascript
+(async () => {
+
+  var blabla1_p = request("blabla1");
+  var blabla2_p = request("blabla2");
+  var blabla3_p = request("blabla3");
+
+  // faz os requests acima em paralelo
+  var [blabla1, blabla2, blabla3] = Promise.all([blabla1_p, blabla2_p, blabla3_p]);
+
+  console.log(blabla1, blabla2, blabla3);
+
+})();
+```
+
+esse último código seria a melhor versão dessa nossa função
diff --git a/promises.md b/promises.md
@@ -39,7 +39,7 @@ request("blabla1")
   .then(blabla3 => console.log(blabla1, blabla2, blabla3)) // imprime todos os blablas
 ```
 
-pára um tempo pra ler o codigo acima e se vê o erro. `blabla1` e `blabla2` não estão em escopo no ultimo `then`! tem 2 jeitos de resolver isso:
+pára um tempo pra ler o codigo acima e perceba o erro. `blabla1` e `blabla2` não estão em escopo no ultimo `then`! tem 2 jeitos de resolver isso:
 
 1. passa os blablas adiante, até chegar no ultimo then:
 

diff --git a/promises.md b/promises.md
@@ -1,6 +1,6 @@
 ### o pq de funcões assíncronas
 
-funcoes de javascript quase sempre são assincronas. isso acontece porque js lida muito com coisas como http requests, leitura de disco... operacoes que levam muito tempo. imagina se seu programa travasse toda vez que vc fizesse um request http? pra evitar isso, o request é feito, o programa continua rodando, e depois o resultado é enviado pra vc num callback
+funcoes de javascript quase sempre são assincronas. isso acontece porque js lida muito com coisas como http requests, leitura de disco... operacoes que levam muito tempo. imagina se seu programa travasse toda vez que vc fizesse um request http? pra evitar isso, o request é feito em background, o programa continua rodando, e depois o resultado é enviado pra vc num callback
 
 ```javascript
 request("www.google.com", function callback(resultado) { ... })

diff --git a/promises.md b/promises.md
@@ -95,4 +95,15 @@ repara que `async` é só um shortcut para escrever uma função que retorna um
 })();
 ```
 
-esse código é equivalente aquela solução de identadar os promises pra direita. o compilador adiciona as identações automaticamente, e o código fica muito mais normal e legível.
+esse código é equivalente a esse:
+
+```javascript
+request("blabla1")
+  .then(blabla1 => request("blabla2")
+    .then(blabla2 => request("blabla3")
+      .then(blabla3 => console.log(blabla1, blabla2, blabla3)) // imprime todos os blablas
+    )
+  );
+```
+
+o compilador adiciona as identações automaticamente, e o código fica muito mais normal e legível.
diff --git a/promises.md b/promises.md
@@ -81,7 +81,7 @@ const add = async (a, b) => a + b;
 add(1, 2).then(result => console.log(result)); // imprime 3
 ```
 
-repara que `async` é só um shortcut para escrever uma função que retorna um promise. mas o legal é que, dentro de uma função `async`, vc pode usar `await promise`, que *para a execução da função até que o promise resolva*. repare que isso não é um problema, pois, como a função é assincrona, isso não vai "travar o seu programa" (o que aconteceria se o `await` pudesse ser usado em funções normais!). assim, com o `async/await`, você consegue escrever funções assíncronas com a "mesma cara" de funções normais. 
+repara que `async` é só um shortcut para escrever uma função que retorna um promise. mas o legal é que, dentro de uma função `async`, vc pode usar `await promise`, que **pára a execução da função até que o promise resolva**. repare que isso não é um problema, pois, como a função é assincrona, isso não vai "travar o seu programa" (o que aconteceria se o `await` pudesse ser usado em funções normais!). só vai travar a própria função, que roda em background, então tanto faz. assim, com o `async/await`, você consegue escrever funções assíncronas com a "mesma cara" de funções normais. 
 
 ```javascript
 (async () => {

diff --git a/promises.md b/promises.md
@@ -6,7 +6,7 @@ funcoes de javascript quase sempre são assincronas. isso acontece porque js lid
 request("www.google.com", function callback(resultado) { ... })
 ```
 
-isso é bom, mas gerava codigo dificil de ler, porque virava uma arvode de identação:
+isso é bom pra performance, mas gera codigo dificil de ler, porque vira uma arvode de identação:
 
 ```javascript
 request("blabla1", function callback(blabla1) {
@@ -20,7 +20,7 @@ request("blabla1", function callback(blabla1) {
 
 ### promises: simplificando funcões assíncronas
 
-daí inventaram promises, que são "valores que serão resolvidos futuramente". eles podem ser passados por aí como valores normais de JS, e vc pode usar `.then(...)` para "esperar" o resultado. além do que, eles podem ser encadeados. cada `.then` tem acesso ao valor retornado pelo then anterior. por fim, vc pode capturar todos os erros no final da cadeia, com um `.catch`.
+eventualmente inventaram promises, que são "valores que serão resolvidos futuramente". eles podem ser passados por aí como valores normais de JS, e vc pode usar `.then(...)` para "esperar" o resultado. além do que, eles podem ser encadeados. cada `.then` tem acesso ao valor retornado pelo then anterior. por fim, vc pode capturar todos os erros no final da cadeia, com um `.catch`.
 
 ```javascript
 request("blabla1")
@@ -50,7 +50,7 @@ request("blabla1")
   .then(([blabla1, blabla2, blabla3]) => console.log(blabla1, blabla2, blabla3)) // imprime todos os blablas
 ```
 
-2. identar para a direita:
+2. identa para a direita:
 
 ```javascript
 request("blabla1")
@@ -61,9 +61,11 @@ request("blabla1")
   );
 ```
 
+como vc pode ver, o primeiro é uma bosta de ler, e o segundo traz o mesmo problema dos callbacks. a solução definitiva disso é o `async/await`. 
+
 ### async: simplificando promises
 
-como vc pode ver, o primeiro é uma bosta de ler, e o segundo traz o mesmo problema dos callbacks. a solução definitiva disso é o `async/await`. eles funcionam junto com Promises. basicamente, toda função que tem `async` retorna um promise. por ex:
+asyncs funcionam junto com Promises. basicamente, toda função que tem `async` retorna um promise. por ex:
 
 ```javascript
 const add = (a, b) => new Promise((resolve, reject) => resolve(a + b));

diff --git a/promises.md b/promises.md
@@ -1,11 +1,12 @@
+### o pq de funcões assíncronas
 
-ate pela natureza do JS, funcoes geralmente eram assincronas. escrever no disco, etc. no começo, se usava callbacks:
+funcoes de javascript quase sempre são assincronas. isso acontece porque js lida muito com coisas como http requests, leitura de disco... operacoes que levam muito tempo. imagina se seu programa travasse toda vez que vc fizesse um request http? pra evitar isso, o request é feito, o programa continua rodando, e depois o resultado é enviado pra vc num callback
 
 ```javascript
 request("www.google.com", function callback(resultado) { ... })
 ```
 
-depois, constataram que isso era burrice e gerava codigo dificil de ler, porque virava uma arvode de identação:
+isso é bom, mas gerava codigo dificil de ler, porque virava uma arvode de identação:
 
 ```javascript
 request("blabla1", function callback(blabla1) {
@@ -17,8 +18,9 @@ request("blabla1", function callback(blabla1) {
 })
 ```
 
+### promises: simplificando funcões assíncronas
 
-inventaram promises, que são "valores que serão resolvidos futuramente". eles podem ser passados por aí como valores normais de JS, e vc pode usar `.then(...)` para "esperar" o resultado. além do que, eles podem ser encadeados. cada `.then` tem acesso ao valor retornado pelo then anterior. por fim, vc pode capturar todos os erros no final da cadeia, com um `.catch`, o que simplifica ainda mais alguns codigos.
+daí inventaram promises, que são "valores que serão resolvidos futuramente". eles podem ser passados por aí como valores normais de JS, e vc pode usar `.then(...)` para "esperar" o resultado. além do que, eles podem ser encadeados. cada `.then` tem acesso ao valor retornado pelo then anterior. por fim, vc pode capturar todos os erros no final da cadeia, com um `.catch`.
 
 ```javascript
 request("blabla1")
@@ -28,7 +30,7 @@ request("blabla1")
   .catch(error => ...) // uma vez so, captura todos os erros acima!
 ```
 
-esse estilo permite simplificar muito o codigo, mas ainda é meio bosta. imagina que vc precisa de todos os `blablas` na ultima linha?
+esse estilo permite simplificar muito códigos assíncronos, mas ainda é meio bosta. imagina que vc precisa de todos os `blablas` na ultima linha?
 
 ```javascript
 request("blabla1")
@@ -37,7 +39,7 @@ request("blabla1")
   .then(blabla3 => console.log(blabla1, blabla2, blabla3)) // imprime todos os blablas
 ```
 
-para um tempo pra ler o codigo acima e se vê o erro. `blabla1` e `blabla2` não estão em escopo no ultimo then! tem 2 jeitos de resolver isso:
+pára um tempo pra ler o codigo acima e se vê o erro. `blabla1` e `blabla2` não estão em escopo no ultimo `then`! tem 2 jeitos de resolver isso:
 
 1. passa os blablas adiante, até chegar no ultimo then:
 
@@ -59,6 +61,8 @@ request("blabla1")
   );
 ```
 
+### async: simplificando promises
+
 como vc pode ver, o primeiro é uma bosta de ler, e o segundo traz o mesmo problema dos callbacks. a solução definitiva disso é o `async/await`. eles funcionam junto com Promises. basicamente, toda função que tem `async` retorna um promise. por ex:
 
 ```javascript

diff --git a/promises.js → promises.md b/promises.js → promises.md
diff --git a/promises.js b/promises.js
@@ -0,0 +1,92 @@
+
+ate pela natureza do JS, funcoes geralmente eram assincronas. escrever no disco, etc. no começo, se usava callbacks:
+
+```javascript
+request("www.google.com", function callback(resultado) { ... })
+```
+
+depois, constataram que isso era burrice e gerava codigo dificil de ler, porque virava uma arvode de identação:
+
+```javascript
+request("blabla1", function callback(blabla1) {
+  request("blabla2", function callback(blabla2) {
+    request("blabla3", function callback(blabla3) {
+      console.log(blabla3); // imprime o ultimo blabla
+    })
+  })
+})
+```
+
+
+inventaram promises, que são "valores que serão resolvidos futuramente". eles podem ser passados por aí como valores normais de JS, e vc pode usar `.then(...)` para "esperar" o resultado. além do que, eles podem ser encadeados. cada `.then` tem acesso ao valor retornado pelo then anterior. por fim, vc pode capturar todos os erros no final da cadeia, com um `.catch`, o que simplifica ainda mais alguns codigos.
+
+```javascript
+request("blabla1")
+  .then(blabla1 => request("blabla2"))
+  .then(blabla2 => request("blabla3"))
+  .then(blabla3 => console.log(blabla3)) // imprime o ultimo blabla
+  .catch(error => ...) // uma vez so, captura todos os erros acima!
+```
+
+esse estilo permite simplificar muito o codigo, mas ainda é meio bosta. imagina que vc precisa de todos os `blablas` na ultima linha?
+
+```javascript
+request("blabla1")
+  .then(blabla1 => request("blabla2"))
+  .then(blabla2 => request("blabla3"))
+  .then(blabla3 => console.log(blabla1, blabla2, blabla3)) // imprime todos os blablas
+```
+
+para um tempo pra ler o codigo acima e se vê o erro. `blabla1` e `blabla2` não estão em escopo no ultimo then! tem 2 jeitos de resolver isso:
+
+1. passa os blablas adiante, até chegar no ultimo then:
+
+```javascript
+request("blabla1")
+  .then(blabla1 => Promise.all([blabla1, request("blabla2")]))
+  .then(([blabla1, blabla2]) => Promise.all([blabla1, blabla2, request("blabla3")]))
+  .then(([blabla1, blabla2, blabla3]) => console.log(blabla1, blabla2, blabla3)) // imprime todos os blablas
+```
+
+2. identar para a direita:
+
+```javascript
+request("blabla1")
+  .then(blabla1 => request("blabla2")
+    .then(blabla2 => request("blabla3")
+      .then(blabla3 => console.log(blabla1, blabla2, blabla3)) // imprime todos os blablas
+    )
+  );
+```
+
+como vc pode ver, o primeiro é uma bosta de ler, e o segundo traz o mesmo problema dos callbacks. a solução definitiva disso é o `async/await`. eles funcionam junto com Promises. basicamente, toda função que tem `async` retorna um promise. por ex:
+
+```javascript
+const add = (a, b) => new Promise((resolve, reject) => resolve(a + b));
+
+add(1, 2).then(result => console.log(result)); // imprime 3
+```
+
+isso pode ser reescrito como:
+
+```javascript
+const add = async (a, b) => a + b;
+
+add(1, 2).then(result => console.log(result)); // imprime 3
+```
+
+repara que `async` é só um shortcut para escrever uma função que retorna um promise. mas o legal é que, dentro de uma função `async`, vc pode usar `await promise`, que *para a execução da função até que o promise resolva*. repare que isso não é um problema, pois, como a função é assincrona, isso não vai "travar o seu programa" (o que aconteceria se o `await` pudesse ser usado em funções normais!). assim, com o `async/await`, você consegue escrever funções assíncronas com a "mesma cara" de funções normais. 
+
+```javascript
+(async () => {
+
+  var blabla1 = await request("blabla1");
+  var blabla2 = await request("blabla2");
+  var blabla3 = await request("blabla3");
+
+  console.log(blabla1, blabla2, blabla3);
+
+})();
+```
+
+esse código é equivalente aquela solução de identadar os promises pra direita. o compilador adiciona as identações automaticamente, e o código fica muito mais normal e legível.
No results found