summaryrefslogtreecommitdiffhomepage
path: root/es-es
diff options
context:
space:
mode:
Diffstat (limited to 'es-es')
-rw-r--r--es-es/bash-es.html.markdown196
-rw-r--r--es-es/brainfuck-es.html.markdown87
-rw-r--r--es-es/css-es.html.markdown244
-rw-r--r--es-es/go-es.html.markdown2
-rw-r--r--es-es/javascript-es.html.markdown530
-rw-r--r--es-es/json-es.html.markdown59
-rw-r--r--es-es/julia-es.html.markdown5
-rw-r--r--es-es/livescript-es.html.markdown339
-rw-r--r--es-es/markdown-es.html.markdown252
-rw-r--r--es-es/perl-es.html.markdown120
-rw-r--r--es-es/python-es.html.markdown4
-rw-r--r--es-es/python3-es.html.markdown570
-rw-r--r--es-es/whip-es.html.markdown255
-rw-r--r--es-es/xml-es.html.markdown131
-rw-r--r--es-es/yaml-es.html.markdown151
15 files changed, 2878 insertions, 67 deletions
diff --git a/es-es/bash-es.html.markdown b/es-es/bash-es.html.markdown
new file mode 100644
index 00000000..fb89b2a0
--- /dev/null
+++ b/es-es/bash-es.html.markdown
@@ -0,0 +1,196 @@
+---
+category: tool
+tool: bash
+contributors:
+ - ["Max Yankov", "https://github.com/golergka"]
+ - ["Darren Lin", "https://github.com/CogBear"]
+ - ["Alexandre Medeiros", "http://alemedeiros.sdf.org"]
+ - ["Denis Arh", "https://github.com/darh"]
+ - ["akirahirose", "https://twitter.com/akirahirose"]
+ - ["Anton Strömkvist", "http://lutic.org/"]
+translators:
+ - ["Daniel Zendejas", "https://github.com/danielzendejas"]
+filename: LearnBash-es.sh
+lang: es-es
+---
+
+Tutorial de Shell en español.
+
+Bash es el nombre del shell de unix, el cual también es distribuido como
+el shell del sistema operativo GNU. También es el shell
+por defecto de Linux y Mac OS X. Casi todos los ejemplos abajo pueden
+ser parte de un script shell o ser ejecutados directamente en la terminal.
+
+[Leer más aquí.](http://www.gnu.org/software/bash/manual/bashref.html)
+
+```bash
+#!/bin/bash
+
+# La primera línea del script es el [shebang](http://en.wikipedia.org/wiki/Shebang_(Unix)) que le indica al sistema
+# cómo ejecutar el script.
+# Como te habrás dado cuenta, los comentarios en shell empiezan con #.
+# El shebang también es un comentario.
+
+# Ejemplo sencillo de hola mundo:
+echo ¡Hola mundo!
+
+# Cada comando empieza con una nueva línea, o después de un punto y coma:
+echo 'Esta es la primera línea'; echo 'Esta es la segunda línea'
+
+# Para declarar una variable se hace lo siguiente:
+VARIABLE="Mi string"
+
+# Pero no así:
+VARIABLE = "Mi string"
+
+# Bash decidirá que VARIABLE es un comando a ejecutar, dando un error.
+
+# Usando la variable:
+echo $VARIABLE
+echo "$VARIABLE"
+echo '$VARIABLE'
+
+# Cuando la variable es usada - o asignada, exportada, etcétera - se
+# escribe su nombre sin $. Si se quiere saber el valor de la variables,
+# entonces sí se usa $. Note que ' (comilla simple) no expandirá las
+# variables.
+
+# Sustitución de strings en variables.
+echo ${VARIABLE/Mi/Una}
+# Esto sustituirá la primera cadena "Mi" con "Una".
+
+# Substring de una variable.
+echo ${VARIABLE:0:7}
+# Esto va a regresar sólo los primeros 7 caracteres del valor.
+
+# Valor por defecto de una variable
+echo ${FOO:-"DefaultValueIfFOOIsMissingOrEmpty"}
+# Esto trabaja para null (VARIABLE=), string vacío (VARIABLE=""), }
+# cero (VARIABLE=0) regresa 0
+
+# Variables del sistema:
+# Aquí hay algunas variables incluídas en el sistema:
+echo "El valor de regreso del último programa: $?"
+echo "PID del sistema: $$"
+echo "Número de argumentos: $#"
+echo "Argumentos del script: $@"
+echo "Argumentos del script separados en variables: $1 $2..."
+
+# Para leer un valor del input:
+echo "¿Cuál es tu nombre?"
+read NOMBRE # Note que no necesitamos declarar una variable
+echo ¡Hola, $NOMBRE!
+
+# Tenemos la estructura 'if' usual:
+# use 'man test' para más información sobre condicionales
+if [ $NOMBRE -ne $USER ]
+then
+ echo "Tu nombre es tu usuario."
+else
+ echo "Tu nombre no es tu usuario."
+fi
+
+# También hay ejecuciones condicionadas.
+echo "Siempre ejecutado" || echo "Sólo ejecutado si el primer comando falla"
+echo "Siempre ejecutado" && echo "Sólo ejecutado si el primer comando NO falla"
+
+# Para usar && y || con condicionales, se necesitan
+# múltiples pares de corchetes:
+if [ $NOMBRE == "Steve" ] && [ $EDAD -eq 15 ]
+then
+ echo "Esto correrá si $NOMBRE es Steve Y $EDAD es 15."
+fi
+
+if [ $NOMBRE == "Daniya" ] || [ $NOMBRE == "Zach" ]
+then
+ echo "Esto correrá si $NOMBRE es Daniya O Zach."
+fi
+
+# Las expresiones se denotan con el siguiente formato:
+echo $(( 10 + 5 ))
+
+# A diferencia de otros lenguajes de programación, bash es shell , así que
+# funciona en un contexto de directorio actual. Puedes listar archivos y
+# directorios en un directorio actual con el comando 'ls':
+ls
+
+# Estos comandos tienen opciones que controlan su ejecución:
+ls -l # Lista todos los archivos y directorios en líneas distintas.
+
+# Los resultados del comando anterior pueden ser pasados al siguiente
+# como input. El comando 'grep' filtra el input con los comandos provistos.
+# Así es como podemos listar archivos .txt en el directorio actual:
+ls -l | grep "\.txt"
+
+# Puedes también redireccionar el input y el error lanzado de algún comando.
+python2 hello.py < "input.in"
+python2 hello.py > "output.out"
+python2 hello.py 2> "error.err"
+
+# El error lanzado eliminará el contenido del archivo si es que existe,
+# para después escribir el error. Para que se concatene (en lugar de eliminar)
+# use el comando ">>".
+
+# Los comandos pueden ser sustituidos dentro de otros comandos usando $():
+# El siguiente ejemplo despliega el número de archivos y directorios en el
+# directorio actual.
+echo "Hay $(ls | wc -l) elementos aquí."
+
+# Lo mismo puede ser hecho usando comillas invertidas `` pero no pueden ser
+# anidadas. El método preferido es $().
+echo "Hay `ls | wc -l` elementos aquí."
+
+# Bash usa una estructura de casos similar al switch de Java o C++:
+case "$VARIABLE" in
+ # Lista de patrones que las condiciones deben cumplir:
+ 0) echo "Hay un cero.";;
+ 1) echo "Hay un uno.";;
+ *) echo "No es null.";;
+esac
+
+# Para los ciclos, se usa la estructura 'for'. Cicla para cada argumento dado:
+# El contenido de $VARIABLE se imprime tres veces.
+for VARIABLE in {1..3}
+do
+ echo "$VARIABLE"
+done
+
+# ciclos while:
+while [true]
+do
+ echo "cuerpo del ciclo..."
+ break
+done
+
+# También se pueden definir sub-rutinas (funciones)
+# Definición:
+function miFuncion ()
+{
+ echo "Los argumentos trabajan igual que argumentos de script: $@"
+ echo "Y: $1 $2..."
+ echo "Esto es una función"
+ return 0
+}
+
+# O simplemente:
+miOtraFuncion ()
+{
+ echo "¡Otra forma de declarar funciones!"
+ return 0
+}
+
+# Para llamar a tu función
+foo "Mi nombre es:" $NOMBRE
+
+# Hay muchos comandos útiles que puedes aprender:
+# imprime las últimas 10 líneas del archivo file.txt
+tail -n 10 file.txt
+# imprime las primeras 10 líneas del archivo file.txt
+head -n 10 file.txt
+# ordena las líneas del archivo file.txt
+sort file.txt
+# identifica u omite las líneas repetidas, con -d las reporta
+uniq -d file.txt
+# imprime sólo la primera columna antes de cada ',' en el archivo|
+cut -d ',' -f 1 file.txt
+```
diff --git a/es-es/brainfuck-es.html.markdown b/es-es/brainfuck-es.html.markdown
new file mode 100644
index 00000000..e33d672d
--- /dev/null
+++ b/es-es/brainfuck-es.html.markdown
@@ -0,0 +1,87 @@
+---
+language: brainfuck
+contributors:
+ - ["Prajit Ramachandran", "http://prajitr.github.io/"]
+ - ["Mathias Bynens", "http://mathiasbynens.be/"]
+translators:
+ - ["Daniel Zendejas", "https://github.com/DanielZendejas"]
+lang: es-es
+---
+
+Brainfuck (con mayúscula sólo al inicio de una oración) es un
+lenguaje de programación mínimo, computacionalmente universal
+en tamaño con sólo 8 comandos.
+
+```
+
+Cualquier caracter que no sea "><+-.,[]" (sin incluir las comillas)
+será ignorado.
+
+Brainfuck es representado por un arreglo de 30,000 celdas inicializadas
+en cero y un apuntador en la celda actual.
+
+Existen ocho comandos:
+
++ : Incrementa 1 al valor de la celda actual.
+- : Decrementa 1 al valor de la celda actual.
+> : Mueve el apuntador a la siguiente celda. (a la derecha)
+< : Mueve el apuntador a la celda anterior. (a la izquierda)
+. : Imprime el valor en ASCII de la celda actual (i.e. 65 = 'A')
+, : Lee un caracter como input y lo escribe en la celda actual.
+[ : Si el valor en la celda actual es cero mueve el apuntador
+ hasta el primer ']' que encuentre. Si no es cero sigue a la
+ siguiente instrucción.
+] : Si el valor en la celda actual es cero, entonces sigue con
+ la siguiente instrucción. Si no entonces mueve el apuntador
+ hacia atrás hasta encontrar el primer '['.
+
+[ y ] forman un while. Obviamente, deben estar balanceados.
+
+Ahora unos ejemplos de programas escritos con brainfuck.
+
+++++++ [ > ++++++++++ < - ] > +++++ .
+
+Este programa imprime la letra 'A'. Primero, incrementa la celda #1 a
+6. La celda #1 será usada para hacer los ciclos. Después entra al ciclo
+([) y se mueve a la celda #2 (>). Después incrementa la celda #2 10 veces,
+y se regresa a la celda #1 (<), para después decrementarla en 1 (-).
+Este ciclo ocurre 6 veces (le toma 6 decrementos a la celda #1 volverse 0),
+cuando esto pasa se salta a (]) y continúa.
+
+En este punto estamos en la celda #1, que tiene un valor de 0, mientras
+que la celda #2 tiene un valor de 60. Nos movemos a la celda #2 (>),
+la incrementamos 5 veces para tener un valor de 65 y luego imprimimos
+el valor de la celda #2 (.). 65 es 'A' en ASCII así que la letra 'A'
+se imprime.
+
+, [ > + < - ] > .
+
+Este programa lee un caracter del input y lo copia en la celda #2 (,).
+Después empieza un ciclo. Nos movemos a la celda #2 (>) e incrementamos su
+valor (+). Regresamos a la celda #1 y decrementamos su valor en 1 (-).
+Esto continúa hasta que la celda #1 contenga un cero. Cuando #1 contenga un
+cero la celda #2 tendrá el valor inicial de #1. Como este ciclo siempre
+terminara en la celda #1 nos movemos a la celda #2 e imprimimos (.).
+
+Ten en mente que los espacios son sólo para fines de legibilidad.
+Es lo mismo escribir el ejemplo de arriba que esto:
+,[>+<-]>.
+
+Intenta descrifrar lo que hace este programa:
+
+,>,< [ > [ >+ >+ << -] >> [- << + >>] <<< -] >>
+
+Este programa toma dos números como input y los multiplica.
+
+Primero recibe dos números del usuario. Luego empieza el ciclo externo,
+condicionado en la celda #1. Luego se mueve a la celda #2, comenzando
+el ciclo interno condicionado en la celda #2 incrementando la celda #3.
+Sin embargo viene un problema: El ciclo interior no funcionará nuevamente
+hasta la próxima vez. Para resolver este problema también incrementamos la
+celda #4 y luego copiamos la celda #4 a la celda #2. La celda #3 contiene
+el resultado.
+```
+Y eso es brainfuck. ¿No tan difícil o sí? Como diversión, puedes escribir
+tu propio intérprete de brainfuck o tu propio programa en brainfuck. El
+intérprete es relativamente sencillo de hacer, pero si eres masoquista,
+intenta construir tu proprio intérprete de brainfuck... en brainfuck.
diff --git a/es-es/css-es.html.markdown b/es-es/css-es.html.markdown
new file mode 100644
index 00000000..31000785
--- /dev/null
+++ b/es-es/css-es.html.markdown
@@ -0,0 +1,244 @@
+---
+language: css
+filename: learncss-es.css
+contributors:
+ - ["Mohammad Valipour", "https://github.com/mvalipour"]
+ - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+ - ["Daniel Zendejas","https://github.com/DanielZendejas"]
+lang: es-es
+---
+
+Tutorial de CSS en español
+
+En los primeros días de la web no había elementos visuales, todo
+era texto plano. Pero después, con el desarrollo de los navegadores,
+las páginas con contenido visual empezaron a ser más comunes.
+CSS es el lenguaje estándar que existe para separar el contenido
+(HTML) y el aspecto visual de las páginas web.
+
+Lo que CSS hace es proveer con una sintaxis que te permite apuntar a distintos
+elementos HTML y asignarles diferentes propiedades visuales.
+
+CSS, como cualquier otro lenguaje, tiene múltiples versiones. Aquí nos enfocamos
+en CSS 2.0. No es la versión más reciente pero sí la más soportada y compatible.
+
+**NOTA:** Como los resultados de CSS son efectos visuales, para aprenderlo,
+necesitarás probar todo tipo de cosas en ambientes como
+[dabblet](http://dabblet.com/). Este artículo se enfoca, principalmente, en
+la sintaxis y consejos generales.
+
+```css
+/* ¡Los comentarios aparecen dentro de diagonal-asterisco, justo como esta línea! */
+
+/* ####################
+ ## SELECTORES
+ ####################*/
+
+/* Generalmente, la sentencia principal en CSS es muy simple. */
+selector { propiedad: valor; /* más propiedades separados por punto y coma...*/ }
+
+/* El selector es usado para apuntar a (seleccionar) un elemento en la página.
+
+¡Puedes apuntar a todos los elementos en la página con el asterisco! */
+* { color:red; }
+
+/*
+Dado un elemento como este en la página:
+
+<div class='una-clase clase2' id='unaId' attr='valor' />
+*/
+
+/* puedes seleccionar el <div> por el nombre de su clase */
+.una-clase { }
+
+/*¡O por sus dos clases! */
+.una-clase.clase2 { }
+
+/* O por el nombre de su elemento */
+div { }
+
+/* O por su Id */
+#unaId { }
+
+/* ¡O por el hecho de que tiene un atributo! */
+[attr] { font-size:smaller; }
+
+/* O por el hecho de que el atributo tiene un valor determinado */
+[attr='valor'] { font-size:smaller; }
+
+/* Empieza con un valor ('val' en este caso)*/
+[attr^='val'] { font-size:smaller; }
+
+/* O termina con un valor ('or' en este caso) */
+[attr$='or'] { font-size:smaller; }
+
+/* O incluso contiene un valor ('lo' en este caso) */
+[attr~='lo'] { font-size:smaller; }
+
+/*Más importante, puedes combinar estos criterios de búsqueda entre sí.
+No debe existir ningún espacio entre estas partes porque hace que el
+significado cambie.*/
+div.una-clase[attr$='or'] { }
+
+/* También puedes seleccionar un elemento HTML basándote en sus padres*/
+
+/* Un elemento que es hijo directo de otro elemento (Seleccionado de la forma que
+vimos anteriormente) */
+
+div.un-padre > .nombre-clase {}
+
+/* O cualquiera de sus ancestros en la jerarquía*/
+/* La siguiente sentencia selecciona a cualquier elemento que tenga una clase
+"nombre-clase" y sea hijo de un div con clase "un-padre" EN CUALQUIER PROFUNDIDAD*/
+div.un-padre .nombre-clase {}
+
+/* advertencia: el mismo selector sin espacio tiene otro significado. ¿Puedes
+identificar la diferencia?*/
+
+/* También puedes seleccionar un elemento basado en su hermano inmediato previo*/
+.yo-estoy-antes + .este-elemento { }
+
+/*o cualquier hermano previo */
+.yo-soy-cualquiera-antes ~ .estes-elemento {}
+
+/* Existen algunas pseudo-clases que permiten seleccionar un elemento
+basado en el comportamiendo de la página (a diferencia de la estructura de
+la página) */
+
+/* Por ejemplo, para cuando pasas el mouse por encima de un elemento */
+:hover {}
+
+/* o una liga visitada*/
+:visited {}
+
+/* o una liga no visitada aún*/
+:link {}
+
+/* o un elemento de un formulario que esté seleccionado */
+:focus {}
+
+
+/* ####################
+ ## PROPIEDADES
+ ####################*/
+
+selector {
+
+ /* Unidades */
+ width: 50%; /* en porcentaje */
+ font-size: 2em; /* dos veces el tamaño de la fuente actual */
+ width: 200px; /* en pixeles */
+ font-size: 20pt; /* en puntos */
+ width: 5cm; /* en centimetros */
+ width: 50mm; /* en milimetros */
+ width: 5in; /* en pulgadas */
+
+ /* Colores */
+ background-color: #F6E; /* en hexadecimal corto */
+ background-color: #F262E2; /* en hexadecimal largo */
+ background-color: tomato; /* puede ser un color con nombre */
+ background-color: rgb(255, 255, 255); /* en rgb */
+ background-color: rgb(10%, 20%, 50%); /* en rgb percent */
+ background-color: rgba(255, 0, 0, 0.3); /* en rgb semi-transparente (con valor alfa)*/
+
+ /* Imagenes */
+ background-image: url(/ruta-a-la-imagen/imagen.jpg);
+
+ /* Fuentes */
+ font-family: Arial;
+ font-family: "Courier New"; /* si el nombre contiene espacios, debe ir entre comillas */
+ font-family: "Courier New", Trebuchet, Arial; /* si la primera fuente no se encontró
+ entonces se busca la seguna, o la tercera, así recursivamente*/
+}
+
+```
+
+## Uso
+
+Guarda cualquier CSS que quieras en un archivo con extensión `.css`.
+
+```xml
+<!-- Necesitas incluir tu archivo CSS en el elemento <head> de tu HTML: -->
+<link rel='stylesheet' type='text/css' href='ruta/archivoDeEstilos.css' />
+
+<!--
+también puedes incluir CSS dentro del archivo HTML. Esta no es una buena práctica
+y debe ser evitada.
+-->
+<style>
+ selector { propiedad:valor; }
+</style>
+
+<!--
+También se pueden aplicar propiedades al elemento directamente.
+Esta práctica también debe ser evitada a toda costa
+-->
+<div style='propiedad:valor;'>
+</div>
+
+```
+
+## Preferencia y orden
+
+Como te habrás dado cuenta un elemento puede ser seleccionado por más
+de un selector. En este caso alguna de las reglas cobra preferencia
+sobre las otras:
+
+Dado el siguiente CSS:
+
+```css
+/*A*/
+p.clase1[attr='valor']
+
+/*B*/
+p.clase1 {}
+
+/*C*/
+p.clase2 {}
+
+/*D*/
+p {}
+
+/*E*/
+p { propiedad: valor !important; }
+
+```
+
+Y el siguiente HTML:
+
+```xml
+<p style='/*F*/ propiedad:valor;' class='clase1 clase2' attr='valor'>
+</p>
+```
+
+El orden respetado es el siguiente:
+Recuerda, la preferencia es por cada **property**, no para el bloque completo.
+
+* `E` tiene la preferencia más elevada gracias a la palabra `!important`.
+ Es recomendado evitar esto a menos que sea estrictamente necesario incluirlo.
+* `F` le sigue, porque es estilo incrustado directamente en el HTML.
+* `A` le sigue, porque es más específico que cualquier otra opción.
+ más específico = más especificadores. Aquí hay tres especificadores: elemento `p` +
+ nombre de la clase `clase1` + un atributo `attr='valor'`
+* `C` le sigue. Aunque tiene el mismo número de especificadores como `B`
+ pero aparece después.
+* Luego va `B`
+* y al final `D`.
+
+## Compatibilidad
+
+La mayoría de las funcionalidades de CSS2 (y gradualmente de CSS3) son compatibles
+en todos los navegadores y dispositivos. Pero siempre es vital tener en mente la
+compatibilidad y disponibilidad del CSS que uses con respecto a los navegadores
+y dispositivos para los que desarrolles.
+
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) es una excelente referencia para esto.
+
+## Referencias
+
+* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
+* [QuirksMode CSS](http://www.quirksmode.org/css/)
+* [Z-Index - The stacking context](https://developer.mozilla.org/en-US/docs/Web/Guide/CSS/Understanding_z_index/The_stacking_context)
+
diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
index e788e810..86de33ec 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -77,7 +77,7 @@ func learnTypes() {
saltos de línea.` // mismo tipo cadena
// Literal no ASCII. Los fuentes de Go son UTF-8.
- g := 'Σ' // Tipo rune, un alias de uint32, alberga un punto unicode.
+ g := 'Σ' // Tipo rune, un alias de int32, alberga un punto unicode.
f := 3.14195 // float64, el estándar IEEE-754 de coma flotante 64-bit.
c := 3 + 4i // complex128, representado internamente por dos float64.
// Sintaxis Var con inicializadores.
diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
new file mode 100644
index 00000000..a1348508
--- /dev/null
+++ b/es-es/javascript-es.html.markdown
@@ -0,0 +1,530 @@
+---
+language: javascript
+contributors:
+ - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+ - ["Ariel Krakowski", "http://www.learneroo.com"]
+translators:
+ - ["Daniel Zendejas","https://github.com/DanielZendejas"]
+filename: javascript-es.js
+lang: es-es
+---
+Tutorial de JavaScript en español.
+
+JavaScript fue creado por Brendan Eich en 1995 mientras trabajaba en Netscape.
+Su intención original era crear un lenguaje simple para sitios web, complementándolo
+con Java para aplicaciones más complejas. Debido a su integracion estrecha con sitios
+web y soporte por defecto de los navegadores modernos se ha vuelto mucho más común
+para front-end que Java.
+
+JavaScript no sólo se limita a los navegadores web:
+* Node.js: Un proyecto que provee con un ambiente para el motor V8 de Google Chrome.
+
+¡La retroalimentación es bienvenida! Puedes encontrarme en:
+[@adambrenecki](https://twitter.com/adambrenecki), o
+[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
+
+```js
+// Los comentarios son como en C. Los comentarios de una sola línea comienzan con //,
+/* y los comentarios multilínea comienzan
+ y terminan con */
+
+// Cada sentencia puede ser terminada con punto y coma ;
+hazAlgo();
+
+// ... aunque no es necesario, ya que el punto y coma se agrega automaticamente
+// cada que se detecta una nueva línea, a excepción de algunos casos.
+hazAlgo()
+
+// Dado que esta práctica puede llevar a resultados inesperados, seguiremos agregando
+// punto y coma en esta guía.
+
+///////////////////////////////////
+// 1. Números, Strings y Operadores
+
+// JavaScript tiene un solo tipo de número (doble de 64-bit IEEE 754).
+// Así como con Lua, no te espantes por la falta de enteros: los dobles tienen 52 bits
+// de mantisa, lo cual es suficiente para guardar enteros de hasta 9✕10¹⁵.
+3; // = 3
+1.5; // = 1.5
+
+// Toda la aritmética básica funciona como uno esperaría.
+1 + 1; // = 2
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Incluyendo divisiones con resultados no enteros.
+5 / 2; // = 2.5
+
+// Las operaciones con bits también funcionan; cuando ejecutas una operación con bits
+// el número flotante se convierte a entero con signo *hasta* 32 bits.
+1 << 2; // = 4
+
+// La jerarquía de las operaciones se aplica con paréntesis.
+(1 + 3) * 2; // = 8
+
+// Hay tres casos especiales de valores con los números:
+Infinity; // por ejemplo: 1/0
+-Infinity; // por ejemplo: -1/0
+NaN; // por ejemplo: 0/0
+
+// También hay booleanos:
+true;
+false;
+
+// Los Strings se pueden crear con ' o ".
+'abc';
+"Hola, mundo";
+
+// La negación se aplica con la expresión !
+!true; // = false
+!false; // = true
+
+// Para comprobar una igualdad se usa ==
+1 == 1; // = true
+2 == 1; // = false
+
+// Para comprobar una desigualdad se usa !=
+1 != 1; // = false
+2 != 1; // = true
+
+// Más comparaciones
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Los Strings se concatenan con +
+"¡Hola " + "mundo!"; // = "¡Hola mundo!"
+
+// y se comparan con < y con >
+"a" < "b"; // = true
+
+// Los tipos no importan con el operador ==...
+"5" == 5; // = true
+
+// ...a menos que uses ===
+"5" === 5; // = false
+
+// Los Strings funcionan como arreglos de caracteres
+// Puedes accesar a cada caracter con la función charAt()
+"Este es un String".charAt(0); // = 'E'
+
+// ...o puedes usar la función substring() para acceder a pedazos más grandes
+"Hola Mundo".substring(0, 4); // = "Hola"
+
+// length es una propiedad, así que no uses ()
+"Hola".length; // = 4
+
+// También hay null y undefined
+null; // usado para indicar una falta de valor deliberada
+undefined; // usado para indicar que un valor no está presente actualmente
+ // (aunque undefined es un valor en sí mismo)
+
+// false, null, undefined, NaN, 0 y "" es false; todo lo demás es true.
+// Note que 0 is false y "0" es true, a pesar de que 0 == "0".
+// Aunque 0 === "0" sí es false.
+
+///////////////////////////////////
+// 2. Variables, Arreglos y Objetos
+
+// Las variables se declaran con la palabra var. JavaScript cuenta con tipado dinámico,
+// así que no se necesitan aplicar tipos. La asignación se logra con el operador =.
+var miPrimeraVariable = 5;
+
+// si no escribes la palabra var no se marcará ningún error...
+miSegundaVariable = 10;
+
+// ...pero tu variable se declarará en el ámbito global, no en el ámbito
+// en el que se definió.
+
+// Las variables que no están aún asignadas tienen el valor undefined.
+var miTerceraVariable; // = undefined
+
+// Existen atajos para realizar operaciones aritméticas:
+miPrimeraVariable += 5; // equivalente a miPrimeraVariable = miPrimeraVariable + 5;
+ // miPrimeraVariable ahora es 10
+miPrimeraVariable *= 10; // ahora miPrimeraVariable es 100
+
+// Y atajos aún más cortos para sumar y restar 1
+miPrimeraVariable++; // ahora miPrimeraVariable es 101
+miPrimeraVariable--; // de vuelta a 100
+
+// Los arreglos son listas ordenadas de valores, de cualquier tipo.
+var miArreglo = ["Hola", 45, true];
+
+// Los miembros de un arreglo pueden ser accesados con la sintaxis
+// de indices dentro de corchetes [].
+// Los índices empiezan en cero.
+miArreglo[1]; // = 45
+
+// Los arreglos son mutables y pueden cambiar de longitud.
+miArreglo.push("Mundo");
+miArreglo.length; // = 4
+
+// Agregar/Modificar en un determinado índice
+miArreglo[3] = "Hola";
+
+// Los objetos en JavaScript son equivalentes a los 'diccionarios' o 'mapas' en otros
+// lenguajes: una colección de pares llave/valor desordenada.
+var miObjeto = {llave1: "Hola", llave2: "Mundo"};
+
+// Las llaves son strings, pero no se necesitan las comillas si son un identificador
+// válido de JavaScript. Los valores pueden ser de cualquier tipo.
+var miObjeto = {miLlave: "miValor", "mi otra llave": 4};
+
+// Los atributos de los objetos también pueden ser accesadas usando
+// la sintaxis de corchetes,
+miObjeto["mi otra llave"]; // = 4
+
+// ... o usando la sintaxis de punto, dado que la llave es un identificador válido.
+miObjeto.miLlave; // = "miValor"
+
+// Los objetos son mutables; los valores pueden ser cambiados y se pueden
+// agregar nuevas llaves.
+miObjeto.miTerceraLlave = true;
+
+// Si intentas accesar con una llave que aún no está asignada tendrás undefined.
+miObjeto.miCuartaLlave; // = undefined
+
+///////////////////////////////////
+// 3. Lógica y estructura de control
+
+// La sintaxis de esta sección es casi idéntica a la de Java.
+
+// La estructura if funciona de la misma forma.
+var contador = 1;
+if (contador == 3){
+ // evaluar si contador es igual a 3
+} else if (contador == 4){
+ // evaluar si contador es igual a 4
+} else {
+ // evaluar si contador no es igual a 3 ni a 4
+}
+
+// De la misma forma la estructura while.
+while (true){
+ // ¡Loop infinito!
+}
+
+// La estructura Do-while es igual al while, excepto que se ejecuta al menos una vez.
+var input
+do {
+ input = conseguirInput();
+} while (!esValido(input))
+
+// la esctructura for es la misma que la de C y Java:
+// inicialización; condición; iteración.
+for (var i = 0; i < 5; i++){
+ // correrá cinco veces
+}
+
+// && es un "y" lógico, || es un "o" lógico
+var casa = {tamano:"grande",casa:"color"};
+if (casa.tamano == "grande" && casa.color == "azul"){
+ casa.contiene = "oso";
+}
+if (color == "rojo" || color == "azul"){
+ // el color es rojo o azul
+}
+
+// && y || "corto circuito", lo cual es útil para establecer valores por defecto.
+var nombre = otroNombre || "default";
+
+
+// la estructura switch usa === para sus comparaciones
+// usa 'break' para terminar cada caso
+// o los casos después del caso correcto serán ejecutados también.
+calificacion = 'B';
+switch (calificacion) {
+ case 'A':
+ console.log("Excelente trabajo");
+ break;
+ case 'B':
+ console.log("Buen trabajo");
+ break;
+ case 'C':
+ console.log("Puedes hacerlo mejor");
+ break;
+ default:
+ console.log("Muy mal");
+ break;
+}
+
+
+///////////////////////////////////
+// 4. Funciones, ámbitos y closures
+
+// Las funciones en JavaScript son declaradas con la palabra clave "function".
+function miFuncion(miArgumentoString){
+ return miArgumentoString.toUpperCase(); //la funcion toUpperCase() vuelve todo
+ // el String a mayúsculas
+}
+miFuncion("foo"); // = "FOO"
+
+// Note que el valor a ser regresado debe estar en la misma línea que la
+// palabra clave 'return', de otra forma la función siempre regresará 'undefined'
+// debido a la inserción automática de punto y coma.
+function miFuncion()
+{
+ return // <- punto y coma insertado aquí automáticamente
+ {
+ estaEsUna: 'propiedad'
+ }
+}
+miFuncion(); // = undefined al mandar a llamar la función
+
+// Las funciones en JavaScript son de primera clase, así que pueden ser asignadas
+// a variables y pasadas a otras funciones como argumentos - por ejemplo:
+function miFuncion(){
+ // este código será llamado cada cinco segundos
+}
+setTimeout(miFuncion, 5000);
+// Note: setTimeout no es parte de JS, pero lo puedes obtener de los browsers
+// y Node.js.
+
+// Es posible declarar funciones sin nombre - se llaman funciones anónimas
+// y se definen como argumentos de otras funciones.
+setTimeout(function(){
+ // este código se ejecuta cada cinco segundos
+}, 5000);
+
+// JavaScript tiene ámbitos de funciones; las funciones tienen su propio ámbito pero
+// otros bloques no.
+if (true){
+ var i = 5;
+}
+i; // = 5 - en un lenguaje que da ámbitos por bloque esto sería undefined, pero no aquí.
+
+// Este conlleva a un patrón de diseño común llamado "ejecutar funciones anónimas
+//inmediatamente", que preveé variables temporales de fugarse al ámbito global
+(function(){
+ var temporal = 5;
+ // Podemos accesar al ámbito global asignando al 'objeto global', el cual
+ // en un navegador siempre es 'window'. El objeto global puede tener
+ // un nombre diferente en ambientes distintos, por ejemplo Node.js .
+ window.permanente = 10;
+})();
+temporal; // da ReferenceError
+permanente; // = 10
+
+// Una de las características más útiles de JavaScript son los closures.
+// Si una función es definida dentro de otra función, la función interna tiene acceso
+// a todas las variables de la función externa, incluso aunque la función
+// externa ya haya terminado.
+function decirHolaCadaCincoSegundos(nombre){
+ var texto = "¡Hola, " + nombre + "!";
+ // Las funciones internas son puestas en el ámbito local por defecto
+ // como si fueran declaradas con 'var'.
+ function interna(){
+ alert(texto);
+ }
+ setTimeout(interna, 5000);
+ // setTimeout es asíncrono, así que la funcion decirHolaCadaCincoSegundos
+ // terminará inmediatamente, y setTimeout llamará a interna() a los cinco segundos
+ // Como interna está "cerrada dentro de" decirHolaCadaCindoSegundos, interna todavía tiene
+ // acceso a la variable 'texto' cuando es llamada.
+}
+decirHolaCadaCincoSegundos("Adam"); // mostrará una alerta con "¡Hola, Adam!" en 5s
+
+///////////////////////////////////
+// 5. Más sobre objetos; constructores y prototipos
+
+// Los objetos pueden contener funciones.
+var miObjeto = {
+ miFuncion: function(){
+ return "¡Hola Mundo!";
+ }
+};
+miObjeto.miFuncion(); // = "¡Hola Mundo!"
+
+// Cuando las funciones de un objeto son llamadas, pueden accesar a las variables
+// del objeto con la palabra clave 'this'.
+miObjeto = {
+ miString: "¡Hola Mundo!",
+ miFuncion: function(){
+ return this.miString;
+ }
+};
+miObjeto.miFuncion(); // = "¡Hola Mundo!"
+
+// Las funciones de un objeto deben ser llamadas dentro del contexto de ese objeto.
+var miFuncion = myObj.miFuncion;
+miFuncion(); // = undefined
+
+// Una función puede ser asignada al objeto y ganar acceso a él gracias a esto,
+// incluso si no estaba dentro del objeto cuando este se definió.
+var miOtraFuncion = function(){
+ return this.miString.toUpperCase();
+}
+miObjeto.miOtraFuncion = myOtherFunc;
+miObjeto.miOtraFuncion(); // = "¡HOLA MUNDO!"
+
+// Podemos especificar el contexto en el que una función será llamada con los comandos
+// 'call' o 'apply'.
+
+var otraFuncion = function(otroString){
+ return this.miString + otroString;
+}
+otraFuncion.call(miObjeto, " y hola Luna!"); // = "¡Hola Mundo! y hola Luna!"
+
+// 'apply' es casi idéntico, pero recibe un arreglo como argumento.
+
+otraFuncion.apply(miObjeto, [" y hola Sol!"]); // = "¡Hola Mundo! y hola Sol!"
+
+// Esto es útil cuando estás trabajando con una función que acepta una secuencia de
+// argumentos y quieres pasar un arreglo.
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// Pero 'call' y 'apply' sólo son temporales. Cuando queremos que se quede, usamos bind.
+
+var funcionUnida = otraFuncion.bind(miObjeto);
+funcionUnida(" y hola Saturno!"); // = "¡Hola Mundo! y hola Saturno!"
+
+// Bind también puede ser usada para aplicar parcialmente (curry) una función.
+
+var producto = function(a, b){ return a * b; }
+var porDos = producto.bind(this, 2);
+porDos(8); // = 16
+
+// Cuando llamas a una función con la palabra clave 'new' un nuevo objeto es creado.
+// Se hace disponible a la función. Las funciones diseñadas para ser usadas así se
+// llaman constructores.
+
+var MiConstructor = function(){
+ this.miNumero = 5;
+}
+miNuevoObjeto = new MiConstructor(); // = {miNumero: 5}
+miNuevoObjeto.miNumero; // = 5
+
+// Todos los objetos JavaScript tienen un 'prototipo'. Cuando vas a accesar a una
+// propiedad en un objeto que no existe en el objeto el intérprete buscará en
+// el prototipo.
+
+// Algunas implementaciones de JavaScript te permiten accesar al prototipo de
+// un objeto con la propiedad __proto__. Mientras que esto es útil para explicar
+// prototipos, no es parte del estándar; veremos formas estándar de usar prototipos
+// más adelante.
+
+var miObjeto = {
+ miString: "¡Hola Mundo!"
+};
+var miPrototipo = {
+ sentidoDeLaVida: 42,
+ miFuncion: function(){
+ return this.miString.toLowerCase()
+ }
+};
+
+miObjeto.__proto__ = miPrototipo;
+miObjeto.sentidoDeLaVida; // = 42
+
+// Esto funcionan también para funciones.
+miObjeto.miFuncion(); // = "hello world!"
+
+// Por supuesto, si la propiedad que buscas no está en el prototipo,
+// se buscará en el prototipo del prototipo.
+miPrototipo.__proto__ = {
+ miBoolean: true
+};
+miObjeto.miBoolean; // = true
+
+// Esto no involucra ningún copiado, cada objeto guarda una referencia a su
+// prototipo. Esto significa que podemos alterar el prototipo y nuestros
+// cambios serán reflejados en todos lados.
+miPrototipo.sentidoDeLaVida = 43;
+miObjeto.sentidoDeLaVida; // = 43
+
+// Mencionabamos anteriormente que __proto__ no está estandarizado, y que no
+// existe una forma estándar de accesar al prototipo de un objeto. De todas formas.
+// hay dos formas de crear un nuevo objeto con un prototipo dado.
+
+// El primer método es Object.create, el cual es una adición reciente a JavaScript,
+// y por lo tanto, no disponible para todas las implementaciones aún.
+var miObjeto = Object.create(miPrototipo);
+miObjeto.sentidoDeLaVida; // = 43
+
+// El segundo método, el cual trabaja en todos lados, tiene que ver con los
+// constructores. Los constructores tienen una propiedad llamada prototype.
+// Este NO ES el prototipo de la función constructor; es el prototipo que
+// se le da a los nuevos objetos cuando son creados con la palabra clave
+// new.
+
+MiConstructor.prototype = {
+ miNumero: 5,
+ getMiNumero: function(){
+ return this.miNumero;
+ }
+};
+var miNuevoObjeto2 = new MiConstructor();
+miNuevoObjeto2.getMiNumero(); // = 5
+miNuevoObjeto2.miNumero = 6
+miNuevoObjeto2.getMiNumero(); // = 6
+
+// Los tipos que vienen por defecto en JavaScript (como Strings y números)
+// también tienen constructores que crean objetos equivalentes.
+var miNumero = 12;
+var miNumeroObjeto = new Number(12);
+miNumero == miNumeroObjeto; // = true
+
+// No son exactamente iguales.
+typeof miNumero; // = 'number'
+typeof miNumeroObjeto; // = 'object'
+miNumero === miNumeroObjeyo; // = false
+if (0){
+ // Este código no se ejecutara porque 0 es false.
+}
+if (Number(0)){
+ // Este código sí se ejecutara, puesto que Number(0) es true.
+}
+
+// Aún así, los objetos que envuelven y los prototipos por defecto comparten
+// un prototipo. así que puedes agregar funcionalidades a un string de la
+// siguiente forma:
+String.prototype.primerCaracter = function(){
+ return this.charAt(0);
+}
+"abc".primerCaracter(); // = "a"
+
+// Este hecho se usa normalmente en "polyfilling", lo cual es implementar
+// nuevas funciones a JavaScript en un JavaScript más viejo, así que pueda ser
+// compatible con ambintes más viejos de JavaScript (por ejemplo, navegadores viejos).
+
+// Por ejemplo, mencionabamos que Object.create no está aún disponible en todas
+// las implementaciones, pero podemos hacerlo con polyfill:
+if (Object.create === undefined){ // esta validación sirve para no sobreescribir
+ Object.create = function(proto){
+ // hace un constructor temporal con el prototipo correcto
+ var Constructor = function(){};
+ Constructor.prototype = proto;
+ // y luego lo usamos para hacer un objeto con el prototipo
+ // correcto.
+ return new Constructor();
+ }
+}
+```
+
+## Fuentes y Referencias
+
+La [Red para Desarroladores de Mozilla](https://developer.mozilla.org/en-US/docs/Web/JavaScript)
+proveé excelente documentación para JavaScript para navegadores. Además, está en formato de wiki,
+por lo que mientras vayas aprendiendo podrás ayudar a los demás con tu experiencia.
+
+MDN [Una re-introducción a JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+cubre muchos de los conceptos que vimos aquí pero a mayor detalle. Esta guía cubre, más que nada,
+el lenguaje JavaScript solo. Si quieres aprender a cómo usarlo en un ambiente web empieza aprendiendo
+sobre el [DOM](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
+
+[Aprende JavaScript con ejemplos y retos](http://www.learneroo.com/modules/64/nodes/350) es una
+variante de esta guía pero con retos.
+
+[Jardín JavaScript](http://bonsaiden.github.io/JavaScript-Garden/) es una guía para todas las
+funciones y características contra-intuitivas del lenguaje.
+
+[JavaScript: La guía definitiva](http://www.amazon.com/gp/product/0596805527/) es una guía clásica / libro de referencia.
+
+Aparte de las contribuciones directas para este artículo, algo del contenido se adaptó
+del tutorial de Python por Louie Dinh en este sitio. y el [Tutorial JS](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) en la Red de Desarrolladores de Mozilla.
diff --git a/es-es/json-es.html.markdown b/es-es/json-es.html.markdown
new file mode 100644
index 00000000..fff678eb
--- /dev/null
+++ b/es-es/json-es.html.markdown
@@ -0,0 +1,59 @@
+---
+language: json
+filename: learnjson-es.json
+contributors:
+ - ["Anna Harren", "https://github.com/iirelu"]
+ - ["Marco Scannadinari", "https://github.com/marcoms"]
+translators:
+ - ["Daniel Zendejas","https://github.com/DanielZendejas"]
+lang: es-es
+---
+
+Siendo JSON un formato de intercambio de infomación tan sencillo, probablemente este será el Learn X in Y más sencillo jamás.
+
+JSON en su forma más pura no tiene comentarios, pero la mayoría de los parseadores aceptarán comentarios de C (//, /\* \*/). De todas formas, para el propóstio de esto todo será JSON 100% válido. Por suerte, habla por sí mismo.
+
+```json
+
+{
+ "llave": "valor",
+
+ "llaves": "siempre debe estar entre comillas (ya sean dobles o simples)",
+ "numeros": 0,
+ "strings": "Høla, múndo. Todo el unicode está permitido, así como \"escapar\".",
+ "soporta booleanos?": true,
+ "vacios": null,
+
+ "numero grande": 1.2e+100,
+
+ "objetos": {
+ "comentario": "La mayoria de tu estructura vendra de objetos.",
+
+ "arreglo": [0, 1, 2, 3, "Los arreglos pueden contener cualquier cosa.", 5],
+
+ "otro objeto": {
+ "comentario": "Estas cosas pueden estar anidadas, muy util."
+ }
+ },
+
+ "tonteria": [
+ {
+ "fuentes de potasio": ["bananas"]
+ },
+ [
+ [1, 0, 0, 0],
+ [0, 1, 0, 0],
+ [0, 0, 1, "neo"],
+ [0, 0, 0, 1]
+ ]
+ ],
+
+ "estilo alternativo": {
+ "comentario": "Mira esto!"
+ , "posicion de la coma": "no importa - mientras este antes del valor, entonces sera valido"
+ , "otro comentario": "que lindo"
+ },
+
+ "eso fue rapido": "Y, estas listo. Ahora sabes todo lo que JSON tiene para ofrecer."
+}
+```
diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 41a7c68b..203ee3bb 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -1,8 +1,9 @@
---
-language: julia
+language: Julia
contributors:
- ["Leah Hanson", "http://leahhanson.us"]
- - ["Guillermo Garza" ]
+translators:
+ - ["Guillermo Garza", "http://github.com/ggarza"]
filename: learnjulia-es.jl
lang: es-es
---
diff --git a/es-es/livescript-es.html.markdown b/es-es/livescript-es.html.markdown
new file mode 100644
index 00000000..103a3142
--- /dev/null
+++ b/es-es/livescript-es.html.markdown
@@ -0,0 +1,339 @@
+---
+language: LiveScript
+filename: learnLivescript-es.ls
+contributors:
+ - ["Christina Whyte", "http://github.com/kurisuwhyte/"]
+translators:
+ - ["Daniel Zendejas", "http://github.com/DanielZendejas/"]
+lang: es-es
+---
+
+LiveScript es un lenguaje funcional compilado sobre Javascript. Comparte
+la mayoría de la semántica con este mismo lenguaje. Composición de funciones,
+comparación de patrones y muchas otras cosas son las adiciones que hace
+LiveScript. Está inspirado en lenguajes como Haskell, F# y Scala.
+
+Livescript es un bifurcación de [Coco][], que en sí mismo es una bifurcación
+de [CoffeeScript][]. El lenguaje es estable, y una nueva versión está en
+desarrollo activo para traer aún más funciones.
+
+[Coco]: http://satyr.github.io/coco/
+[CoffeeScript]: http://coffeescript.org/
+
+La retroalimentación siempre es bienvenida, así que sientete libre de
+contactarme en [@kurisuwhyte](https://twitter.com/kurisuwhyte) :)
+
+```coffeescript
+# Justo como su primo CoffeeScript, LiveScript usa símbolos de gato para
+# comentarios de una sola línea
+
+/*
+ Comentarios multi-línea son escritos con estilo de C. Usa este estilo si quieres
+ que los comentarios se preserven en el output de Javascript
+ */
+```
+```coffeescript
+# En lo que a la sintaxis se refiere, LiveScript usa indentación para delimitar
+# bloques en lugar de llaves {} y espacios para aplicar funciones, en lugar de
+# paréntesis.
+
+########################################################################
+## 1. Valores básicos
+########################################################################
+
+# La carencia de valor se define con la palabra `void` en lugar de `undefined`
+void # igual que `undefined` pero más seguro (no puede ser sobre escrito)
+
+# Ningún valor válido se representa con Null.
+null
+
+# El valor básico más pequeño es de tipo lógico:
+true
+false
+
+# Y tiene múltiples alias que significan lo mismo:
+on; off
+yes; no
+
+# Luego vienen los números. Estos número con punto flotante tienen la misma
+# precisión que los de JS:
+10
+0.4 # Note que el `0` al inicio es requerido
+
+# Para fines de fácil lectura, puedes usar guiones bajos y sufijos en un
+# número, y estos serán ignorados por el compilador.
+12_344km
+
+# Los Strings son secuencias de caracteres inmutables, como en JS:
+"Christina" # ¡Los apóstrofes están bien!
+"""Strings
+ de muchas
+ líneas
+ están
+ bien
+ también."""
+
+# A veces quieres codificar un palabra clave, la diagonal invertida sirve para esto:
+\keyword # => 'keyword'
+
+
+# Los arreglos son colecciones ordenadas de datos:
+frutas =
+ * \manzana
+ * \naranja
+ * \pera
+
+# Una forma más concisa de representarlos son con corchetes:
+frutas = [ \manzana, \naranja, \pera ]
+
+# Esta es una conveniente de crear listas de Strings, usando
+# espacio en blanco para delimitar los items:
+frutas = <[ manzana naranja pera ]>
+
+# Puedes recuperar un item usando su índice (empezando en 0):
+frutas[0] # => "manzana"
+
+# Los objetos son colecciones de pares llave/valor sin ordenar, entre otras cosas,
+# (detallaremos más al respecto en un momento):
+persona =
+ nombre: "Christina"
+ gusta:
+ * "gatitos"
+ * "otras cosas"
+
+# Otra vez, puedes expresar el objeto con más consistencia con llaves {}:
+persona = {nombre: "Christina", gusta: ["gatitos", "otras cosas"]}
+
+# Puedes conseguir un valor por medio de su llave:
+persona.nombre # => "Christina"
+persona["nombre"] # => "Christina"
+
+
+# Las expresiones regulares tienen la misma sintaxis que en JavaScript:
+expresion-regular = /\s$/
+
+# A excepción de que puedes hacer expresiones de múltiples líneas
+# (los comentarios y espacios se ignoran):
+expresion-regular = //
+ function\s+(.+) # nombre
+ \s* \((.*)\) \s* # argumentos
+ { (.*) } # cuerpo
+ //
+
+
+########################################################################
+## 2. Operaciones básicas
+########################################################################
+
+# Los operadores aritméticos son los mismos que en JavaScript:
+1 + 2 # => 3
+2 - 1 # => 1
+2 * 3 # => 6
+4 / 2 # => 2
+3 % 2 # => 1
+
+
+# Las comparaciones son casi las mismas, excepto `==` que es igual
+# a `===` en. El operador `==` de JS en LiveScript es `~=`, y `===`
+# permite comparaciones entre objetos y arreglos, y también
+# comparasiones más estrictas:
+2 == 2 # => true
+2 == "2" # => false
+2 ~= "2" # => true
+2 === "2" # => false
+
+[1,2,3] == [1,2,3] # => false
+[1,2,3] === [1,2,3] # => true
+
++0 == -0 # => true
++0 === -0 # => false
+
+# Otros operadores relacionales incluyen <, <=, > and >=
+
+# Los valores lógicos pueden ser combinados mediante los operadores
+# lógicos `or`, `and` and `not`:
+true and false # => false
+false or true # => true
+not false # => true
+
+# Las colecciones también tienen algunos operadores adicionales:
+[1, 2] ++ [3, 4] # => [1, 2, 3, 4]
+'a' in <[ a b c ]> # => true
+'nombre' of { nombre: 'Chris' } # => true
+
+
+########################################################################
+## 3. Funciones
+########################################################################
+
+# Como LiveScript es funcional, uno esperaría que las funciones recibirían
+# un buen tratamiento. En LiveScript es más que aparente que las funciones
+# son de primera clase:
+suma = (primerElemento, segundoElemento) -> primerElemento + segundoElemento
+add 1, 2 # => 3
+
+# Las funciones que no reciben argumentos son llamadas rápidamente
+dos = -> 2
+dos!
+
+# LiveScript, al igual que JS, aplica ámbitos (alcance) a sus variables y
+# tiene cierres (closures) también. A diferencia de JavaScript, el operador
+# `=` sirve como declaración y siempre declarará la variable en lado izquierdo.
+
+# El operador `:=` está disponible para *reusar* un nombre del ámbito del padre.
+
+# Puedes acceder a los argumentos de una función para conseguir
+# los datos internos de una estructura de datos rápidamente:
+cola = ([cabeza, ...resto]) -> resto
+cola [1, 2, 3] # => [2, 3]
+
+# También puedes transformar argumentos usando operadores binarios o unarios.
+# Argumentos por defecto también son posibles
+foo = (a = 1, b = 2) -> a + b
+foo! # => 3
+
+# También puedes usarlo para clonar un argumento en particular para evitar efectos
+# secundarios, por ejemplo:
+copiar = (^^objetivo, fuente) ->
+ for k,v of fuente => objetivo[k] = v
+ objetivo
+a = { a: 1 }
+copiar a, { b: 2 } # => { a: 1, b: 2 }
+a # => { a: 1 }
+
+# Una función puede ser abreviada usando una flecha larga en lugar de una corta:
+suma = (primerElemento, segundoElemento) --> primerElemento + segundoElemento
+sumaAbreviada = suma 1
+sumaAbreviada 2 # => 3
+
+# Las funciones obtienen un argumento `it` implícito, incluso si no declaras
+# ningún argument
+identidad = -> it
+identidad 1 # => 1
+
+# Los operadores no son funciones en LiveScript. ¡Pero se pueden convertir fácilmente
+# en una! Presentamos el seccionamiento de operadores:
+dividir-entre-2 = (/ 2)
+[2, 4, 8, 16].map(dividir-entre-2) .reduce (+)
+
+# LiveScript vive de otras cosas aparte de las funciones. Como en cualquier lenguaje
+# funcional obtienes medios para componer (juntar) funciones:
+doble-menos-uno = (- 1) . (* 2)
+
+# A parte de la clásica fórmula matemática `f . g`, también cuentas co los operadores
+# `>>` y `<<`, que describen el flujo de los valores dentro de las funciones:
+double-minus-one = (* 2) >> (- 1)
+double-minus-one = (- 1) << (* 2)
+
+# Hablando del flujo de los valores, LiveScript también tiene los operadores `|>` y `<|`
+# que aplican un valor a una función:
+map = (f, xs) --> xs.map f
+[1 2 3] |> map (* 2) # => [2 4 6]
+
+# También puedes escoger dónde quieres que el valor se posicione, sólo márcalo con un
+# guíon bajo:
+reducir = (f, xs, initial) --> xs.reducir f, initial
+[1 2 3] |> reducir (+), _, 0 # => 6
+
+# El guíon bajo también se usa para apartar lugares para tus argumentos, por ejemplo:
+division = (dividendo,divisor) -> dividendo / divisor
+dividir-entre-2 = division _, 2
+dividir-entre-2 4 # => 2
+
+# Por último, LiveScript tiene back-calls (útiles mecanismos para hacer
+# callbacks.). A pesar de esto deberías intentar formas más funcionales de hacerlo,
+# como Promises:
+leerArchivo = (nombre, f) -> f name
+a <- leerArchivo 'foo'
+b <- leerArchivo 'bar'
+console.log a + b
+
+# Igual a:
+leerArchivo 'foo', (a) -> leerArchivo 'bar', (b) -> console.log a + b
+
+
+########################################################################
+## 4. Patrones, guardias y control de flujo
+########################################################################
+
+# Puedes bifurcar cálculos con la expresión `if...else`:
+x = if n > 0 then \positive else \negative
+
+# En lugar de `then`, puedes usar `=>`
+x = if n > 0 => \positivo
+ else \negativo
+
+# A pesar de esto, a las condiciones complejas es mejor expresarlas con el `switch`:
+y = {}
+x = switch
+ | (typeof y) is \number => \numero
+ | (typeof y) is \string => \string
+ | 'length' of y => \arreglo
+ | otherwise => \objeto # `otherwise` y `_` son lo mismo.
+
+# Los cuerpos de las funciones, declaraciones y asignaciones tienen un `switch` por defecto,
+# así que no necesitas escribirlo nuevamente:
+
+take = (n, [x, ...xs]) -->
+ | n == 0 => []
+ | _ => [x] ++ take (n - 1), xs
+
+
+########################################################################
+## 5. Comprehensions (Auxiliares)
+########################################################################
+
+# Mientras que los auxiliares funcionales (para lidiar con listas y objetos)
+# están en la librería estándar de JavaScript (y complementada con prelude-ls,
+# que es una "librería estándar" de LiveScipt) los "comprehensions" (Auxiliares)
+# usualemente te permiten hacer lo mismo pero más rápido y con una sintaxis más
+# comprehensible (de ahí su nombre en inglés):
+unoAVeinte = [1 to 20]
+pares = [x for x in oneToTwenty when x % 2 == 0]
+
+# `when` y `unless` pueden ser usados como filtros en el auxiliar.
+
+# Los auxiliares para objetos funcionan de la misma forma, excepto que regresa un
+# objeto en lugar de un arreglo:
+copiar = { [k, v] for k, v of source }
+
+
+########################################################################
+## 4. PROGRAMACIÓN ORIENTADA A OBJETOS
+########################################################################
+
+# Mientras que LiveScript es un lenguaje funcional en la mayoría de los
+# aspectos, también brinda ayudas para la programación orientada a objetos.
+# Algunas de estas ayudas son la sintaxis para las clases y un poco de "azucar"
+# para las clases heredada de CoffeeScript:
+class Animal
+ (@nombre, tipo) ->
+ @tipo = tipo
+ action: (accion) -> "*#{@nombre} (un #{@tipo}) #{accion}*"
+
+class Gato extends Animal
+ (@nombre) -> super @nombre, 'gato'
+ ronronear: -> @action 'ronronea'
+
+gatito = new Gato 'Mei'
+gatito.purr! # => "*Mei (un gato) ronronea*"
+
+# A parte del clásico patrón de herencia simple, también puedes proveer
+# cuantas mezclas quieras para una clase. Las mezclas sólo son objetos:
+Abrazable =
+ abrazar: -> @action 'es abrazado'
+
+class GatoAbrazable extends Gato implements Abrazable
+
+gatito = new GatoAbrazable 'Ronroneo'
+gatito.abrazar! # => "*Mei (un gato) es abrazado*"
+```
+
+## Más recursos
+
+Existe mucho más sobre LiveScript, pero esto debe bastar para que empieces.
+El [sitio oficial](http://livescript.net/) tiene mucha información sobre el
+lenguaje, y un compilador en linea para que pruebes cosas inmediatamente.
+
+También querras probar un poco de [prelude.ls](http://gkz.github.io/prelude-ls/),
+y probar el canal `#livescript` en la red Freenode.
diff --git a/es-es/markdown-es.html.markdown b/es-es/markdown-es.html.markdown
new file mode 100644
index 00000000..d90e3eb5
--- /dev/null
+++ b/es-es/markdown-es.html.markdown
@@ -0,0 +1,252 @@
+---
+language: markdown
+filename: markdown-es.md
+contributors:
+ - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+ - ["Daniel Zendejas", "https://github.com/DanielZendejas"]
+lang: es-es
+---
+
+Markdown fue creado por John Gruber en 2004. Su propósito es ser una sintaxis fácil de leer y escribir que se convierta
+fácilmente a HTML (y, actualmente, otros formatos también).
+
+¡Denme todo la retroalimentación que quieran! / ¡Sientanse en la libertad de hacer forks o pull requests!
+
+
+```markdown
+<!-- Markdown está basado en HTML, así que cualquier archivo HTML es Markdown
+válido, eso significa que podemos usar elementos HTML en Markdown como, por
+ejemplo, el comentario y no serán afectados por un parseador Markdown. Aún
+así si creas un elemento HTML en tu archivo Markdown no podrás usar sintaxis
+Markdown dentro de él. -->
+
+<!-- La implementación de Markdown cambia de acuerdo al parseador. Esta
+guía servirá para clarificar cuales características son universales y
+cuales son específicas de cada parseador-->
+
+<!-- Headers -->
+<!-- Puedes crear headers HTML fácilmente precediendo al texto con una serie
+de símbolos de números (#)-->
+
+# Esto es un <h1>
+## Esto es un <h2>
+### Esto es un <h3>
+#### Esto es un <h4>
+##### Esto es un <h5>
+###### Esto es un <h6>
+
+<!-- Markdown también nos proveé con dos alternativas para indicar h1 y h2 -->
+Esto es un h1
+=============
+
+Esto es un h2
+-------------
+
+<!-- Estilos para texto plano -->
+<!-- El texto puede ser fácilmente estilizaedo con italicas, negritas o tachado
+usando markdown -->
+
+*Este texto está en itálicas.*
+_Al igual que este texto._
+
+**Este texto está en negritas.**
+__Al igual que este texto.__
+
+***Este texto tiene ambos estilos.***
+**_Al igual que este!_**
+*__¡Y este!__*
+
+<!-- En Github Flavored Markdown, el cual es usado para mostrar archivos
+Markdown en Github, también tenemos: -->
+
+~~Este texto está tachado.~~
+
+<!-- Los párrafos son una o múltuples líneas de texto adyacentes separadas por
+una o múltiples líneas en blanco-->
+
+Este es un párrafo. Estoy escribiendo un párrafo, ¿No es divertido?
+
+Ahora estoy en el párrafo dos.
+¡Sigo en el párrafo dos!
+
+¡Estoy en el párrafo tres!
+
+<!-- Si en algún momento quieres insertar un break HTML <br />, puedes terminar
+un párrafo con dos o más espacios y luego empieza un párrafo nuevo-->
+
+Termino con dos espacios (selecciona esta línea completa para que los veas).
+
+¡Hay un <br /> arriba de mí!
+
+<!-- Las citas de bloque son fáciles y se pueden hacer con el caracter >. -->
+
+> Esta es una cita de bloque. Puedes
+> envolver tus líneas manualmente y poner un `>` antes de cada línea o puedes dejar que tus líneas sean muy largas y que se envuelvan solas.
+> No hay diferencia, siempre y cuando empiecen con `>`.
+
+> ¿También puedes usar más de un nivel
+>> de indentación?
+> Esto es muy útil ¿No?
+
+<!-- Listas -->
+<!-- Las listas desordenadas se hacen usando asteriscos, símbolos de más,
+ o guiones -->
+
+* Item
+* Item
+* Otro item
+
+o
+
++ Item
++ Item
++ Un item más
+
+o
+
+- Item
+- Item
+- El último item
+
+<!-- Las listas ordenadas se logran con un número seguido de un punto -->
+
+1. Item uno
+2. Item dos
+3. Item tres
+
+<!-- Aunque Markdown mostrará los items correctamente en orden, esto no
+es una buena idea -->
+
+1. Item uno
+1. Item dos
+1. Item tres
+<!-- (Esto muestra lo mismo que el ejemplo de arriba) -->
+
+<!-- También puedes usar sub-listas -->
+
+1. Item uno
+2. Item dos
+3. Item tres
+ * Sub-item
+ * Sub-item
+4. Item cuatro
+
+<!-- Bloques de código -->
+<!-- Puedes indicar un bloque de código (usan los elementos <code>) indentando
+una línea con cuatro espacios o un tab-->
+
+ Esto es código
+ Esto también
+
+<!-- También puedes insertar dos tabs (o cuatro espacios adicionales)
+para indentar dentro del código -->
+
+ my_array.each do |item|
+ puts item
+ end
+
+<!-- Código dentro de la línea puede ser escrito usando la comilla ` -->
+
+¡John no sabía lo que la función `go_to()` hacía!
+
+<!-- Con Github Flavored Markdown, puedes usar una sintaxis especial para código -->
+
+\`\`\`ruby <!-- quita esas comillas cuando lo hagas, deja sólo ```ruby ! -->
+def foobar
+ puts "Hello world!"
+end
+\`\`\` <!-- aquí también, sin comillas, sólo ``` -->
+
+<!-- El texto de arriba no necesita indentación, aparte Github usará
+resaltará la sintaxis del lenguaje que especifiques después de ``` -->
+
+<!-- Regla horizontal (<hr />) -->
+<!-- Las reglas horizontales se agregan fácilmente con tres o más asteriscos o guiones,
+con o sin espacios. -->
+
+***
+---
+- - -
+****************
+
+<!-- Ligas -->
+<!-- Una de las mejores cosas de Markdown es la facilidad para hacer ligas. Pon
+el texto a mostrar en corchetes [] seguidos por la URL en paréntesis () -->
+
+[¡Haz click!](http://test.com/)
+
+<!-- También puedes agregar el titulo de la liga usando comillas dentro de los paréntesis -->
+
+[¡Haz click!](http://test.com/ "Liga al test.com")
+
+<!-- También funcionan las rutas relativas. -->
+
+[Ir a la música](/music/).
+
+<!-- Markdown también soporta ligas con estilo de referencia -->
+
+¡[Has click a esta liga][liga1] para más información!
+[También mira esta liag][foobar] si quieres.
+
+
+
+
+<!-- El título también puede estar en comillas simples o dentro de paréntesis,
+también se pueden omitir completamente. Las referencias pueden estar en cualquier
+lugar en tu documento y los IDs de referencia pueden ser lo que sea mientras sean únicos. -->
+
+<!-- También hay "nombramiento implicito" el cual te permite usar el texto de la liga como id -->
+
+[Esta][] es una liga.
+
+
+
+<!-- Pero no se usa comúnmente. -->
+
+<!-- Imagenes -->
+<!-- Las imagenes se hacen de la misma forma que las ligas pero con un símbolo de exclamaciónal frente! -->
+
+![Esta es una etiqueta (texto alternativo) para mi imagen](http://imgur.com/myimage.jpg "Un titulo opcional")
+
+<!-- Y el estilo de referencia funciona como se espera -->
+
+![Esta es una etiqueta.][myimage]
+
+
+
+<!-- Misceláneos -->
+<!-- Auto-ligas -->
+
+<http://testwebsite.com/> equivale a
+[http://testwebsite.com/](http://testwebsite.com/)
+
+<!-- Auto-ligas para correos electrónicos -->
+
+<foo@bar.com>
+
+<!-- Escapando caracteres -->
+
+Quiero escribir *este texto rodeado por asteriscos* pero no quiero que esté en itálicas,
+así que hago esto: \*Este texto está rodeado de asteriscos\*.
+
+<!-- Tablas -->
+<!-- Las tablas sólo están disponibles en Github Flavored Markdown y son un poco pesadas,
+pero si de verdad las quieres: -->
+
+| Col1 | Col2 | Col3 |
+| :----------- | :------: | ------------: |
+| Izquierda | Centrado | Derecha |
+| blah | blah | blah |
+
+<!-- o, para los mismos resultados -->
+
+Col 1 | Col2 | Col3
+:-- | :-: | --:
+Ugh esto es feo | has que | pare.
+
+<!-- ¡El fin! -->
+
+```
+
+Para más información, mira el post oficial de John Gruber's [aquí](http://daringfireball.net/projects/markdown/syntax) y la gran referencia de Adam Pritchard's [aquí](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
diff --git a/es-es/perl-es.html.markdown b/es-es/perl-es.html.markdown
index 4f0c26c1..644182ff 100644
--- a/es-es/perl-es.html.markdown
+++ b/es-es/perl-es.html.markdown
@@ -7,23 +7,24 @@ contributors:
- ["Korjavin Ivan", "http://github.com/korjavin"]
translators:
- ["Francisco Gomez", "http://github.com/frncscgmz"]
+ - ["Joaquín Ferrero", "http://github.com/joaquinferrero"]
lang: es-es
---
-Perl 5 es un lenguaje de programación altamente capaz, rico en características con mas de 25 años de desarrollo.
+Perl 5 es un lenguaje de programación altamente capaz, rico en características, con más de 25 años de desarrollo.
-Perl 5 corre en mas de 100 plataformas desde portales hasta mainframes y es adecuado para realizar prototipos rápidos hasta desarrollar proyectos a gran escala.
+Perl 5 corre en más de 100 plataformas, desde portátiles hasta ordenadores centrales, y es adecuado para realizar desde prototipos rápidos hasta desarrollar proyectos a gran escala.
```perl
-# Comentarios de una sola linea con un carácter hash.
+# Comentarios de una sola línea con un carácter hash
#### Tipos de variables en Perl
-# Las variables comienzan con el símbolo $.
-# Un nombre de variable valido empieza con una letra o un guión bajo,
-# seguido por cualquier numero de letras, números o guiones bajos.
+# Las variables comienzan con el símbolo $
+# Un nombre de variable válido empieza con una letra o un guión bajo,
+# seguido por cualquier número de letras, números o guiones bajos
-### Perl tiene tres tipos principales de variables: escalares, arreglos y hashes.
+### Perl tiene tres tipos principales de variables: escalares, arreglos y hashes
## Escalares
# Un escalar representa un solo valor:
@@ -31,99 +32,98 @@ my $animal = "camello";
my $respuesta = 42;
# Los valores escalares pueden ser cadenas de caracteres, números enteros o
-# de punto flotante, Perl automáticamente los convertirá como sea requerido.
+# de punto flotante; Perl automáticamente los convertirá como sea requerido
## Arreglos
# Un arreglo representa una lista de valores:
-my @animales = {"camello","llama","buho"};
-my @numeros = {23,42,69};
-my @mixto = {"camello",42,1.23};
-
-
+my @animales = ("camello","llama","buho"};
+my @numeros = (23, 42, 69);
+my @mixto = ("camello", 42, 1.23);
## Hashes
-# Un hash representa un conjunto de pares llave/valor:
-
-my %color_fruta = {"manzana","rojo","banana","amarillo"};
-
-# Puedes usar un espacio en blanco y el operador "=>" para asignarlos mas
-# fácilmente.
+# Un hash representa un conjunto de pares llave/valor:
+my %color_fruta = ("manzana","rojo","banana","amarillo");
+# Puede usar un espacio en blanco y el operador "=>" para asignarlos más fácilmente
my %color_fruta = (
manzana => "rojo",
banana => "amarillo",
- );
-# Los escalares, arreglos y hashes están mas documentados en perldata. (perldoc perldata).
+);
-# Los tipos de datos mas complejos pueden ser construidos utilizando
-# referencias, las cuales te permiten construir listas y hashes dentro
-# de listas y hashes.
+# Los escalares, arreglos y hashes están más documentados en perldata (perldoc perldata)
-#### Estructuras condicionales y de ciclos
+# Los tipos de datos más complejos se pueden construir utilizando
+# referencias, las cuales le permiten construir listas y hashes dentro
+# de listas y hashes
-# Perl tiene la mayoría de las estructuras condicionales y de ciclos mas comunes.
+#### Estructuras condicionales y de ciclos
+# Perl tiene la mayoría de las estructuras condicionales y de ciclos más comunes
if ( $var ) {
- ...
+ ...;
} elsif ( $var eq 'bar' ) {
- ...
+ ...;
} else {
- ...
+ ...;
}
unless ( condicion ) {
- ...
- }
-# Esto es proporcionado como una version mas fácil de leer que "if (!condición)"
+ ...;
+}
-# La post condición al modo Perl
+# Esto se ofrece como una versión más fácil de leer que "if (!condición)"
+
+# La postcondición al modo Perl:
print "Yow!" if $zippy;
print "No tenemos bananas" unless $bananas;
# while
- while ( condicion ) {
- ...
- }
-
+while ( condicion ) {
+ ...;
+}
# for y foreach
for ($i = 0; $i <= $max; $i++) {
- ...
- }
+ ...;
+}
+
+for $i (0 .. $max) {
+ ...;
+}
foreach (@array) {
- print "Este elemento es $_\n";
- }
+ print "Este elemento es $_\n";
+}
#### Expresiones regulares
-# El soporte de expresiones regulares en Perl es muy amplio y profundo, y es
-# sujeto a una extensa documentación en perlrequick, perlretut, entre otros.
+# El soporte de expresiones regulares en Perl es muy amplio y profundo, y
+# está sujeto a una extensa documentación en perlrequick, perlretut, entre otros.
# Sin embargo, resumiendo:
-# Pareo simple
+# Coincidencia simple
if (/foo/) { ... } # verdadero si $_ contiene "foo"
if ($a =~ /foo/) { ... } # verdadero si $a contiene "foo"
# Substitución simple
-$a =~ s/foo/bar/; # remplaza foo con bar en $a
-$a =~ s/foo/bar/g; # remplaza TODAS LAS INSTANCIAS de foo con bar en $a
+$a =~ s/foo/bar/; # remplaza "foo" con "bar" en $a
+$a =~ s/foo/bar/g; # remplaza TODAS LAS INSTANCIAS de "foo" con "bar" en $a
-#### Archivos e I/O
+#### Archivos y E/S
-# Puedes abrir un archivo para obtener datos o escribirlos utilizando la
-# función "open()".
+# Puede abrir un archivo para obtener datos o escribirlos utilizando la
+# función "open()"
open(my $entrada, "<" "entrada.txt") or die "No es posible abrir entrada.txt: $!";
open(my $salida, ">", "salida.txt") or die "No es posible abrir salida.txt: $!";
open(my $log, ">>", "mi.log") or die "No es posible abrir mi.log: $!";
-# Es posible leer desde un gestor de archivo abierto utilizando el operador "<>"
-# operador. En contexto escalar leer una sola linea desde el gestor de
-# archivo, y en contexto de lista leer el archivo completo en donde, asigna
-# cada linea a un elemento de la lista.
+# Es posible leer desde un gestor de archivo abierto utilizando el operador "<>".
+# En contexto escalar, leer una sola línea desde el gestor de archivo, y
+# en contexto de lista, leer el archivo completo en donde asigna
+# cada línea a un elemento de la lista
my $linea = <$entrada>;
my @lineas = <$entrada>;
@@ -131,30 +131,26 @@ my @lineas = <$entrada>;
#### Escribiendo subrutinas
# Escribir subrutinas es fácil:
-
sub logger {
my $mensajelog = shift;
open my $archivolog, ">>", "mi.log" or die "No es posible abrir mi.log: $!";
print $archivolog $mensajelog;
}
-# Ahora podemos utilizar la subrutina al igual que cualquier otra función
-# incorporada:
-
+# Ahora podemos utilizar la subrutina al igual que cualquier otra función incorporada:
logger("Tenemos una subrutina logger!");
-
```
#### Utilizando módulos Perl
-Los módulos en Perl proveen una gama de funciones que te pueden ayudar a evitar reinventar la rueda, estas pueden ser descargadas desde CPAN( http://www.cpan.org/ ). Algunos de los módulos mas populares ya están incluidos con la misma distribución de Perl.
+Los módulos en Perl proveen de una gama de funciones que le pueden ayudar a evitar reinventar la rueda. Éstas se pueden descargar desde CPAN ( http://www.cpan.org/ ). Algunos de los módulos más populares ya están incluidos con la misma distribución de Perl.
-perlfaq contiene preguntas y respuestas relacionadas con muchas tareas comunes, y algunas veces provee sugerencias sobre buenos módulos CPAN para usar.
+perlfaq contiene preguntas y respuestas relacionadas con muchas tareas comunes, y algunas veces provee sugerencias sobre buenos módulos de CPAN que puede usar.
#### Material de Lectura
- [perl-tutorial](http://perl-tutorial.org/)
- - [Aprende en www.perl.com](http://www.perl.org/learn.html)
+ - [Learn Perl](http://www.perl.org/learn.html)
- [perldoc](http://perldoc.perl.org/)
- - y perl incorporado: `perldoc perlintro`
+ - y en su propio perl: `perldoc perlintro`
diff --git a/es-es/python-es.html.markdown b/es-es/python-es.html.markdown
index f92f5cde..f7a0ec02 100644
--- a/es-es/python-es.html.markdown
+++ b/es-es/python-es.html.markdown
@@ -130,7 +130,7 @@ otra_variable # Levanta un error de nombre
# 'if' puede ser usado como una expresión
"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
-# Listas sobre secuencias
+# Listas almacenan secuencias
lista = []
# Puedes empezar con una lista prellenada
otra_lista = [4, 5, 6]
@@ -254,7 +254,7 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
# Haz diferencia de conjuntos con -
{1,2,3,4} - {2,3,5} #=> {1, 4}
-# CHequea la existencia en un conjunto con 'in'
+# Chequea la existencia en un conjunto con 'in'
2 in conjunto_lleno #=> True
10 in conjunto_lleno #=> False
diff --git a/es-es/python3-es.html.markdown b/es-es/python3-es.html.markdown
new file mode 100644
index 00000000..1c69481a
--- /dev/null
+++ b/es-es/python3-es.html.markdown
@@ -0,0 +1,570 @@
+---
+language: python3
+contributors:
+ - ["Louie Dinh", "http://pythonpracticeprojects.com"]
+translators:
+ - ["Camilo Garrido", "http://twitter.com/hirohope"]
+lang: es-es
+filename: learnpython3-es.py
+---
+
+Python fue creado por Guido Van Rossum en el principio de los 90'. Ahora es uno
+de los lenguajes más populares en existencia. Me enamoré de Python por su claridad sintáctica.
+Es básicamente pseudocódigo ejecutable.
+
+¡Comentarios serán muy apreciados! Pueden contactarme en [@louiedinh](http://twitter.com/louiedinh) o louiedinh [at] [servicio de email de google]
+
+Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser aplicable a Python 2.x. ¡Pronto un recorrido por Python 3!
+
+```python
+
+# Comentarios de una línea comienzan con una almohadilla (o signo gato)
+
+""" Strings multilinea pueden escribirse
+ usando tres "'s, y comunmente son usados
+ como comentarios.
+"""
+
+####################################################
+## 1. Tipos de datos primitivos y operadores.
+####################################################
+
+# Tienes números
+3 #=> 3
+
+# Matemática es lo que esperarías
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+
+# Excepto la división la cual por defecto retorna un número 'float' (número de coma flotante)
+35 / 5 # => 7.0
+
+# Cuando usas un float, los resultados son floats
+3 * 2.0 # => 6.0
+
+# Refuerza la precedencia con paréntesis
+(1 + 3) * 2 # => 8
+
+
+# Valores 'boolean' (booleanos) son primitivos
+True
+False
+
+# Niega con 'not'
+not True # => False
+not False # => True
+
+
+# Igualdad es ==
+1 == 1 # => True
+2 == 1 # => False
+
+# Desigualdad es !=
+1 != 1 # => False
+2 != 1 # => True
+
+# Más comparaciones
+1 < 10 # => True
+1 > 10 # => False
+2 <= 2 # => True
+2 >= 2 # => True
+
+# ¡Las comparaciones pueden ser concatenadas!
+1 < 2 < 3 # => True
+2 < 3 < 2 # => False
+
+# Strings se crean con " o '
+"Esto es un string."
+'Esto también es un string'
+
+# ¡Strings también pueden ser sumados!
+"Hola " + "mundo!" #=> "Hola mundo!"
+
+# Un string puede ser tratado como una lista de caracteres
+"Esto es un string"[0] #=> 'E'
+
+# .format puede ser usaro para darle formato a los strings, así:
+"{} pueden ser {}".format("strings", "interpolados")
+
+# Puedes repetir los argumentos de formateo para ahorrar tipeos.
+"{0} sé ligero, {0} sé rápido, {0} brinca sobre la {1}".format("Jack", "vela") #=> "Jack sé ligero, Jack sé rápido, Jack brinca sobre la vela"
+# Puedes usar palabras claves si no quieres contar.
+"{nombre} quiere comer {comida}".format(nombre="Bob", food="lasaña") #=> "Bob quiere comer lasaña"
+
+
+# None es un objeto
+None # => None
+
+# No uses el símbolo de igualdad `==` para comparar objetos con None
+# Usa `is` en lugar de
+"etc" is None #=> False
+None is None #=> True
+
+# None, 0, y strings/listas/diccionarios vacíos(as) todos se evalúan como False.
+# Todos los otros valores son True
+bool(0) # => False
+bool("") # => False
+bool([]) #=> False
+bool({}) #=> False
+
+
+####################################################
+## 2. Variables y Colecciones
+####################################################
+
+# Python tiene una función para imprimir
+print("Soy Python. Encantado de conocerte")
+
+# No hay necesidad de declarar las variables antes de asignarlas.
+una_variable = 5 # La convención es usar guiones_bajos_con_minúsculas
+una_variable #=> 5
+
+# Acceder a variables no asignadas previamente es una excepción.
+# Ve Control de Flujo para aprender más sobre el manejo de excepciones.
+otra_variable # Levanta un error de nombre
+
+# Listas almacena secuencias
+lista = []
+# Puedes empezar con una lista prellenada
+otra_lista = [4, 5, 6]
+
+# Añadir cosas al final de una lista con 'append'
+lista.append(1) #lista ahora es [1]
+lista.append(2) #lista ahora es [1, 2]
+lista.append(4) #lista ahora es [1, 2, 4]
+lista.append(3) #lista ahora es [1, 2, 4, 3]
+# Remueve del final de la lista con 'pop'
+lista.pop() #=> 3 y lista ahora es [1, 2, 4]
+# Pongámoslo de vuelta
+lista.append(3) # Nuevamente lista ahora es [1, 2, 4, 3].
+
+# Accede a una lista como lo harías con cualquier arreglo
+lista[0] #=> 1
+# Mira el último elemento
+lista[-1] #=> 3
+
+# Mirar fuera de los límites es un error 'IndexError'
+lista[4] # Levanta la excepción IndexError
+
+# Puedes mirar por rango con la sintáxis de trozo.
+# (Es un rango cerrado/abierto para ustedes los matemáticos.)
+lista[1:3] #=> [2, 4]
+# Omite el inicio
+lista[2:] #=> [4, 3]
+# Omite el final
+lista[:3] #=> [1, 2, 4]
+# Selecciona cada dos elementos
+lista[::2] # =>[1, 4]
+# Invierte la lista
+lista[::-1] # => [3, 4, 2, 1]
+# Usa cualquier combinación de estos para crear trozos avanzados
+# lista[inicio:final:pasos]
+
+# Remueve elementos arbitrarios de una lista con 'del'
+del lista[2] # lista ahora es [1, 2, 3]
+
+# Puedes sumar listas
+lista + otra_lista #=> [1, 2, 3, 4, 5, 6] - Nota: lista y otra_lista no se tocan
+
+# Concatenar listas con 'extend'
+lista.extend(otra_lista) # lista ahora es [1, 2, 3, 4, 5, 6]
+
+# Chequea la existencia en una lista con 'in'
+1 in lista #=> True
+
+# Examina el largo de una lista con 'len'
+len(lista) #=> 6
+
+
+# Tuplas son como listas pero son inmutables.
+tupla = (1, 2, 3)
+tupla[0] #=> 1
+tupla[0] = 3 # Levanta un error TypeError
+
+# También puedes hacer todas esas cosas que haces con listas
+len(tupla) #=> 3
+tupla + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
+tupla[:2] #=> (1, 2)
+2 in tupla #=> True
+
+# Puedes desempacar tuplas (o listas) en variables
+a, b, c = (1, 2, 3) # a ahora es 1, b ahora es 2 y c ahora es 3
+# Tuplas son creadas por defecto si omites los paréntesis
+d, e, f = 4, 5, 6
+# Ahora mira que fácil es intercambiar dos valores
+e, d = d, e # d ahora es 5 y e ahora es 4
+
+
+# Diccionarios almacenan mapeos
+dicc_vacio = {}
+# Aquí está un diccionario prellenado
+dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
+
+# Busca valores con []
+dicc_lleno["uno"] #=> 1
+
+# Obtén todas las llaves como una lista con 'keys()'. Necesitamos envolver la llamada en 'list()' porque obtenemos un iterable. Hablaremos de eso luego.
+list(dicc_lleno.keys()) #=> ["tres", "dos", "uno"]
+# Nota - El orden de las llaves del diccionario no está garantizada.
+# Tus resultados podrían no ser los mismos del ejemplo.
+
+# Obtén todos los valores como una lista. Nuevamente necesitamos envolverlas en una lista para sacarlas del iterable.
+list(dicc_lleno.values()) #=> [3, 2, 1]
+# Nota - Lo mismo que con las llaves, no se garantiza el orden.
+
+# Chequea la existencia de una llave en el diccionario con 'in'
+"uno" in dicc_lleno #=> True
+1 in dicc_lleno #=> False
+
+# Buscar una llave inexistente deriva en KeyError
+dicc_lleno["cuatro"] # KeyError
+
+# Usa el método 'get' para evitar la excepción KeyError
+dicc_lleno.get("uno") #=> 1
+dicc_lleno.get("cuatro") #=> None
+# El método 'get' soporta un argumento por defecto cuando el valor no existe.
+dicc_lleno.get("uno", 4) #=> 1
+dicc_lleno.get("cuatro", 4) #=> 4
+
+# El método 'setdefault' inserta en un diccionario solo si la llave no está presente
+dicc_lleno.setdefault("cinco", 5) #dicc_lleno["cinco"] es puesto con valor 5
+dicc_lleno.setdefault("cinco", 6) #dicc_lleno["cinco"] todavía es 5
+
+
+# Remueve llaves de un diccionario con 'del'
+del dicc_lleno['uno'] # Remueve la llave 'uno' de dicc_lleno
+
+# Sets (conjuntos) almacenan ... bueno, conjuntos
+conjunto_vacio = set()
+# Inicializar un conjunto con montón de valores. Yeah, se ve un poco como un diccionario. Lo siento.
+un_conjunto = {1,2,2,3,4} # un_conjunto ahora es {1, 2, 3, 4}
+
+# Añade más valores a un conjunto
+conjunto_lleno.add(5) # conjunto_lleno ahora es {1, 2, 3, 4, 5}
+
+# Haz intersección de conjuntos con &
+otro_conjunto = {3, 4, 5, 6}
+conjunto_lleno & otro_conjunto #=> {3, 4, 5}
+
+# Haz unión de conjuntos con |
+conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
+
+# Haz diferencia de conjuntos con -
+{1,2,3,4} - {2,3,5} #=> {1, 4}
+
+# Chequea la existencia en un conjunto con 'in'
+2 in conjunto_lleno #=> True
+10 in conjunto_lleno #=> False
+
+
+####################################################
+## 3. Control de Flujo
+####################################################
+
+# Let's just make a variable
+some_var = 5
+
+# Aquí está una declaración de un 'if'. ¡La indentación es significativa en Python!
+# imprime "una_variable es menor que 10"
+if una_variable > 10:
+ print("una_variable es completamente mas grande que 10.")
+elif una_variable < 10: # Este condición 'elif' es opcional.
+ print("una_variable es mas chica que 10.")
+else: # Esto también es opcional.
+ print("una_variable es de hecho 10.")
+
+"""
+For itera sobre listas
+imprime:
+ perro es un mamifero
+ gato es un mamifero
+ raton es un mamifero
+"""
+for animal in ["perro", "gato", "raton"]:
+ # Puedes usar % para interpolar strings formateados
+ print("{} es un mamifero".format(animal))
+
+"""
+`range(número)` retorna una lista de números
+desde cero hasta el número dado
+imprime:
+ 0
+ 1
+ 2
+ 3
+"""
+for i in range(4):
+ print(i)
+
+"""
+While itera hasta que una condición no se cumple.
+imprime:
+ 0
+ 1
+ 2
+ 3
+"""
+x = 0
+while x < 4:
+ print(x)
+ x += 1 # versión corta de x = x + 1
+
+# Maneja excepciones con un bloque try/except
+try:
+ # Usa raise para levantar un error
+ raise IndexError("Este es un error de indice")
+except IndexError as e:
+ pass # Pass no hace nada. Usualmente harias alguna recuperacion aqui.
+
+# Python oferce una abstracción fundamental llamada Iterable.
+# Un iterable es un objeto que puede ser tratado como una sequencia.
+# El objeto es retornado por la función 'range' es un iterable.
+
+dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
+nuestro_iterable = dicc_lleno.keys()
+print(nuestro_iterable) #=> range(1,10). Este es un objeto que implementa nuestra interfaz Iterable
+
+Podemos recorrerla.
+for i in nuestro_iterable:
+ print(i) # Imprime uno, dos, tres
+
+# Aunque no podemos selecionar un elemento por su índice.
+nuestro_iterable[1] # Genera un TypeError
+
+# Un iterable es un objeto que sabe como crear un iterador.
+nuestro_iterator = iter(nuestro_iterable)
+
+# Nuestro iterador es un objeto que puede recordar el estado mientras lo recorremos.
+# Obtenemos el siguiente objeto llamando la función __next__.
+nuestro_iterator.__next__() #=> "uno"
+
+# Mantiene el estado mientras llamamos __next__.
+nuestro_iterator.__next__() #=> "dos"
+nuestro_iterator.__next__() #=> "tres"
+
+# Después que el iterador ha retornado todos sus datos, da una excepción StopIterator.
+nuestro_iterator.__next__() # Genera StopIteration
+
+# Puedes obtener todos los elementos de un iterador llamando a list() en el.
+list(dicc_lleno.keys()) #=> Retorna ["uno", "dos", "tres"]
+
+
+
+####################################################
+## 4. Funciones
+####################################################
+
+# Usa 'def' para crear nuevas funciones
+def add(x, y):
+ print("x es {} y y es {}".format(x, y))
+ return x + y # Retorna valores con una la declaración return
+
+# Llamando funciones con parámetros
+add(5, 6) #=> imprime "x es 5 y y es 6" y retorna 11
+
+# Otra forma de llamar funciones es con argumentos de palabras claves
+add(y=6, x=5) # Argumentos de palabra clave pueden ir en cualquier orden.
+
+
+# Puedes definir funciones que tomen un número variable de argumentos
+def varargs(*args):
+ return args
+
+varargs(1, 2, 3) #=> (1,2,3)
+
+
+# Puedes definir funciones que toman un número variable de argumentos
+# de palabras claves
+def keyword_args(**kwargs):
+ return kwargs
+
+# Llamémosla para ver que sucede
+keyword_args(pie="grande", lago="ness") #=> {"pie": "grande", "lago": "ness"}
+
+
+# You can do both at once, if you like# Puedes hacer ambas a la vez si quieres
+def todos_los_argumentos(*args, **kwargs):
+ print args
+ print kwargs
+"""
+todos_los_argumentos(1, 2, a=3, b=4) imprime:
+ (1, 2)
+ {"a": 3, "b": 4}
+"""
+
+# ¡Cuando llames funciones, puedes hacer lo opuesto a varargs/kwargs!
+# Usa * para expandir tuplas y usa ** para expandir argumentos de palabras claves.
+args = (1, 2, 3, 4)
+kwargs = {"a": 3, "b": 4}
+todos_los_argumentos(*args) # es equivalente a foo(1, 2, 3, 4)
+todos_los_argumentos(**kwargs) # es equivalente a foo(a=3, b=4)
+todos_los_argumentos(*args, **kwargs) # es equivalente a foo(1, 2, 3, 4, a=3, b=4)
+
+# Python tiene funciones de primera clase
+def crear_suma(x):
+ def suma(y):
+ return x + y
+ return suma
+
+sumar_10 = crear_suma(10)
+sumar_10(3) #=> 13
+
+# También hay funciones anónimas
+(lambda x: x > 2)(3) #=> True
+
+# Hay funciones integradas de orden superior
+map(sumar_10, [1,2,3]) #=> [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+
+# Podemos usar listas por comprensión para mapeos y filtros agradables
+[add_10(i) for i in [1, 2, 3]] #=> [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+
+####################################################
+## 5. Classes
+####################################################
+
+
+# Heredamos de object para obtener una clase.
+class Humano(object):
+
+ # Un atributo de clase es compartido por todas las instancias de esta clase
+ especie = "H. sapiens"
+
+ # Constructor basico
+ def __init__(self, nombre):
+ # Asigna el argumento al atributo nombre de la instancia
+ self.nombre = nombre
+
+ # Un metodo de instancia. Todos los metodos toman self como primer argumento
+ def decir(self, msg):
+ return "%s: %s" % (self.nombre, msg)
+
+ # Un metodo de clase es compartido a través de todas las instancias
+ # Son llamados con la clase como primer argumento
+ @classmethod
+ def get_especie(cls):
+ return cls.especie
+
+ # Un metodo estatico es llamado sin la clase o instancia como referencia
+ @staticmethod
+ def roncar():
+ return "*roncar*"
+
+
+# Instancia una clase
+i = Humano(nombre="Ian")
+print i.decir("hi") # imprime "Ian: hi"
+
+j = Humano("Joel")
+print j.decir("hello") #imprime "Joel: hello"
+
+# Llama nuestro método de clase
+i.get_especie() #=> "H. sapiens"
+
+# Cambia los atributos compartidos
+Humano.especie = "H. neanderthalensis"
+i.get_especie() #=> "H. neanderthalensis"
+j.get_especie() #=> "H. neanderthalensis"
+
+# Llama al método estático
+Humano.roncar() #=> "*roncar*"
+
+
+####################################################
+## 6. Módulos
+####################################################
+
+# Puedes importar módulos
+import math
+print(math.sqrt(16)) #=> 4
+
+# Puedes obtener funciones específicas desde un módulo
+from math import ceil, floor
+print(ceil(3.7)) #=> 4.0
+print(floor(3.7))#=> 3.0
+
+# Puedes importar todas las funciones de un módulo
+# Precaución: Esto no es recomendable
+from math import *
+
+# Puedes acortar los nombres de los módulos
+import math as m
+math.sqrt(16) == m.sqrt(16) #=> True
+
+# Los módulos de Python son sólo archivos ordinarios de Python.
+# Puedes escribir tus propios módulos e importarlos. El nombre del módulo
+# es el mismo del nombre del archivo.
+
+# Puedes encontrar que funciones y atributos definen un módulo.
+import math
+dir(math)
+
+
+####################################################
+## 7. Avanzado
+####################################################
+
+# Los generadores te ayudan a hacer un código perezoso (lazy)
+def duplicar_numeros(iterable):
+ for i in iterable:
+ yield i + i
+
+# Un generador cera valores sobre la marcha.
+# En vez de generar y retornar todos los valores de una vez, crea uno en cada iteración.
+# Esto significa que valores más grandes que 15 no serán procesados en 'duplicar_numeros'.
+# Fíjate que 'range' es un generador. Crear una lista 1-900000000 tomaría mucho tiempo en crearse.
+_rango = range(1, 900000000)
+# Duplicará todos los números hasta que un resultado >= se encuentre.
+for i in duplicar_numeros(_rango):
+ print(i)
+ if i >= 30:
+ break
+
+
+# Decoradores
+# en este ejemplo 'pedir' envuelve a 'decir'
+# Pedir llamará a 'decir'. Si decir_por_favor es True entonces cambiará el mensaje a retornar
+from functools import wraps
+
+
+def pedir(_decir):
+ @wraps(_decir)
+ def wrapper(*args, **kwargs):
+ mensaje, decir_por_favor = _decir(*args, **kwargs)
+ if decir_por_favor:
+ return "{} {}".format(mensaje, "¡Por favor! Soy pobre :(")
+ return mensaje
+
+ return wrapper
+
+
+@pedir
+def say(decir_por_favor=False):
+ mensaje = "¿Puedes comprarme una cerveza?"
+ return mensaje, decir_por_favor
+
+
+print(decir()) # ¿Puedes comprarme una cerveza?
+print(decir(decir_por_favor=True)) # ¿Puedes comprarme una cerveza? ¡Por favor! Soy pobre :()
+```
+
+## ¿Listo para más?
+
+### Gratis y en línea
+
+* [Learn Python The Hard Way](http://learnpythonthehardway.org/book/)
+* [Dive Into Python](http://www.diveintopython.net/)
+* [Ideas for Python Projects](http://pythonpracticeprojects.com)
+* [The Official Docs](http://docs.python.org/3/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/3/)
+* [A Crash Course in Python for Scientists](http://nbviewer.ipython.org/5920182)
+
+### Encuadernados
+
+* [Programming Python](http://www.amazon.com/gp/product/0596158106/ref=as_li_qf_sp_asin_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0596158106&linkCode=as2&tag=homebits04-20)
+* [Dive Into Python](http://www.amazon.com/gp/product/1441413022/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1441413022&linkCode=as2&tag=homebits04-20)
+* [Python Essential Reference](http://www.amazon.com/gp/product/0672329786/ref=as_li_tf_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=0672329786&linkCode=as2&tag=homebits04-20)
+
diff --git a/es-es/whip-es.html.markdown b/es-es/whip-es.html.markdown
new file mode 100644
index 00000000..7c2f4bd2
--- /dev/null
+++ b/es-es/whip-es.html.markdown
@@ -0,0 +1,255 @@
+---
+language: whip
+contributors:
+ - ["Tenor Biel", "http://github.com/L8D"]
+translators:
+ - ["Daniel Zendejas", "https://github.com/DanielZendejas"]
+author: Tenor Biel
+author_url: http://github.com/L8D
+filename: whip-es.lisp
+lang: es-es
+---
+Tutorial de Whip en español.
+
+Whip es un dialecto de LISP hecho para escribir código y conceptos
+simples. Ha tomado prestado bastante de la sintaxis de Haskell
+(un lenguaje no relacionado).
+
+Esta documentación fue escrita por el creador del lenguaje
+
+```scheme
+; Los comentarios son como en LISP, con punto y coma...
+
+; La mayoría de las sentencias de primer nivel están dentro de
+; "formas". Una forma no es más que cosas dentro de paréntesis
+no_en_la_forma
+(en_la_form)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 1. Números, Strings y Operadores
+
+;Whip tiene un tipo para números (es el estándar 64-bit IEEE 754 double, de JS)
+3 ; => 3
+1.5 ; => 1.5
+
+; Las funciones son llamadas si son el primer elemento de una forma
+(funcion_llamada argumentos)
+
+; La mayoría de los operadores se hacen con funciones
+; Toda la aritmética básica es bastante estándar
+(+ 1 1) ; => 2
+(- 2 1) ; => 1
+(* 1 2) ; => 2
+(/ 2 1) ; => 2
+; incluso el módulo
+(% 9 4) ; => 1
+; división impar al estilo de JavaScript.
+(/ 5 2) ; => 2.5
+
+; Las formas anidadas funcionan como se espera.
+(* 2 (+ 1 3)) ; => 8
+
+; Hay un tipo booleano.
+true
+false
+
+; Los Strings son creados con comillas dobles ".
+"Hola mundo"
+
+; Los caracteres solos se declaran con comillas simples '.
+'a'
+
+; La negación usa la función 'not'.
+(not true) ; => false
+(not false) ; => true
+
+; La mayoría de las funcions que no vienen de Haskell tienen
+; atajos. La función 'not' también se puede declarar con '!'.
+(! (! true)) ; => true
+
+; La igualdad es `equal` o `=`.
+(= 1 1) ; => true
+(equal 2 1) ; => false
+
+; Por ejemplo, la desigualdad sería combinar la función 'not' con
+; la función de igualdad
+(! (= 2 1)) ; => true
+
+; Más comparaciones
+(< 1 10) ; => true
+(> 1 10) ; => false
+; y su contraparte textual.
+(lesser 1 10) ; => true
+(greater 1 10) ; => false
+
+; Los Strings pueden concatenarse con la función +.
+(+ "Hola " "mundo!") ; => "Hello world!"
+
+; También puedes usar las comparativas de JavaScript
+(< 'a' 'b') ; => true
+; ...y la coerción de tipos
+(= '5' 5)
+
+; La función 'at' o @ accesa a los caracteres dentro de los strings,
+; empezando en 0.
+(at 0 'a') ; => 'a'
+(@ 3 "foobar") ; => 'b'
+
+; También están las variables `null` and `undefined`.
+null; usado para indicar una falta de valor deliberada.
+undefined; usado para indicar un valor que aún no está definido.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 2. Variables, Listas y Diccionarios
+
+; Las variables son declaradas con las funciones `def` o `let`.
+; Las variables que aún no son asignadas tendrán el valor `undefined`.
+(def mi_variable 5)
+; `def` asignará la variable al contexto global.
+; `let` asignará la variable al contexto local,
+; y tiene una sintaxis distinta.
+(let ((mi_variable 5)) (+ mi_variable 5)) ; => 10
+(+ mi_variable 5) ; = undefined + 5 => undefined
+
+; Las listas son arreglos de valores de cualquier tipo.
+; Básicamente, son formas sin funciones al inicio.
+(1 2 3) ; => [1, 2, 3] (sintaxis JavaScript)
+
+; Los diccionarios son el equivalente en Whip de los 'objetos' de JavaScript,
+; los 'dicts' de Python o los 'hashes' de Ruby: una colección desordenada
+; de pares llave-valor
+{"llave1" "valor1" "llave2" 2 3 3}
+
+; Las llaves son sólo valores, identificadores, números o strings.
+(def mi_diccionario {mi_llave "mi_valor" "mi otra llave" 4})
+; Pero con Whip, los diccionarios son leidos así:
+; "llave" "espacio en blanco" "valor" "espacio en blanco"
+{"llave" "valor"
+"otra llave"
+1234
+}
+
+; Las definiciones de los diccionarios pueden accesarse con la función @
+; (como los strings y las listas)
+(@ "mi otra llave" mi_diccionario) ; => 4
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; 3. Logica y secuencias de control
+
+; La funcion `if` es bastante simple, aunque distinta que en otros lenguajes.
+(if true "regresa esto si es true" "regresa esto si es false")
+; => "regresa esto si es true"
+
+; Y para el operador ternario `?`
+(? false true false) ; => false
+
+? `both` es un 'y' lógico, mientras que la función `either` es un 'o'.
+(both true true) ; => true
+(both true false) ; => false
+(either true false) ; => true
+(either false false) ; => false
+; Y sus atajos son '&' y '^' respectivamente
+; & => both
+; ^ => either
+(& true true) ; => true
+(^ false true) ; => true
+
+;;;;;;;;;
+; Lambdas
+
+; Las Lambdas en Whip son declaradas con las funciones `lambda` o `->`.
+; Las funciones regulares en realidad sólo son lambdas con nombre.
+(def mi_funcion (-> (x y) (+ (+ x y) 10)))
+; | | | |
+; | | | valor regresado(estas son las variables argumentos)
+; | | argumentos
+; | declaración de lambda
+; |
+; nombre de la lambda
+
+(mi_funcion 10 10) ; = (+ (+ 10 10) 10) => 30
+
+; Obviamente, todas las lambdas por definición son anónimas y
+; técnicamente siempre usadas anónimamente. Redundancia.
+((lambda (x) x) 10) ; => 10
+
+;;;;;;;;;;;;;;;;
+; Comprensiones
+
+; `range` o `..` genera una lista de números que comprende
+; cada entero dentro de los argumentos.
+(range 1 5) ; => (1 2 3 4 5)
+(.. 0 2) ; => (0 1 2)
+
+; `map` aplica su primer argumento (que debe ser una función)
+; al siguiente argumento (que es una lista).
+(map (-> (x) (+ x 1)) (1 2 3)) ; => (2 3 4)
+
+; Reducir
+(reduce + (.. 1 5))
+; equivale a
+((+ (+ (+ 1 2) 3) 4) 5)
+
+; Nota: map y reduce no tienen atajos.
+
+; `slice` o `\` es idéntico a la función .slice() de JavaScript
+; Pero toma la lista del primer argumento, no del último.
+(slice (.. 1 5) 2) ; => (3 4 5)
+(\ (.. 0 100) -5) ; => (96 97 98 99 100)
+
+; `append` o `<<` se explica solo.
+(append 4 (1 2 3)) ; => (1 2 3 4)
+(<< "bar" ("foo")) ; => ("foo" "bar")
+
+; Length se explica solo.
+(length (1 2 3)) ; => 3
+(_ "foobar") ; => 6
+
+;;;;;;;;;;;;;;;
+; Elementos de Haskell
+
+; Primer elemento en una lista
+(head (1 2 3)) ; => 1
+
+; Lista del segundo elemento al último en una lista
+(tail (1 2 3)) ; => (2 3)
+
+; Último elemento en una lista
+(last (1 2 3)) ; => 3
+
+; Contrario a `tail`
+(init (1 2 3)) ; => (1 2)
+
+; Lista del primer elemento al argumento
+(take 1 (1 2 3 4)) ; (1 2)
+
+; Contrario a `take`
+(drop 1 (1 2 3 4)) ; (3 4)
+
+; Valor más pequeño de una lista
+(min (1 2 3 4)) ; 1
+
+; Valor más grande de una lista
+(max (1 2 3 4)) ; 4
+
+; Comprobar que el elemento está en la lista
+(elem 1 (1 2 3)) ; true
+(elem "foo" {"foo" "bar"}) ; true
+(elem "bar" {"foo" "bar"}) ; false
+
+; Invertir el orden de la lista
+(reverse (1 2 3 4)) ; => (4 3 2 1)
+
+; Comprobar si un elemento es par o impar
+(even 1) ; => false
+(odd 1) ; => true
+
+; Separar string en una lista de strings, separados por espacios
+(words "foobar nachos cheese") ; => ("foobar" "nachos" "cheese")
+; Juntar lista de strings.
+(unwords ("foo" "bar")) ; => "foobar"
+(pred 21) ; => 20
+(succ 20) ; => 21
+```
+
+Para más información, revisa el [repositorio](http://github.com/L8D/whip)
diff --git a/es-es/xml-es.html.markdown b/es-es/xml-es.html.markdown
new file mode 100644
index 00000000..2e9326cf
--- /dev/null
+++ b/es-es/xml-es.html.markdown
@@ -0,0 +1,131 @@
+---
+language: xml
+filename: learnxml.xml
+contributors:
+ - ["João Farias", "https://github.com/JoaoGFarias"]
+translators:
+ - ["Daniel Zendejas", "https://github.com/DanielZendejas"]
+lang: es-es
+---
+XML es un lenguaje diseñado para guardar y transportar datos
+
+A diferencia de HTML, XML no especifica cómo desplegar la información,
+sólo la guarda.
+
+* Sintaxis XML
+
+```xml
+<!-- Los comentarios en XML son de esta forma -->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<tiendaDeLibros>
+ <libro categoria="COCINA">
+ <titulo lenguaje="en">Everyday Italian</titulo>
+ <autor>Giada De Laurentiis</autor>
+ <anio>2005</anio>
+ <precio>30.00</precio>
+ </libro>
+ <libro categoria="INFANTES">
+ <titulo lenguaje="en">Harry Potter</titulo>
+ <autor>J K. Rowling</autor>
+ <anio>2005</anio>
+ <precio>29.99</precio>
+ </libro>
+ <libro categoria="WEB">
+ <titulo lenguaje="en">Learning XML</titulo>
+ <autor>Erik T. Ray</autor>
+ <anio>2003</anio>
+ <precio>39.95</precio>
+ </libro>
+</tiendaDeLibros>
+
+<!-- Este es un archivo típico de XML.
+ Empieza con una declaración de metadatos (opcional).
+
+ XML usa una estructura de árbol. El nodo raíz es 'tiendaDeLibros', el cual
+ tiene tres nodos hijos, todos llamados 'libros'.
+ Esos nodos tienen más nodos hijos, y así continúa...
+
+ Los nodos son creados usando tags que abren y cierran, y los hijos
+ son sólo nodos entre estas tags.-->
+
+
+<!-- XML guarda dos tipos de datos:
+ 1 - Atributos -> Son los metadatos de un nodo.
+ Usualmente el parseador XML usa esta información para guardar los datos
+ apropiadamente. Aparecen con el formato (nombre="valor") dentro de la
+ tag que abre.
+ 2 - Elementos -> Ese es el dato puro.
+ Eso es lo que el parseador recuperará del archivo XML.
+ Los elementos aparecen entre las tags que abren y cierran.-->
+
+
+<!-- Debajo, un elemento con dos atributos. -->
+<archivo tipo="gif" id="4293">computer.gif</archivo>
+
+
+```
+
+* Documentos con buen formato x Validación
+
+Un documento XML está bien formado cuando es sintácticamente correcto.
+Aún esto, es posible inyectar más restricciones en el documento,
+usando definiciones de documento, así como DTD o XML Schemas.
+
+Un documento XML que sigue a una definición de documento (un esquema) es
+válida.
+
+Con esta herramienta puedes validar datos XML fuera de la aplicación
+
+```xml
+
+<!-- Debajo puedes encontrar una versión simplificada del documento
+ tiendaDeLibros en adición a la definición DTD.-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE note SYSTEM "tiendaDeLibros.dtd">
+<tiendaDeLibros>
+ <libro categoriq="COCINA">
+ <titulo>Everyday Italian</titulo>
+ <precio>30.00</precio>
+ </libro>
+</tiendaDeLibros>
+
+<!-- El DTD de este documento podría verse algo así:-->
+
+<!DOCTYPE note
+[
+<!ELEMENT tiendaDeLibros (libro+)>
+<!ELEMENT libro (titulo,precio)>
+<!ATTLIST libro categoria CDATA "Literatura">
+<!ELEMENT titulo (#PCDATA)>
+<!ELEMENT precio (#PCDATA)>
+]>
+
+<!--El DTD empieza con una declaración.
+ Después el nodo raíz es declarado, requiriendo 1 o más nodos 'libro'
+ Cada 'libro' debe contener exactamente un 'titulo' y un 'precio' y
+ un atributo llamado 'categoria', con "Literatura" como su valor
+ default.
+ Los nodos 'titulo' y 'precio' contienen datos de caracteres
+ parseados.
+
+ El DTD puede ser declarado dentro del XML mismo.-->
+
+<?xml version="1.0" encoding="UTF-8"?>
+
+<!DOCTYPE note
+[
+<!ELEMENT tiendaDeLibros (libro+)>
+<!ELEMENT libro (titulo,precio)>
+<!ATTLIST libro categoria CDATA "Literatura">
+<!ELEMENT titulo (#PCDATA)>
+<!ELEMENT precio (#PCDATA)>
+]>
+<tiendaDeLibros>
+ <libro categoriq="COCINA">
+ <titulo>Everyday Italian</titulo>
+ <precio>30.00</precio>
+ </libro>
+</tiendaDeLibros>
+```
diff --git a/es-es/yaml-es.html.markdown b/es-es/yaml-es.html.markdown
new file mode 100644
index 00000000..a5157b5d
--- /dev/null
+++ b/es-es/yaml-es.html.markdown
@@ -0,0 +1,151 @@
+---
+language: yaml
+lang: es-es
+filename: learnyaml-es.yaml
+contributors:
+ - ["Adam Brenecki", "https://github.com/adambrenecki"]
+translators:
+ - ["Daniel Zendejas","https://github.com/DanielZendejas"]
+---
+Tutorial de YAML en español.
+
+YAML es un lenguaje de serialización de datos diseñado para ser
+leído y escrito por humanos.
+
+Basa su funcionalidad en JSON, con la adición de líneas nuevas
+e indentación inspirada en Python. A diferencia de Python, YAML
+no permite tabs literales.
+
+```yaml
+# Los comentarios en YAML se ven así.
+
+###################
+# TIPOS ESCALARES #
+###################
+
+# Nuestro objeto raíz (el cual es el mismo a lo largo de todo el
+# documento) será un mapa, equivalente a un diccionario, hash,
+# u objeto en otros lenguajes.
+
+llave: valor
+otra_llave: Otro valor
+un_valor_numerico: 100
+notacion_cientifica: 1e+12
+booleano: true
+valor_nulo: null
+llave con espacios: valor
+# Nótese que los strings no deben estar entre comillas, aunqué también es válido.
+llave: "Un string, entre comillas."
+"Las llaves tambien pueden estar entre comillas.": "valor entre comillas"
+
+# Los strings de líneas múltiples pueden ser escritos
+# como un 'bloque literal' (usando pipes |)
+# o como un 'bloque doblado' (usando >)
+
+bloque_literal: |
+ Este bloque completo de texto será preservado como el valor de la llave
+ 'bloque_literal', incluyendo los saltos de línea.
+
+ Se continúa guardando la literal hasta que se cese la indentación.
+ Cualquier línea que tenga más indentación, mantendrá los espacios dados
+ (por ejemplo, estas líneas se guardarán con cuatro espacios)
+
+nloque_doblado: >
+ De la misma forma que el valor de 'bloque_literal', todas estas
+ líneas se guardarán como una sola literal, pero en esta ocasión todos los
+ saltos de línea serán reemplazados por espacio.
+
+ Las líneas en blanco, como la anterior, son convertidos a un salto de línea.
+
+ Las líneas con mayor indentación guardan sus saltos de línea.
+ Esta literal ocuparán dos líneas.
+
+########################
+# TIPOS DE COLECCIONES #
+########################
+
+# La indentación se usa para anidar.
+un_mapa_indentado:
+ llave: valor
+ otra_llave: otro valor
+ otro_mapa_indentado:
+ llave_interna: valor_interno
+
+# Las llaves de los mapas no deben ser strings necesariamente
+0.25: una llave numérica
+
+# Las llaves también pueden ser objetos de multi línea, usando ? para indicar
+# el inicio de una llave
+? |
+ Esto es una llave
+ que tiene múltiples líneas
+: y este es su valor
+
+# YAML tambien permite colecciones como llaves, pero muchos lenguajes de
+# programación se quejarán.
+
+# Las secuencias (equivalentes a listas o arreglos) se ven así:
+una_secuencia:
+ - Item 1
+ - Item 2
+ - 0.5 # las secuencias pueden tener distintos tipos en su contenido.
+ - Item 4
+ - llave: valor
+ otra_llave: otro_valor
+ -
+ - Esta es una secuencia
+ - ...dentro de otra secuencia
+
+# Dado que todo JSON está incluído dentro de YAML, también puedes escribir
+# mapas con la sintaxis de JSON y secuencias:
+mapa_de_json: {"llave": "valor"}
+secuencia_de_json: [3, 2, 1, "despegue"]
+
+##################################
+# CARACTERÍSTICAS EXTRAS DE YAML #
+##################################
+
+# YAML tiene funciones útiles llamadas 'anchors' (anclas), que te permiten
+# duplicar fácilmente contenido a lo largo de tu documento. En el ejemplo
+# a continuación, ambas llaves tendrán el mismo valor:
+contenido_anclado: &nombre_del_ancla Este string será el valor de las llaves
+otra_ancla: *nombre_del_ancla
+
+# YAML también tiene tags, que puedes usar para declarar tipos explícitamente.
+string_explícito: !!str 0.5
+# Algunos parseadores implementar tags específicas del lenguaje, como el
+# que se muestra a continuación, encargado de manejar números complejos en
+# Python:
+numero_complejo_python: !!python/complex 1+2j
+
+########################
+# TIPOS EXTRAS EN YAML #
+########################
+
+# Stirngs y números no son los únicos escalares que YAML puede entener.
+# YAML también puede parsear fechas en formato ISO .
+fechaHora: 2001-12-15T02:59:43.1Z
+fechaHora_con_espacios: 2001-12-14 21:59:43.10 -5
+fecha: 2002-12-14
+
+# La tag !!binary indica que un string es, en realidad, un blob
+# representado en base-64.
+archivo_gif: !!binary |
+ R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+ OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+ +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+ AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
+
+# YAML también tiene un tipo set, que se ve de la siguiente forma:
+set:
+ ? item1
+ ? item2
+ ? item3
+
+# Al igual que Python, los sets sólo son mapas con valores nulos.
+# El ejemplo de arriba es equivalente a:
+set2:
+ item1: null
+ item2: null
+ item3: null
+```