Revert "Prototype methods, objects without __proto__"

Author: vplentinax

1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/solution.md

@@ -1,31 +1,31 @@
 
-El método puede tomar todas las claves enumerables usando `Object.keys` y generar su lista.
+The method can take all enumerable keys using `Object.keys` and output their list.
 
-Para hacer que `toString` no sea enumerable, definámoslo usando un descriptor de propiedad. La sintaxis de `Object.create` nos permite proporcionar un objeto con descriptores de propiedad como segundo argumento.
+To make `toString` non-enumerable, let's define it using a property descriptor. The syntax of `Object.create` allows us to provide an object with property descriptors as the second argument.
 
 ```js run
 *!*
 let dictionary = Object.create(null, {
-  toString: { // define la propiedad toString
-    value() { // el valor es una funcion
+  toString: { // define toString property
+    value() { // the value is a function
       return Object.keys(this).join();
     }
   }
 });
 */!*
 
-dictionary.apple = "Manzana";
-dictionary.__proto__ = "prueba";
+dictionary.apple = "Apple";
+dictionary.__proto__ = "test";
 
-// manzana y __proto__ están en el ciclo
+// apple and __proto__ is in the loop
 for(let key in dictionary) {
-  alert(key); // "manzana", despues "__proto__"
+  alert(key); // "apple", then "__proto__"
 }  
 
-// lista de propiedades separadas por comas por toString
-alert(dictionary); // "manzana,__proto__"
+// comma-separated list of properties by toString
+alert(dictionary); // "apple,__proto__"
 ```
 
-Cuando creamos una propiedad usando un descriptor, sus banderas son `false` por defecto. Entonces, en el código anterior, `dictionary.toString` no es enumerable.
+When we create a property using a descriptor, its flags are `false` by default. So in the code above, `dictionary.toString` is non-enumerable.
 
-Consulte el capítulo [](info:property-descriptors) para su revisión.
+See the the chapter [](info:property-descriptors) for review.

1-js/08-prototypes/04-prototype-methods/2-dictionary-tostring/task.md

@@ -2,30 +2,30 @@ importance: 5
 
 ---
 
-# Añadir toString al diccionario
+# Add toString to the dictionary
 
-Hay un objeto `dictionary`, creado como `Object.create(null)`, para almacenar cualquier par `clave/valor`.
+There's an object `dictionary`, created as `Object.create(null)`, to store any `key/value` pairs.
 
-Agrega el método `dictionary.toString()`, que debería devolver una lista de claves delimitadas por comas. Tu `toString` no debe aparecer al iterar un `for..in` sobre el objeto.
+Add method `dictionary.toString()` into it, that should return a comma-delimited list of keys. Your `toString` should not show up in `for..in` over the object.
 
-Así es como debería funcionar:
+Here's how it should work:
 
 ```js
 let dictionary = Object.create(null);
 
 *!*
-// tu código para agregar el método dictionary.toString 
+// your code to add dictionary.toString method
 */!*
 
-// agregar algunos datos
-dictionary.apple = "Manzana";
-dictionary.__proto__ = "prueba"; // // aquí proto es una propiedad clave común
+// add some data
+dictionary.apple = "Apple";
+dictionary.__proto__ = "test"; // __proto__ is a regular property key here
 
-// solo manzana y __proto__ están en el ciclo
+// only apple and __proto__ are in the loop
 for(let key in dictionary) {
-  alert(key); // "manzana", despues "__proto__"
+  alert(key); // "apple", then "__proto__"
 }  
 
-// tu toString en accion
-alert(dictionary); // "manzana,__proto__"
+// your toString in action
+alert(dictionary); // "apple,__proto__"
 ```

1-js/08-prototypes/04-prototype-methods/3-compare-calls/solution.md

@@ -1,7 +1,7 @@
 
-La primera llamada tiene `this == rabbit`, las otras tienen `this` igual a `Rabbit.prototype`, porque en realidad es el objeto antes del punto.
+The first call has `this == rabbit`, the other ones have `this` equal to `Rabbit.prototype`, because it's actually the object before the dot.
 
-Entonces, solo la primera llamada muestra `Rabbit`, las otras muestran `undefined`:
+So only the first call shows `Rabbit`, other ones show `undefined`:
 
 ```js run
 function Rabbit(name) {
@@ -11,9 +11,9 @@ Rabbit.prototype.sayHi = function() {
   alert( this.name );
 }
 
-let rabbit = new Rabbit("Conejo");
+let rabbit = new Rabbit("Rabbit");
 
-rabbit.sayHi();                        // Conejo
+rabbit.sayHi();                        // Rabbit
 Rabbit.prototype.sayHi();              // undefined
 Object.getPrototypeOf(rabbit).sayHi(); // undefined
 rabbit.__proto__.sayHi();              // undefined

1-js/08-prototypes/04-prototype-methods/3-compare-calls/task.md

@@ -2,9 +2,9 @@ importance: 5
 
 ---
 
-# La diferencia entre llamadas
+# The difference between calls
 
-Creemos un nuevo objeto `rabbit`:
+Let's create a new `rabbit` object:
 
 ```js
 function Rabbit(name) {
@@ -14,10 +14,10 @@ Rabbit.prototype.sayHi = function() {
   alert(this.name);
 };
 
-let rabbit = new Rabbit("Conejo");
+let rabbit = new Rabbit("Rabbit");
 ```
 
-Estas llamadas hacen lo mismo o no?
+These calls do the same thing or not?
 
 ```js
 rabbit.sayHi();