Spanish Translation [ES]

README.es.md

@@ -0,0 +1,113 @@
+# Taller de Javascript Funcional
+
+[![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/nodeschool/discussions?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+<img alt="Discusiones de NodeSchool" src="https://f.cloud.github.com/assets/43438/1368315/63919ad8-3997-11e3-909e-8193f5a94b59.png" align="right">
+
+### Enseñando las propiedades fundamentales de Javascript Funcional.
+
+#### No se requieren librerías (e.j. sin `underscore`), tan solo ES5.
+
+<a href="https://nodei.co/npm/functional-javascript-workshop/" ><img src="https://nodei.co/npm/functional-javascript-workshop.png?downloads=true&stars=true"><br />
+<img src="https://nodei.co/npm-dl/functional-javascript-workshop.png?months=12">
+</a>
+
+[![Gittip](http://img.shields.io/gittip/timoxley.png)](https://www.gittip.com/timoxley/)
+
+## Misión
+
+Muchos recursos de aprendizaje de programación funcional te enseñarán como escribir código al estilo funcional, pero usualmente es altamente indirecto, profundamente abstraído, requiere el entendimiento de complejas relaciones entre llamados de librerías personalizadas y no representa la realidad de como la gente escribe realmente JavaScript.
+
+La meta de este taller es de crear problemas realistas que pueden ser resueltos usando JavaScript nativo y conciso.
+
+**Por favor lee los ejercicios cuidadosamente y sigue todas las instrucciones, están para ayudarte a aprender**
+
+## Instalación y actualización
+
+```
+$ npm install -g functional-javascript-workshop@latest
+```
+
+Algunas instalaciones de npm requieren el uso de `sudo` en el comando de arriba. Es recomendado en vez [re-instalar node/npm para que no necesites usar sudo](https://gist.github.com/isaacs/579814).
+
+## Instrucciones de uso
+
+#### 1. Elige el problema en el que quieras trabajar
+
+Una vez el taller está instalado, corre `functional-javascript-workshop` para imprimir en consola un menú donde puedas seleccionar un problema para trabajar.
+
+```
+$ functional-javascript-workshop
+```
+
+Los problemas están listados en un vago orden de dificultad. Se recomienda completarlos en orden, debido a que ejercicios posteriores serán resueltos por habilidades desarrolladas al resolver problemas previos.
+
+#### 2. Escribiendo tu solución
+
+Una vez has elegido un problema, el taller recordará en cual problema estás trabajando. Usando tu editor preferido, simplemente crea un archivo en el cual escribir tu solución. La mayoría de problemas proveerán algúna plantilla con la cual comenzar. Cópialo de la descripción del problema a tu archivo de solución.
+
+#### 3. Probando tu solución
+
+Usa el comando del taller `run` para apuntar el taller a tu archivo de solución. Tu solución será cargada y pasada a el proceso del problema. Esto usualmente no correrá ningún tipo de validación, simplemente mostrará el resultado del programa.
+
+```
+$ functional-javascript-workshop run misolucion.js
+```
+
+#### 4. Verificando tu solución
+
+Tu solución será verificada contra el resultado de la solución 'oficial'. Si todos los resultados concuerdan, ¡has solucionado el problema correctamente!.
+
+```
+$ functional-javascript-workshop verify misolucion.js
+```
+
+## ¿Problemas?
+
+Retroalimentación y recomendaciones son recibidas, por favor informa de tus problemas en [issues](https://github.com/timoxley/functional-javascript-workshop/issues).
+
+Reseñas completas [como esta](https://github.com/timoxley/functional-javascript-workshop/issues/7) son increíblemente útiles. ¡Más reseñas así por favor!.
+
+Estamos a la búsqueda de más problemas prácticos, así que si tienes un problema en tu día a día el cual fue solucionado simple y elegantemente con alguna técnica de JavaScript funcional, dejanos saber para crear un ejercicio en base a esta.
+
+## Pantallazos
+
+![screen shot 2013-09-27 at 5 18 45 pm](https://f.cloud.github.com/assets/43438/1225514/08c87a70-276a-11e3-8db7-485e3c760373.png)
+![screen shot 2013-09-23 at 9 13 02 pm](https://f.cloud.github.com/assets/43438/1191466/f289f38a-2451-11e3-9ba5-a3c224b5ca97.png)
+
+## Recursos
+
+[Una colección en crecimiento de recursos sobre JavaScript funcional puede ser encontrada en la wiki](https://github.com/timoxley/functional-javascript-workshop/wiki).
+
+## Gracias rvagg
+
+Este tutorial fue construido usando el [framework de talleres](https://github.com/rvagg/workshopper) de rvagg.
+
+## Resumen
+
+```
+ proyecto  : functional-javascript
+ edad del repositorio : 2 años
+ activo   : 50 días
+ commits  : 152
+ archivos    : 70
+ autores  :
+    69	Tim                     45.4%
+    67	Tim Oxley               44.1%
+     3	Sequoia McDowell        2.0%
+     2	ZJ                      1.3%
+     1	Naor Biton              0.7%
+     1	Pavel Kornilov          0.7%
+     1	Steve Teo               0.7%
+     1	Wei Lu                  0.7%
+     1	Yoshua Wuyts            0.7%
+     1	flakyfilibuster         0.7%
+     1	Arvid Andersson         0.7%
+     1	tim walker              0.7%
+     1	Brendon Murphy          0.7%
+     1	Lorcan Coyle            0.7%
+     1	Matthew Hokanson        0.7%
+```
+
+## Licencia
+
+MIT

exercises/async_loops/problem.es.md

@@ -0,0 +1,51 @@
+¡El código está roto!
+
+¡Un desarrollador Java ha subido su terrible código a nuestro proyecto y no lo probó!
+
+```js
+function loadUsers(userIds, load, done) {
+  var users = [];
+  for (var i = 0; i < userIds.length; i++) {
+    users.push(load(userIds[i]));
+  }
+  return users;
+}
+
+module.exports = loadUsers;
+```
+
+# Tarea
+
+¡Arregla este código! El callback debería ser llamado con todos los usuarios cargados. El orden de los usuarios debería concordar el order de los IDs cargados. Debido a que esta función es asíncrona, no nos importa el valor de retorno.
+
+## Parámetros
+
+- `userIds`: Un `Array` de IDs de usuario numéricos.
+- `load`: Una función usada para cargar un objeto de tipo usuario. Recibe un ID numérico y un callback. El callback será llamado con el resultado de cargar el usuario con el ID provisto (puede ser un objeto usuario o `null`).
+- `done`: Una función que recibe un Array de objetos usuario (como los devueltos en `load`).
+
+## Condiciones
+
+- No uses ciclos `for/while` (Array#forEach está bien).
+- El orden de los resultados en `done` debe ser el mismo en el fueron especificados en `userIds`.
+- Los usuarios deberían ser cargado es paralelo, e.j. todo el proceso no debería tomar más de un segundo.
+- No crees ninguna función innecesaria, e.j. funciones auxiliares.
+
+## Pista
+
+- No necesitas organizar para mantener el orden.
+- Usar `console.log` afectará la verificación. Solo usa `console.log` cuando corras `functional-javascript run`.
+
+## Plantilla
+
+```js
+function loadUsers(userIds, load, done) {
+  var users = [];
+  for (var i = 0; i < userIds.length; i++) {
+    users.push(load(userIds[i]));
+  }
+  return users;
+}
+
+module.exports = loadUsers;
+```

exercises/basic_call/problem.es.md

@@ -0,0 +1,105 @@
+JavaScript permite "duck typing", el cual es una forma de tipeado dinámico en el cual las propiedades y métodos de un objeto determinan la validez semántica, en vez de su herencia de una clase en particular o implementación de un interfaz en particular. El nombre del concepto se refiere al "duck test" (prueba de pato), atribuida a James Whitcomb Riley, el cual puede ser formulado así:
+
+> Cuando veo un ave que camina como un pato, nada como un pato y grazna como un pato, digo que esa ave es un pato.
+
+En JavaScript, para escribir programas robustos necesitamos revisar que un objeto es del tipo que necesitamos.
+
+Podemos usar `Object#hasOwnProperty` para saber si un objeto "tiene" una propiedad definida en si mismo (e.j. no heredada desde su prototipo):
+
+```js
+var duck = {
+  quack: function() {
+    console.log("quack");
+  }
+};
+
+duck.hasOwnProperty("quack"); // => true
+```
+
+Nosotros no le dimos a `duck` el método #hasOwnProperty, ¿de donde vino?.
+
+`duck` fue creado con la sintaxis de `{}`, y esta hereda de `Object.prototype`:
+
+```js
+var object = { quack: true };
+
+Object.getPrototypeOf(object) === Object.prototype; // => true
+object.hasOwnProperty("quack"); // => true
+```
+
+¿Pero qué pasa si un objeto no hereda de `Object.prototype`?.
+
+```js
+// crea un objeto con el prototipo de `null`
+var object = Object.create(null);
+object.quack = function() {
+  console.log("quack");
+};
+
+Object.getPrototypeOf(object) === Object.prototype; // => false
+Object.getPrototypeOf(object) === null; // => true
+
+object.hasOwnProperty("quack");
+// => TypeError: Object object has no method 'hasOwnProperty'
+```
+
+Aún podemos usar `hasOwnProperty` de `Object.prototype`, si lo llamamos con el valor de `this` con "algo similar a un objeto". `Function#call` nos permite llamar cualquiera función con valor de `this` alterado.
+
+```js
+// el primer argumento se convierte en el valor de `this`
+// el resto de los argumentos son pasados a la función
+
+Object.prototype.hasOwnProperty.call(object, "quack"); // => true
+```
+
+# Tarea:
+
+Escribe una función `duckCount` que retorne el número de argumentos provistos que contienen una propiedad "quack" definida en ellos. No cuentes valores heredados de los prototipos.
+
+Ejemplo:
+
+```js
+var notDuck = Object.create({ quack: true });
+var duck = { quack: true };
+duckCount(duck, notDuck); // 1
+```
+
+## Argumentos
+
+- Se te proveerán de 0 a 20 argumentos. Cada argumento podría ser de cualquier tipo con cualquier propiedad. Algunos de estos tendrán una propiedad "quack".
+
+## Condiciones
+
+- No uses ciclos `for/while` o `Array#forEach`.
+- No crees ninguna variable como contador/acumulador.
+- No crees ninguna función innecesaria, e.j. funciones auxiliares.
+
+## Pista
+
+- La variable `arguments`, disponible en todas las funciones, es un _Object_ similar a un _Array_ de esta manera:
+
+```js
+{
+  0: 'argument0',
+  1: 'argument1', // etc
+  length: 2
+}
+```
+
+## Recursos
+
+- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call
+- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
+- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/in
+- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice#Array-like
+- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/arguments
+
+## Plantilla
+
+```js
+function duckCount() {
+  // TU SOLUCIÓN
+}
+
+module.exports = duckCount;
+```

exercises/basic_every_some/problem.es.md

@@ -0,0 +1,48 @@
+# Tarea
+
+Retorna una función que tome una lista de usuarios validos, y retorna una función que retorne verdadero si todos los usuarios existen en la lista original de usuarios.
+
+Solo necesitas revisar que los IDs concuerden.
+
+## Ejemplo
+
+```js
+var goodUsers = [{ id: 1 }, { id: 2 }, { id: 3 }];
+
+// `checkUsersValid` es la función que definirás
+var testAllValid = checkUsersValid(goodUsers);
+
+testAllValid([{ id: 2 }, { id: 1 }]);
+// => true
+
+testAllValid([{ id: 2 }, { id: 4 }, { id: 1 }]);
+// => false
+```
+
+## Argumentos
+
+- `goodUsers`: Una lista de usuarios validos.
+
+Usa `array#some` y `Array#every` para verificar que cada usuario pasado a tu función retornada existe en en el array pasado a la función exportada.
+
+## Condiciones
+
+- No uses ciclos `for/while` o `Array#forEach`.
+- No crees ninguna función innecesaria, e.j. funciones auxiliares.
+
+## Recursos
+
+- https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/every
+- https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/some
+
+## Plantilla
+
+```js
+function checkUsersValid(goodUsers) {
+  return function allUsersValid(submittedUsers) {
+    // TU SOLUCIÓN
+  };
+}
+
+module.exports = checkUsersValid;
+```

exercises/basic_filter/problem.es.md

@@ -0,0 +1,50 @@
+# Tarea
+
+Usa `Array#filter` para escribir una función llamada `getShortMessages`.
+
+`getShortMessages` recibe un `array` de objetos con la propiedad `message` y retorna un `array` de mensajes que _tienen menos de 50 caracteres_.
+
+La función debería retornar un `array` conteniendo los mensajes _sin su objeto contenedor_.
+
+## Argumentos
+
+- mensajes: un `Array` de 10 a 100 objetos aleatorios que se ven algo así:
+
+```js
+{
+  message: "Esse id amet quis eu esse aute officia ipsum."; // aleatorio
+}
+```
+
+## Condiciones
+
+- No uses ciclos `for/while` o `Array#forEach`.
+- No crees ninguna función innecesaria, e.j. funciones auxiliares.
+
+## Pista
+
+- ¡Trata de encadenar algunos métodos de `Array`!
+
+## Ejemplo
+
+```
+[ 'Tempor quis esse consequat sunt ea eiusmod.',
+  'Id culpa ad proident ad nulla laborum incididunt.',
+  'Ullamco in ea et ad anim anim ullamco est.',
+  'Est ut irure irure nisi.' ]
+```
+
+## Recursos
+
+- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter
+- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map
+
+## Plantilla
+
+```js
+function getShortMessages(messages) {
+  // TU SOLUCIÓN
+}
+
+module.exports = getShortMessages;
+```