From ef00c647d15cf08607b4fa79b97d55c07710f0d6 Mon Sep 17 00:00:00 2001
From: lizzie136 <darknessover136@gmail.com>
Date: Tue, 2 Apr 2019 10:24:48 -0600
Subject: [PATCH 1/7] Adds spanish translation for 6-async/01-callbacks

  - Translates article.md
  - Translates task.md
  - We consider to use 'callback' instead of a translation because
    it is the term used by the community.
---
 .../01-animate-circle-callback/task.md        |  17 +--
 6-async/01-callbacks/article.md               | 141 +++++++++---------
 2 files changed, 79 insertions(+), 79 deletions(-)

diff --git a/6-async/01-callbacks/01-animate-circle-callback/task.md b/6-async/01-callbacks/01-animate-circle-callback/task.md
index 4a20ca604..ea613cd41 100644
--- a/6-async/01-callbacks/01-animate-circle-callback/task.md
+++ b/6-async/01-callbacks/01-animate-circle-callback/task.md
@@ -1,19 +1,18 @@
+# Círculo animado con callbacks
 
-# Animated circle with callback
+En esta tarea <info:task/animate-circle> se muestra un círculo animado creciendo.
 
-In the task <info:task/animate-circle> an animated growing circle is shown.
+Ahora, digamos que no necesitamos sólo un círculo, sino también mostrar un mensaje dentro de él. El mensaje debe aparecer _después_ que se ha completado la animación (el círculo ha crecido por completo), de otra manera se vería feo.
 
-Now let's say we need not just a circle, but to show a message inside it. The message should appear *after* the animation is complete (the circle is fully grown), otherwise it would look ugly.
+El la solución de esta tarea, la función `showCircle(cx, cy, radius)` dibuja el círulo, pero no hay manera de rastrea cuando está listo.
 
-In the solution of the task, the function `showCircle(cx, cy, radius)` draws the circle, but gives no way to track when it's ready.
+Agrega un argumento callback: `showCircle(cx, cy, radius, callback)` a ser llamado cuando la animación se halla completado. El `callback` debe recibir como un argumonto el `<div>` del círculo.
 
-Add a callback argument: `showCircle(cx, cy, radius, callback)` to be called when the animation is complete. The `callback` should receive the circle `<div>` as an argument.
-
-Here's the example:
+Aquí hay un ejemplo:
 
 ```js
 showCircle(150, 150, 100, div => {
-  div.classList.add('message-ball');
+  div.classList.add("message-ball");
   div.append("Hello, world!");
 });
 ```
@@ -22,4 +21,4 @@ Demo:
 
 [iframe src="solution" height=260]
 
-Take the solution of the task <info:task/animate-circle> as the base.
+Toma la solución de la tarea <info:task/animate-circle> como base.
diff --git a/6-async/01-callbacks/article.md b/6-async/01-callbacks/article.md
index a5a91793e..c8731a9ce 100644
--- a/6-async/01-callbacks/article.md
+++ b/6-async/01-callbacks/article.md
@@ -1,53 +1,51 @@
+# Introducción: callbacks
 
+Muchas acciones en JavaScript son _asíncronas_.
 
-# Introduction: callbacks
-
-Many actions in JavaScript are *asynchronous*.
-
-For instance, take a look at the function `loadScript(src)`:
+Por ejemplo, vemos la función `loadScript(src)`:
 
 ```js
 function loadScript(src) {
-  let script = document.createElement('script');
+  let script = document.createElement("script");
   script.src = src;
   document.head.append(script);
 }
 ```
 
-The purpose of the function is to load a new script. When it adds the `<script src="…">` to the document, the browser loads and executes it.
+El propósito de la función es cargar un nuevo script. Cuando agrega el `<script src="…">` al documento, el navegador lo carga y ejecuta.
 
-We can use it like this:
+Podemos usarlo así:
 
 ```js
 // loads and executes the script
-loadScript('/my/script.js');
+loadScript("/my/script.js");
 ```
 
-The function is called "asynchronously," because the action (script loading) finishes not now, but later.
+La función es llamada "asíncronamente", porque la acción (cargar el script) no termina ahora, pero luego.
 
-The call initiates the script loading, then the execution continues. While the script is loading, the code below may finish executing, and if the loading takes time, other scripts may run meanwhile too.
+La llamada inicia la carga del script, luego la ejecución continua. Mientras el script está cargando, el código de abajo podría terminar su ejecución, y si la carga toma tiempo, otros scripts también pueden correr mientras tanto.
 
 ```js
-loadScript('/my/script.js');
-// the code below loadScript doesn't wait for the script loading to finish
+loadScript("/my/script.js");
+// el código debajo del script no espera a que termine la carga de script
 // ...
 ```
 
-Now let's say we want to use the new script when it loads. It probably declares new functions, so we'd like to run them.
+Ahora, digamos que queremos usar el nuevo script cuando cargue. Probablemente el script declara nuevas funciones, así que nos gustaría ejecutarlas.
 
-But if we do that immediately after the `loadScript(…)` call, that wouldn't work:
+Pero si hacemos eso inmediatamente después de la llamada a `loadScript(…)`, no funcionaría:
 
 ```js
-loadScript('/my/script.js'); // the script has "function newFunction() {…}"
+loadScript('/my/script.js'); // el script tiene una nueva función "function newFunction() {…}"
 
 *!*
-newFunction(); // no such function!
+newFunction(); // no hay tal función!
 */!*
 ```
 
-Naturally, the browser probably didn't have time to load the script. So the immediate call to the new function fails. As of now, the `loadScript` function doesn't provide a way to track the load completion. The script loads and eventually runs, that's all. But we'd like to know when it happens, to use new functions and variables from that script.
+Naturalmente, el navegador probablemente no tuvo el tiempo de cargar el script. Así que el llamado inmediato de la nueva función falla. Actualmente, la función `loadScript` no provee una manera de rastrear que la carga se ha completado. El script carga y eventualmente ejecuta, eso es todo. Pero nos gustaría saber cuando sucede, para usar las funciones y variables de ese script.
 
-Let's add a `callback` function as a second argument to `loadScript` that should execute when the script loads:
+Agreguemos un función `callback` como segundo argumento a `loadScript` que debe ejecutarse cuando el script carga:
 
 ```js
 function loadScript(src, *!*callback*/!*) {
@@ -62,19 +60,19 @@ function loadScript(src, *!*callback*/!*) {
 }
 ```
 
-Now if we want to call new functions from the script, we should write that in the callback:
+Ahora, si queremos cargar una nueva función del script, debemos escribirlo en la función callback:
 
 ```js
 loadScript('/my/script.js', function() {
-  // the callback runs after the script is loaded
-  newFunction(); // so now it works
+  // el callbck corre después que el script ha sido cargado
+  newFunction(); // ahora si funciona
   ...
 });
 ```
 
-That's the idea: the second argument is a function (usually anonymous) that runs when the action is completed.
+Esa es la idea: el segundo argumento es una función (usualmente anónima) que corre cuando la acción se ha completado.
 
-Here's a runnable example with a real script:
+Aquí hay un ejemplo ejecutable con un script real:
 
 ```js run
 function loadScript(src, callback) {
@@ -86,39 +84,39 @@ function loadScript(src, callback) {
 
 *!*
 loadScript('https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js', script => {
-  alert(`Cool, the ${script.src} is loaded`);
-  alert( _ ); // function declared in the loaded script
+  alert(`Genial, el ${script.src} esta cargado`);
+  alert( _ ); // función declarada en el script cargado
 });
 */!*
 ```
 
-That's called a "callback-based" style of asynchronous programming. A function that does something asynchronously should provide a `callback` argument where we put the function to run after it's complete.
+Eso se llama un estilo "callback-based" o "basado en callbacks" de programación asíncrona. Una función que hace algo de manera asíncrona debe provee un argumento `callback` donde pongamos la función que correrá luego que sea completada.
 
-Here we did it in `loadScript`, but of course, it's a general approach.
+Aquí lo hicimos en `loadScript`, pero por supuesto, es un enfoque general.
 
-## Callback in callback
+## Callback en callback
 
-How to load two scripts sequentially: the first one, and then the second one after it?
+Como cargar dos script secuencialmente: el primero, ¿y luego el segundo después de ese?
 
-The natural solution would be to put the second `loadScript` call inside the callback, like this:
+La solución natural sería poner un segundo llamdo a `loadScript` dentro del callback, así:
 
 ```js
 loadScript('/my/script.js', function(script) {
 
-  alert(`Cool, the ${script.src} is loaded, let's load one more`);
+  alert(`Genial, el ${script.src} esta cargado, carguemos uno más`);
 
 *!*
   loadScript('/my/script2.js', function(script) {
-    alert(`Cool, the second script is loaded`);
+    alert(`Genial, el segundo script esta cargado`);
   });
 */!*
 
 });
 ```
 
-After the outer `loadScript` is complete, the callback initiates the inner one.
+Luego que el `loadScript` exterior se ha completado, el callback inicia el interior.
 
-What if we want one more script...?
+¿Qué pasa si queremos cargar un script más?
 
 ```js
 loadScript('/my/script.js', function(script) {
@@ -127,7 +125,7 @@ loadScript('/my/script.js', function(script) {
 
 *!*
     loadScript('/my/script3.js', function(script) {
-      // ...continue after all scripts are loaded
+      // ...continua luego que todos los cripts han cargado
     });
 */!*
 
@@ -136,13 +134,13 @@ loadScript('/my/script.js', function(script) {
 });
 ```
 
-So, every new action is inside a callback. That's fine for few actions, but not good for many, so we'll see other variants soon.
+De esta manera, cada nueva acción esta dentro de un callback. Esto esta bien para unas pocas acciones, pero no tan bien para varias, así que veremos otras variantes pronto.
 
-## Handling errors
+## Manejo de errors
 
-In examples above we didn't consider errors. What if the script loading fails? Our callback should be able to react on that.
+En el ejemplo de arriba, no consideramos errores. ¿Qué pasa su cargar el script falla? Nuestro callback debería poder reaccionar a eso.
 
-Here's an improved version of `loadScript` that tracks loading errors:
+Aquí hay una versión mejorada de `loadScript` que tracker la carga de :
 
 ```js run
 function loadScript(src, callback) {
@@ -158,11 +156,12 @@ function loadScript(src, callback) {
 }
 ```
 
-It calls `callback(null, script)` for successful load and `callback(error)` otherwise.
+Esta versión llama a `callback(null, script)` cuando la carga ha sido exitosa y a `callback(error)` en otro caso.
+
+En uso:
 
-The usage:
 ```js
-loadScript('/my/script.js', function(error, script) {
+loadScript("/my/script.js", function(error, script) {
   if (error) {
     // handle error
   } else {
@@ -171,19 +170,20 @@ loadScript('/my/script.js', function(error, script) {
 });
 ```
 
-Once again, the recipe that we used for `loadScript` is actually quite common. It's called the "error-first callback" style.
+Una vez más, la receta que usamos para `loadScript` es bastante usada. Es llamado estilo "error-first callback".
 
-The convention is:
-1. The first argument of the `callback` is reserved for an error if it occurs. Then `callback(err)` is called.
-2. The second argument (and the next ones if needed) are for the successful result. Then `callback(null, result1, result2…)` is called.
+La conveción es:
 
-So the single `callback` function is used both for reporting errors and passing back results.
+1. El primer argumento del callback `callback` es reservado para un error en caso que ocurra. Entonces se llama`callback(err)`.
+2. El segundo argumento (y los siguientes si se necesita) son para el resultado exitoso. Entonces se llama `callback(null, result1, result2…)`.
 
-## Pyramid of Doom
+De esta manera esta única función `callback` es usada para ambas cosas, reportar errores y pasar de vuelta los resultados.
 
-From the first look, it's a viable way of asynchronous coding. And indeed it is. For one or maybe two nested calls it looks fine.
+## Pirámide de la catástrofe
 
-But for multiple asynchronous actions that follow one after another we'll have code like this:
+Desde una primera mirada, es una menera viable de código asíncrono. Y en sí, lo es. Para uno o dos callbacks anidados luce bien.
+
+Pero para múltiples acciones asíncronas que siguen una después de otra tendremos código como este:
 
 ```js
 loadScript('1.js', function(error, script) {
@@ -202,7 +202,7 @@ loadScript('1.js', function(error, script) {
             handleError(error);
           } else {
   *!*
-            // ...continue after all scripts are loaded (*)
+            // ...continua luego que todos los scripts han cargado (*)
   */!*
           }
         });
@@ -213,32 +213,33 @@ loadScript('1.js', function(error, script) {
 });
 ```
 
-In the code above:
-1. We load `1.js`, then if there's no error.
-2. We load `2.js`, then if there's no error.
-3. We load `3.js`, then if there's no error -- do something else `(*)`.
+En el código de arriba:
+
+1. Cargamos `1.js`, entonces, si no hay error.
+2. Cargamos `2.js`, entonces, si no hay error.
+3. Cargamos `3.js`, entonces, si no hay error -- hacemos algo más `(*)`.
 
-As calls become more nested, the code becomes deeper and increasingly more difficult to manage, especially if we have a real code instead of `...`, that may include more loops, conditional statements and so on.
+Mientras llamadas se hagan más anidades, el código se vuelve más profundo y incrementalmente más difícil de manejar, especialmente si tenemos código real en lugar de `...`, que puede incluír más bucles, declaraciones de condiciones y más.
 
-That's sometimes called "callback hell" or "pyramid of doom."
+Esto es a lo que algunas veces llamamos "infierno de callback" o "pirámide de la catástrofe."
 
 ![](callback-hell.png)
 
-The "pyramid" of nested calls grows to the right with every asynchronous action. Soon it spirals out of control.
+La "pirámide" de llamadas anidadas crece hacia la derecha en cada acción asíncrona. Pronto será una espiral fuera de control.
 
-So this way of coding isn't very good.
+Así que esta manera de codear no es tan buena.
 
-We can try to alleviate the problem by making every action a standalone function, like this:
+Podemos intentar aliviar el problema haciendo cada acción una función We can try to alleviate the problem by making every action a independiente, así:
 
 ```js
-loadScript('1.js', step1);
+loadScript("1.js", step1);
 
 function step1(error, script) {
   if (error) {
     handleError(error);
   } else {
     // ...
-    loadScript('2.js', step2);
+    loadScript("2.js", step2);
   }
 }
 
@@ -247,7 +248,7 @@ function step2(error, script) {
     handleError(error);
   } else {
     // ...
-    loadScript('3.js', step3);
+    loadScript("3.js", step3);
   }
 }
 
@@ -257,15 +258,15 @@ function step3(error, script) {
   } else {
     // ...continue after all scripts are loaded (*)
   }
-};
+}
 ```
 
-See? It does the same, and there's no deep nesting now because we made every action a separate top-level function.
+¿Ves? Hace lo mismo, y no hay anidación profunda ahora porque cada acción es una función separa al nivel más alto.
 
-It works, but the code looks like a torn apart spreadsheet. It's difficult to read, and you probably noticed that. One needs to eye-jump between pieces while reading it. That's inconvenient, especially if the reader is not familiar with the code and doesn't know where to eye-jump.
+Funciona, peor el código luce como unaa hoja de cálculo partida. Es difícil de leer, probablemente ya lo notaste. Uno necesita saltar con la mirada entre las piezas mientras lo lee. Ese es el inconveniente, especiamente si el lector no esta familizarizado con el código y no sabe donde saltar con la mirada.
 
-Also, the functions named `step*` are all of single use, they are created only to avoid the "pyramid of doom." No one is going to reuse them outside of the action chain. So there's a bit of a namespace cluttering here.
+Además, las funcies llamadas `step*` son todas de un solo uso. Sólo son creadas para evitar la "pirámide de la catástrofe". Nadie va a reusarlas fuera de la cadena de acciones. Así que hay un poco de sobrecarga de nombres aquí.
 
-We'd like to have something better.
+Nos gustaría algo mejor.
 
-Luckily, there are other ways to avoid such pyramids. One of the best ways is to use "promises," described in the next chapter.
+Por suerte, hay otras manera de evitar dichas pirámides. Una de las mejores maneras es usar "promesas", que se describen en el siguiente capítulo.

From 887fb406f4bb24162f40970b0a577dd177c81799 Mon Sep 17 00:00:00 2001
From: Tomas Scandalitta <38343557+tscandalitta@users.noreply.github.com>
Date: Fri, 5 Apr 2019 22:40:54 -0300
Subject: [PATCH 2/7] typo  'pero' -> 'sino'

---
 6-async/01-callbacks/article.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/6-async/01-callbacks/article.md b/6-async/01-callbacks/article.md
index c8731a9ce..e352565e9 100644
--- a/6-async/01-callbacks/article.md
+++ b/6-async/01-callbacks/article.md
@@ -21,7 +21,7 @@ Podemos usarlo así:
 loadScript("/my/script.js");
 ```
 
-La función es llamada "asíncronamente", porque la acción (cargar el script) no termina ahora, pero luego.
+La función es llamada "asíncronamente", porque la acción (cargar el script) no termina ahora, sino luego.
 
 La llamada inicia la carga del script, luego la ejecución continua. Mientras el script está cargando, el código de abajo podría terminar su ejecución, y si la carga toma tiempo, otros scripts también pueden correr mientras tanto.
 

From 970f5fa4f0b19f64b21944b3f4651d870b7b2206 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Tue, 2 Jun 2020 17:24:50 -0300
Subject: [PATCH 3/7] Update task.md
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Cocinada por la reestructuración de capítulos para merge y reubicacion
---
 6-async/01-callbacks/01-animate-circle-callback/task.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/6-async/01-callbacks/01-animate-circle-callback/task.md b/6-async/01-callbacks/01-animate-circle-callback/task.md
index ea613cd41..9027dbc7e 100644
--- a/6-async/01-callbacks/01-animate-circle-callback/task.md
+++ b/6-async/01-callbacks/01-animate-circle-callback/task.md
@@ -2,11 +2,11 @@
 
 En esta tarea <info:task/animate-circle> se muestra un círculo animado creciendo.
 
-Ahora, digamos que no necesitamos sólo un círculo, sino también mostrar un mensaje dentro de él. El mensaje debe aparecer _después_ que se ha completado la animación (el círculo ha crecido por completo), de otra manera se vería feo.
+Ahora, digamos que no necesitamos sólo un círculo, sino también mostrar un mensaje dentro de él. El mensaje debe aparecer _después_ de que se ha completado la animación (el círculo ha crecido por completo), de otra manera se vería feo.
 
-El la solución de esta tarea, la función `showCircle(cx, cy, radius)` dibuja el círulo, pero no hay manera de rastrea cuando está listo.
+El la solución de esta tarea, la función `showCircle(cx, cy, radius)` dibuja el círulo, pero no hay manera de rastrear cuándo está listo.
 
-Agrega un argumento callback: `showCircle(cx, cy, radius, callback)` a ser llamado cuando la animación se halla completado. El `callback` debe recibir como un argumonto el `<div>` del círculo.
+Agrega un argumento callback: `showCircle(cx, cy, radius, callback)` para ser llamado cuando la animación se haya completado. El `callback` debe recibir como un argumonto el `<div>` del círculo.
 
 Aquí hay un ejemplo:
 

From f431fa2c48829b629b17fb7f4def1eef507110b7 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Tue, 2 Jun 2020 20:00:52 -0300
Subject: [PATCH 4/7] =?UTF-8?q?article=20fast=20update=20para=20la=20resst?=
 =?UTF-8?q?ructuraci=C3=B3n?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 6-async/01-callbacks/article.md | 38 ++++++++++++++++-----------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/6-async/01-callbacks/article.md b/6-async/01-callbacks/article.md
index e352565e9..4b57a79cb 100644
--- a/6-async/01-callbacks/article.md
+++ b/6-async/01-callbacks/article.md
@@ -23,7 +23,7 @@ loadScript("/my/script.js");
 
 La función es llamada "asíncronamente", porque la acción (cargar el script) no termina ahora, sino luego.
 
-La llamada inicia la carga del script, luego la ejecución continua. Mientras el script está cargando, el código de abajo podría terminar su ejecución, y si la carga toma tiempo, otros scripts también pueden correr mientras tanto.
+La llamada inicia la carga del script, luego la ejecución continúa. Mientras el script está cargando, el código de abajo podría terminar su ejecución, y si la carga toma tiempo, otros scripts también pueden correr mientras tanto.
 
 ```js
 loadScript("/my/script.js");
@@ -43,7 +43,7 @@ newFunction(); // no hay tal función!
 */!*
 ```
 
-Naturalmente, el navegador probablemente no tuvo el tiempo de cargar el script. Así que el llamado inmediato de la nueva función falla. Actualmente, la función `loadScript` no provee una manera de rastrear que la carga se ha completado. El script carga y eventualmente ejecuta, eso es todo. Pero nos gustaría saber cuando sucede, para usar las funciones y variables de ese script.
+Naturalmente, el navegador probablemente no tuvo el tiempo de cargar el script. Así que el llamado inmediato de la nueva función falla. Por ahora, la función `loadScript` no provee una manera de rastrear que la carga se ha completado. El script carga y a la larga ejecuta, eso es todo. Pero nos gustaría saber cuándo sucede, para usar las funciones y variables de ese script.
 
 Agreguemos un función `callback` como segundo argumento a `loadScript` que debe ejecutarse cuando el script carga:
 
@@ -64,8 +64,8 @@ Ahora, si queremos cargar una nueva función del script, debemos escribirlo en l
 
 ```js
 loadScript('/my/script.js', function() {
-  // el callbck corre después que el script ha sido cargado
-  newFunction(); // ahora si funciona
+  // el callbck corre después de que el script ha sido cargado
+  newFunction(); // ahora sí funciona
   ...
 });
 ```
@@ -90,7 +90,7 @@ loadScript('https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js', s
 */!*
 ```
 
-Eso se llama un estilo "callback-based" o "basado en callbacks" de programación asíncrona. Una función que hace algo de manera asíncrona debe provee un argumento `callback` donde pongamos la función que correrá luego que sea completada.
+Eso se llama un estilo "callback-based" o "basado en callbacks" de programación asíncrona. Una función que hace algo de manera asíncrona debe proveer un argumento `callback` donde pongamos la función que correrá después de que sea completada.
 
 Aquí lo hicimos en `loadScript`, pero por supuesto, es un enfoque general.
 
@@ -114,7 +114,7 @@ loadScript('/my/script.js', function(script) {
 });
 ```
 
-Luego que el `loadScript` exterior se ha completado, el callback inicia el interior.
+Después de que el `loadScript` exterior se ha completado, el callback inicia el interior.
 
 ¿Qué pasa si queremos cargar un script más?
 
@@ -125,7 +125,7 @@ loadScript('/my/script.js', function(script) {
 
 *!*
     loadScript('/my/script3.js', function(script) {
-      // ...continua luego que todos los cripts han cargado
+      // ...continua después de que todos los scripts han cargado
     });
 */!*
 
@@ -134,13 +134,13 @@ loadScript('/my/script.js', function(script) {
 });
 ```
 
-De esta manera, cada nueva acción esta dentro de un callback. Esto esta bien para unas pocas acciones, pero no tan bien para varias, así que veremos otras variantes pronto.
+De esta manera, cada nueva acción está dentro de un callback. Esto está bien para unas pocas acciones, pero no tan bien para varias, así que veremos otras variantes pronto.
 
 ## Manejo de errors
 
-En el ejemplo de arriba, no consideramos errores. ¿Qué pasa su cargar el script falla? Nuestro callback debería poder reaccionar a eso.
+En el ejemplo de arriba, no consideramos errores. ¿Qué pasa si al cargar el script falla? Nuestro callback debería poder reaccionar a eso.
 
-Aquí hay una versión mejorada de `loadScript` que tracker la carga de :
+Aquí hay una versión mejorada de `loadScript` que monitorea los errores de carga:
 
 ```js run
 function loadScript(src, callback) {
@@ -172,16 +172,16 @@ loadScript("/my/script.js", function(error, script) {
 
 Una vez más, la receta que usamos para `loadScript` es bastante usada. Es llamado estilo "error-first callback".
 
-La conveción es:
+La convención es:
 
 1. El primer argumento del callback `callback` es reservado para un error en caso que ocurra. Entonces se llama`callback(err)`.
 2. El segundo argumento (y los siguientes si se necesita) son para el resultado exitoso. Entonces se llama `callback(null, result1, result2…)`.
 
 De esta manera esta única función `callback` es usada para ambas cosas, reportar errores y pasar de vuelta los resultados.
 
-## Pirámide de la catástrofe
+## Pirámide de la catástrofe (Pyramid of Doom)
 
-Desde una primera mirada, es una menera viable de código asíncrono. Y en sí, lo es. Para uno o dos callbacks anidados luce bien.
+A primera vista, es una menera viable de código asíncrono. Y en sí, lo es. Para uno o dos callbacks anidados luce bien.
 
 Pero para múltiples acciones asíncronas que siguen una después de otra tendremos código como este:
 
@@ -219,7 +219,7 @@ En el código de arriba:
 2. Cargamos `2.js`, entonces, si no hay error.
 3. Cargamos `3.js`, entonces, si no hay error -- hacemos algo más `(*)`.
 
-Mientras llamadas se hagan más anidades, el código se vuelve más profundo y incrementalmente más difícil de manejar, especialmente si tenemos código real en lugar de `...`, que puede incluír más bucles, declaraciones de condiciones y más.
+Mientras las llamadas se hagan más anidadas, el código se vuelve más profundo e incrementalmente más difícil de manejar, especialmente si tenemos código real en lugar de `...`, que puede incluir más bucles, declaraciones de condiciones y más.
 
 Esto es a lo que algunas veces llamamos "infierno de callback" o "pirámide de la catástrofe."
 
@@ -227,9 +227,9 @@ Esto es a lo que algunas veces llamamos "infierno de callback" o "pirámide de l
 
 La "pirámide" de llamadas anidadas crece hacia la derecha en cada acción asíncrona. Pronto será una espiral fuera de control.
 
-Así que esta manera de codear no es tan buena.
+Así que esta manera de programar no es tan buena.
 
-Podemos intentar aliviar el problema haciendo cada acción una función We can try to alleviate the problem by making every action a independiente, así:
+Podemos intentar aliviar el problema haciendo cada acción una función independiente, así:
 
 ```js
 loadScript("1.js", step1);
@@ -261,11 +261,11 @@ function step3(error, script) {
 }
 ```
 
-¿Ves? Hace lo mismo, y no hay anidación profunda ahora porque cada acción es una función separa al nivel más alto.
+¿Ves? Hace lo mismo, y no hay anidación profunda ahora porque hicimos cada acción en una función separada al nivel más alto.
 
-Funciona, peor el código luce como unaa hoja de cálculo partida. Es difícil de leer, probablemente ya lo notaste. Uno necesita saltar con la mirada entre las piezas mientras lo lee. Ese es el inconveniente, especiamente si el lector no esta familizarizado con el código y no sabe donde saltar con la mirada.
+Funciona, pero el código luse ve como unaa hoja de cálculo partida. Es difícil de leer, probablemente ya lo notaste. Uno necesita saltar con la mirada entre las piezas mientras lo lee. Ese es el inconveniente, especiamente si el lector no esta familizarizado con el código y no sabe dónde saltar con la mirada.
 
-Además, las funcies llamadas `step*` son todas de un solo uso. Sólo son creadas para evitar la "pirámide de la catástrofe". Nadie va a reusarlas fuera de la cadena de acciones. Así que hay un poco de sobrecarga de nombres aquí.
+Además, las funciones llamadas `step*` son todas de un solo uso. Sólo son creadas para evitar la "pirámide de la catástrofe". Nadie va a reusarlas fuera de la cadena de acciones. Así que hay un poco de sobrecarga de nombres aquí.
 
 Nos gustaría algo mejor.
 

From 739d34777cd568818d6fc20a4eed54f7a3bf7316 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Tue, 2 Jun 2020 21:04:02 -0300
Subject: [PATCH 5/7] 1 6 11 async article 1 task

---
 .../01-animate-circle-callback/solution.md    |   0
 11-async/01-callbacks/article.md              | 272 ++++++++++++++++++
 2 files changed, 272 insertions(+)
 create mode 100644 11-async/01-callbacks/01-animate-circle-callback/solution.md
 create mode 100644 11-async/01-callbacks/article.md

diff --git a/11-async/01-callbacks/01-animate-circle-callback/solution.md b/11-async/01-callbacks/01-animate-circle-callback/solution.md
new file mode 100644
index 000000000..e69de29bb
diff --git a/11-async/01-callbacks/article.md b/11-async/01-callbacks/article.md
new file mode 100644
index 000000000..e352565e9
--- /dev/null
+++ b/11-async/01-callbacks/article.md
@@ -0,0 +1,272 @@
+# Introducción: callbacks
+
+Muchas acciones en JavaScript son _asíncronas_.
+
+Por ejemplo, vemos la función `loadScript(src)`:
+
+```js
+function loadScript(src) {
+  let script = document.createElement("script");
+  script.src = src;
+  document.head.append(script);
+}
+```
+
+El propósito de la función es cargar un nuevo script. Cuando agrega el `<script src="…">` al documento, el navegador lo carga y ejecuta.
+
+Podemos usarlo así:
+
+```js
+// loads and executes the script
+loadScript("/my/script.js");
+```
+
+La función es llamada "asíncronamente", porque la acción (cargar el script) no termina ahora, sino luego.
+
+La llamada inicia la carga del script, luego la ejecución continua. Mientras el script está cargando, el código de abajo podría terminar su ejecución, y si la carga toma tiempo, otros scripts también pueden correr mientras tanto.
+
+```js
+loadScript("/my/script.js");
+// el código debajo del script no espera a que termine la carga de script
+// ...
+```
+
+Ahora, digamos que queremos usar el nuevo script cuando cargue. Probablemente el script declara nuevas funciones, así que nos gustaría ejecutarlas.
+
+Pero si hacemos eso inmediatamente después de la llamada a `loadScript(…)`, no funcionaría:
+
+```js
+loadScript('/my/script.js'); // el script tiene una nueva función "function newFunction() {…}"
+
+*!*
+newFunction(); // no hay tal función!
+*/!*
+```
+
+Naturalmente, el navegador probablemente no tuvo el tiempo de cargar el script. Así que el llamado inmediato de la nueva función falla. Actualmente, la función `loadScript` no provee una manera de rastrear que la carga se ha completado. El script carga y eventualmente ejecuta, eso es todo. Pero nos gustaría saber cuando sucede, para usar las funciones y variables de ese script.
+
+Agreguemos un función `callback` como segundo argumento a `loadScript` que debe ejecutarse cuando el script carga:
+
+```js
+function loadScript(src, *!*callback*/!*) {
+  let script = document.createElement('script');
+  script.src = src;
+
+*!*
+  script.onload = () => callback(script);
+*/!*
+
+  document.head.append(script);
+}
+```
+
+Ahora, si queremos cargar una nueva función del script, debemos escribirlo en la función callback:
+
+```js
+loadScript('/my/script.js', function() {
+  // el callbck corre después que el script ha sido cargado
+  newFunction(); // ahora si funciona
+  ...
+});
+```
+
+Esa es la idea: el segundo argumento es una función (usualmente anónima) que corre cuando la acción se ha completado.
+
+Aquí hay un ejemplo ejecutable con un script real:
+
+```js run
+function loadScript(src, callback) {
+  let script = document.createElement('script');
+  script.src = src;
+  script.onload = () => callback(script);
+  document.head.append(script);
+}
+
+*!*
+loadScript('https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js', script => {
+  alert(`Genial, el ${script.src} esta cargado`);
+  alert( _ ); // función declarada en el script cargado
+});
+*/!*
+```
+
+Eso se llama un estilo "callback-based" o "basado en callbacks" de programación asíncrona. Una función que hace algo de manera asíncrona debe provee un argumento `callback` donde pongamos la función que correrá luego que sea completada.
+
+Aquí lo hicimos en `loadScript`, pero por supuesto, es un enfoque general.
+
+## Callback en callback
+
+Como cargar dos script secuencialmente: el primero, ¿y luego el segundo después de ese?
+
+La solución natural sería poner un segundo llamdo a `loadScript` dentro del callback, así:
+
+```js
+loadScript('/my/script.js', function(script) {
+
+  alert(`Genial, el ${script.src} esta cargado, carguemos uno más`);
+
+*!*
+  loadScript('/my/script2.js', function(script) {
+    alert(`Genial, el segundo script esta cargado`);
+  });
+*/!*
+
+});
+```
+
+Luego que el `loadScript` exterior se ha completado, el callback inicia el interior.
+
+¿Qué pasa si queremos cargar un script más?
+
+```js
+loadScript('/my/script.js', function(script) {
+
+  loadScript('/my/script2.js', function(script) {
+
+*!*
+    loadScript('/my/script3.js', function(script) {
+      // ...continua luego que todos los cripts han cargado
+    });
+*/!*
+
+  })
+
+});
+```
+
+De esta manera, cada nueva acción esta dentro de un callback. Esto esta bien para unas pocas acciones, pero no tan bien para varias, así que veremos otras variantes pronto.
+
+## Manejo de errors
+
+En el ejemplo de arriba, no consideramos errores. ¿Qué pasa su cargar el script falla? Nuestro callback debería poder reaccionar a eso.
+
+Aquí hay una versión mejorada de `loadScript` que tracker la carga de :
+
+```js run
+function loadScript(src, callback) {
+  let script = document.createElement('script');
+  script.src = src;
+
+*!*
+  script.onload = () => callback(null, script);
+  script.onerror = () => callback(new Error(`Script load error for ${src}`));
+*/!*
+
+  document.head.append(script);
+}
+```
+
+Esta versión llama a `callback(null, script)` cuando la carga ha sido exitosa y a `callback(error)` en otro caso.
+
+En uso:
+
+```js
+loadScript("/my/script.js", function(error, script) {
+  if (error) {
+    // handle error
+  } else {
+    // script loaded successfully
+  }
+});
+```
+
+Una vez más, la receta que usamos para `loadScript` es bastante usada. Es llamado estilo "error-first callback".
+
+La conveción es:
+
+1. El primer argumento del callback `callback` es reservado para un error en caso que ocurra. Entonces se llama`callback(err)`.
+2. El segundo argumento (y los siguientes si se necesita) son para el resultado exitoso. Entonces se llama `callback(null, result1, result2…)`.
+
+De esta manera esta única función `callback` es usada para ambas cosas, reportar errores y pasar de vuelta los resultados.
+
+## Pirámide de la catástrofe
+
+Desde una primera mirada, es una menera viable de código asíncrono. Y en sí, lo es. Para uno o dos callbacks anidados luce bien.
+
+Pero para múltiples acciones asíncronas que siguen una después de otra tendremos código como este:
+
+```js
+loadScript('1.js', function(error, script) {
+
+  if (error) {
+    handleError(error);
+  } else {
+    // ...
+    loadScript('2.js', function(error, script) {
+      if (error) {
+        handleError(error);
+      } else {
+        // ...
+        loadScript('3.js', function(error, script) {
+          if (error) {
+            handleError(error);
+          } else {
+  *!*
+            // ...continua luego que todos los scripts han cargado (*)
+  */!*
+          }
+        });
+
+      }
+    })
+  }
+});
+```
+
+En el código de arriba:
+
+1. Cargamos `1.js`, entonces, si no hay error.
+2. Cargamos `2.js`, entonces, si no hay error.
+3. Cargamos `3.js`, entonces, si no hay error -- hacemos algo más `(*)`.
+
+Mientras llamadas se hagan más anidades, el código se vuelve más profundo y incrementalmente más difícil de manejar, especialmente si tenemos código real en lugar de `...`, que puede incluír más bucles, declaraciones de condiciones y más.
+
+Esto es a lo que algunas veces llamamos "infierno de callback" o "pirámide de la catástrofe."
+
+![](callback-hell.png)
+
+La "pirámide" de llamadas anidadas crece hacia la derecha en cada acción asíncrona. Pronto será una espiral fuera de control.
+
+Así que esta manera de codear no es tan buena.
+
+Podemos intentar aliviar el problema haciendo cada acción una función We can try to alleviate the problem by making every action a independiente, así:
+
+```js
+loadScript("1.js", step1);
+
+function step1(error, script) {
+  if (error) {
+    handleError(error);
+  } else {
+    // ...
+    loadScript("2.js", step2);
+  }
+}
+
+function step2(error, script) {
+  if (error) {
+    handleError(error);
+  } else {
+    // ...
+    loadScript("3.js", step3);
+  }
+}
+
+function step3(error, script) {
+  if (error) {
+    handleError(error);
+  } else {
+    // ...continue after all scripts are loaded (*)
+  }
+}
+```
+
+¿Ves? Hace lo mismo, y no hay anidación profunda ahora porque cada acción es una función separa al nivel más alto.
+
+Funciona, peor el código luce como unaa hoja de cálculo partida. Es difícil de leer, probablemente ya lo notaste. Uno necesita saltar con la mirada entre las piezas mientras lo lee. Ese es el inconveniente, especiamente si el lector no esta familizarizado con el código y no sabe donde saltar con la mirada.
+
+Además, las funcies llamadas `step*` son todas de un solo uso. Sólo son creadas para evitar la "pirámide de la catástrofe". Nadie va a reusarlas fuera de la cadena de acciones. Así que hay un poco de sobrecarga de nombres aquí.
+
+Nos gustaría algo mejor.
+
+Por suerte, hay otras manera de evitar dichas pirámides. Una de las mejores maneras es usar "promesas", que se describen en el siguiente capítulo.

From ec4cddf69ca3e0392320f13c92c2a661b87677c4 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Tue, 2 Jun 2020 21:43:50 -0300
Subject: [PATCH 6/7] delete article 1 6 async art old

---
 6-async/01-callbacks/article.md | 272 --------------------------------
 1 file changed, 272 deletions(-)
 delete mode 100644 6-async/01-callbacks/article.md

diff --git a/6-async/01-callbacks/article.md b/6-async/01-callbacks/article.md
deleted file mode 100644
index 4b57a79cb..000000000
--- a/6-async/01-callbacks/article.md
+++ /dev/null
@@ -1,272 +0,0 @@
-# Introducción: callbacks
-
-Muchas acciones en JavaScript son _asíncronas_.
-
-Por ejemplo, vemos la función `loadScript(src)`:
-
-```js
-function loadScript(src) {
-  let script = document.createElement("script");
-  script.src = src;
-  document.head.append(script);
-}
-```
-
-El propósito de la función es cargar un nuevo script. Cuando agrega el `<script src="…">` al documento, el navegador lo carga y ejecuta.
-
-Podemos usarlo así:
-
-```js
-// loads and executes the script
-loadScript("/my/script.js");
-```
-
-La función es llamada "asíncronamente", porque la acción (cargar el script) no termina ahora, sino luego.
-
-La llamada inicia la carga del script, luego la ejecución continúa. Mientras el script está cargando, el código de abajo podría terminar su ejecución, y si la carga toma tiempo, otros scripts también pueden correr mientras tanto.
-
-```js
-loadScript("/my/script.js");
-// el código debajo del script no espera a que termine la carga de script
-// ...
-```
-
-Ahora, digamos que queremos usar el nuevo script cuando cargue. Probablemente el script declara nuevas funciones, así que nos gustaría ejecutarlas.
-
-Pero si hacemos eso inmediatamente después de la llamada a `loadScript(…)`, no funcionaría:
-
-```js
-loadScript('/my/script.js'); // el script tiene una nueva función "function newFunction() {…}"
-
-*!*
-newFunction(); // no hay tal función!
-*/!*
-```
-
-Naturalmente, el navegador probablemente no tuvo el tiempo de cargar el script. Así que el llamado inmediato de la nueva función falla. Por ahora, la función `loadScript` no provee una manera de rastrear que la carga se ha completado. El script carga y a la larga ejecuta, eso es todo. Pero nos gustaría saber cuándo sucede, para usar las funciones y variables de ese script.
-
-Agreguemos un función `callback` como segundo argumento a `loadScript` que debe ejecutarse cuando el script carga:
-
-```js
-function loadScript(src, *!*callback*/!*) {
-  let script = document.createElement('script');
-  script.src = src;
-
-*!*
-  script.onload = () => callback(script);
-*/!*
-
-  document.head.append(script);
-}
-```
-
-Ahora, si queremos cargar una nueva función del script, debemos escribirlo en la función callback:
-
-```js
-loadScript('/my/script.js', function() {
-  // el callbck corre después de que el script ha sido cargado
-  newFunction(); // ahora sí funciona
-  ...
-});
-```
-
-Esa es la idea: el segundo argumento es una función (usualmente anónima) que corre cuando la acción se ha completado.
-
-Aquí hay un ejemplo ejecutable con un script real:
-
-```js run
-function loadScript(src, callback) {
-  let script = document.createElement('script');
-  script.src = src;
-  script.onload = () => callback(script);
-  document.head.append(script);
-}
-
-*!*
-loadScript('https://cdnjs.cloudflare.com/ajax/libs/lodash.js/3.2.0/lodash.js', script => {
-  alert(`Genial, el ${script.src} esta cargado`);
-  alert( _ ); // función declarada en el script cargado
-});
-*/!*
-```
-
-Eso se llama un estilo "callback-based" o "basado en callbacks" de programación asíncrona. Una función que hace algo de manera asíncrona debe proveer un argumento `callback` donde pongamos la función que correrá después de que sea completada.
-
-Aquí lo hicimos en `loadScript`, pero por supuesto, es un enfoque general.
-
-## Callback en callback
-
-Como cargar dos script secuencialmente: el primero, ¿y luego el segundo después de ese?
-
-La solución natural sería poner un segundo llamdo a `loadScript` dentro del callback, así:
-
-```js
-loadScript('/my/script.js', function(script) {
-
-  alert(`Genial, el ${script.src} esta cargado, carguemos uno más`);
-
-*!*
-  loadScript('/my/script2.js', function(script) {
-    alert(`Genial, el segundo script esta cargado`);
-  });
-*/!*
-
-});
-```
-
-Después de que el `loadScript` exterior se ha completado, el callback inicia el interior.
-
-¿Qué pasa si queremos cargar un script más?
-
-```js
-loadScript('/my/script.js', function(script) {
-
-  loadScript('/my/script2.js', function(script) {
-
-*!*
-    loadScript('/my/script3.js', function(script) {
-      // ...continua después de que todos los scripts han cargado
-    });
-*/!*
-
-  })
-
-});
-```
-
-De esta manera, cada nueva acción está dentro de un callback. Esto está bien para unas pocas acciones, pero no tan bien para varias, así que veremos otras variantes pronto.
-
-## Manejo de errors
-
-En el ejemplo de arriba, no consideramos errores. ¿Qué pasa si al cargar el script falla? Nuestro callback debería poder reaccionar a eso.
-
-Aquí hay una versión mejorada de `loadScript` que monitorea los errores de carga:
-
-```js run
-function loadScript(src, callback) {
-  let script = document.createElement('script');
-  script.src = src;
-
-*!*
-  script.onload = () => callback(null, script);
-  script.onerror = () => callback(new Error(`Script load error for ${src}`));
-*/!*
-
-  document.head.append(script);
-}
-```
-
-Esta versión llama a `callback(null, script)` cuando la carga ha sido exitosa y a `callback(error)` en otro caso.
-
-En uso:
-
-```js
-loadScript("/my/script.js", function(error, script) {
-  if (error) {
-    // handle error
-  } else {
-    // script loaded successfully
-  }
-});
-```
-
-Una vez más, la receta que usamos para `loadScript` es bastante usada. Es llamado estilo "error-first callback".
-
-La convención es:
-
-1. El primer argumento del callback `callback` es reservado para un error en caso que ocurra. Entonces se llama`callback(err)`.
-2. El segundo argumento (y los siguientes si se necesita) son para el resultado exitoso. Entonces se llama `callback(null, result1, result2…)`.
-
-De esta manera esta única función `callback` es usada para ambas cosas, reportar errores y pasar de vuelta los resultados.
-
-## Pirámide de la catástrofe (Pyramid of Doom)
-
-A primera vista, es una menera viable de código asíncrono. Y en sí, lo es. Para uno o dos callbacks anidados luce bien.
-
-Pero para múltiples acciones asíncronas que siguen una después de otra tendremos código como este:
-
-```js
-loadScript('1.js', function(error, script) {
-
-  if (error) {
-    handleError(error);
-  } else {
-    // ...
-    loadScript('2.js', function(error, script) {
-      if (error) {
-        handleError(error);
-      } else {
-        // ...
-        loadScript('3.js', function(error, script) {
-          if (error) {
-            handleError(error);
-          } else {
-  *!*
-            // ...continua luego que todos los scripts han cargado (*)
-  */!*
-          }
-        });
-
-      }
-    })
-  }
-});
-```
-
-En el código de arriba:
-
-1. Cargamos `1.js`, entonces, si no hay error.
-2. Cargamos `2.js`, entonces, si no hay error.
-3. Cargamos `3.js`, entonces, si no hay error -- hacemos algo más `(*)`.
-
-Mientras las llamadas se hagan más anidadas, el código se vuelve más profundo e incrementalmente más difícil de manejar, especialmente si tenemos código real en lugar de `...`, que puede incluir más bucles, declaraciones de condiciones y más.
-
-Esto es a lo que algunas veces llamamos "infierno de callback" o "pirámide de la catástrofe."
-
-![](callback-hell.png)
-
-La "pirámide" de llamadas anidadas crece hacia la derecha en cada acción asíncrona. Pronto será una espiral fuera de control.
-
-Así que esta manera de programar no es tan buena.
-
-Podemos intentar aliviar el problema haciendo cada acción una función independiente, así:
-
-```js
-loadScript("1.js", step1);
-
-function step1(error, script) {
-  if (error) {
-    handleError(error);
-  } else {
-    // ...
-    loadScript("2.js", step2);
-  }
-}
-
-function step2(error, script) {
-  if (error) {
-    handleError(error);
-  } else {
-    // ...
-    loadScript("3.js", step3);
-  }
-}
-
-function step3(error, script) {
-  if (error) {
-    handleError(error);
-  } else {
-    // ...continue after all scripts are loaded (*)
-  }
-}
-```
-
-¿Ves? Hace lo mismo, y no hay anidación profunda ahora porque hicimos cada acción en una función separada al nivel más alto.
-
-Funciona, pero el código luse ve como unaa hoja de cálculo partida. Es difícil de leer, probablemente ya lo notaste. Uno necesita saltar con la mirada entre las piezas mientras lo lee. Ese es el inconveniente, especiamente si el lector no esta familizarizado con el código y no sabe dónde saltar con la mirada.
-
-Además, las funciones llamadas `step*` son todas de un solo uso. Sólo son creadas para evitar la "pirámide de la catástrofe". Nadie va a reusarlas fuera de la cadena de acciones. Así que hay un poco de sobrecarga de nombres aquí.
-
-Nos gustaría algo mejor.
-
-Por suerte, hay otras manera de evitar dichas pirámides. Una de las mejores maneras es usar "promesas", que se describen en el siguiente capítulo.

From 59e90fcc1982122f9299243865f37171500356c8 Mon Sep 17 00:00:00 2001
From: joaquinelio <joaquinelio@gmail.com>
Date: Tue, 2 Jun 2020 21:44:54 -0300
Subject: [PATCH 7/7] Delete task.md

---
 .../01-animate-circle-callback/task.md        | 24 -------------------
 1 file changed, 24 deletions(-)
 delete mode 100644 6-async/01-callbacks/01-animate-circle-callback/task.md

diff --git a/6-async/01-callbacks/01-animate-circle-callback/task.md b/6-async/01-callbacks/01-animate-circle-callback/task.md
deleted file mode 100644
index 9027dbc7e..000000000
--- a/6-async/01-callbacks/01-animate-circle-callback/task.md
+++ /dev/null
@@ -1,24 +0,0 @@
-# Círculo animado con callbacks
-
-En esta tarea <info:task/animate-circle> se muestra un círculo animado creciendo.
-
-Ahora, digamos que no necesitamos sólo un círculo, sino también mostrar un mensaje dentro de él. El mensaje debe aparecer _después_ de que se ha completado la animación (el círculo ha crecido por completo), de otra manera se vería feo.
-
-El la solución de esta tarea, la función `showCircle(cx, cy, radius)` dibuja el círulo, pero no hay manera de rastrear cuándo está listo.
-
-Agrega un argumento callback: `showCircle(cx, cy, radius, callback)` para ser llamado cuando la animación se haya completado. El `callback` debe recibir como un argumonto el `<div>` del círculo.
-
-Aquí hay un ejemplo:
-
-```js
-showCircle(150, 150, 100, div => {
-  div.classList.add("message-ball");
-  div.append("Hello, world!");
-});
-```
-
-Demo:
-
-[iframe src="solution" height=260]
-
-Toma la solución de la tarea <info:task/animate-circle> como base.