Merge remote-tracking branch 'adambard/master' into adambard/master-cn

25 files changed, 8989 insertions, 0 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/c++-es.html.markdown b/es-es/c++-es.html.markdown
new file mode 100644
index 00000000..bcc775e5
--- /dev/null
+++ b/es-es/c++-es.html.markdown
@@ -0,0 +1,829 @@
+---
+language: c++
+filename: learncpp.cpp
+contributors:
+    - ["Steven Basart", "http://github.com/xksteven"]
+    - ["Matt Kline", "https://github.com/mrkline"]
+    - ["Geoff Liu", "http://geoffliu.me"]
+    - ["Connor Waters", "http://github.com/connorwaters"]
+translators:
+    - ["Gerson Lázaro", "https://gersonlazaro.com"]
+lang: es-es
+---
+
+C++ es un lenguaje de programación de sistemas que,
+[de acuerdo a su inventor Bjarne Stroustrup](http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Keynote),
+fue diseñado para
+
+- ser un "mejor C"
+- soportar abstracción de datos
+- soportar programación orientada a objetos
+- soportar programación genérica
+
+Aunque su sintaxis puede ser más difícil o compleja que los nuevos lenguajes, 
+es ampliamente utilizado, ya que compila instrucciones nativas que pueden ser 
+directamente ejecutadas por el procesador y ofrece un estricto control sobre 
+el hardware (como C), mientras ofrece características de alto nivel como 
+genericidad, excepciones, y clases. Esta combinación de velocidad y 
+funcionalidad hace de C ++ uno de los lenguajes de programación más utilizados.
+
+```c++
+////////////////////
+// Comparación con C
+////////////////////
+
+// C ++ es _casi_ un superconjunto de C y comparte su sintaxis básica para las 
+// declaraciones de variables, tipos primitivos y funciones.
+
+// Al igual que en C, el punto de entrada de tu programa es una función llamada 
+// main con un retorno de tipo entero. 
+// Este valor sirve como código de salida del programa.
+// Mira http://en.wikipedia.org/wiki/Exit_status para mayor información.
+int main(int argc, char** argv)
+{
+	// Los argumentos de la línea de comandos se pasan por argc y argv de la 
+	// misma manera que en C.
+	// argc indica el número de argumentos, 
+	// y argv es un arreglo de strings de estilo C (char*) 
+	// representando los argumentos.
+	// El primer argumento es el nombre con el que el programa es llamado.
+	// argc y argv pueden omitirse si no te preocupan los argumentos, 
+	// dejando la definición de la función como int main ()
+
+	// Un estado de salida 0 indica éxito.
+    return 0;
+}
+
+// Sin embargo, C ++ varía en algunas de las siguientes maneras:
+
+// En C++, los caracteres literales son caracteres
+sizeof('c') == sizeof(char) == 1
+
+// En C, los caracteres literales son enteros
+sizeof('c') == sizeof(int)
+
+
+// C++ tiene prototipado estricto
+void func(); // función que no acepta argumentos
+
+// En C
+void func(); // función que puede aceptar cualquier número de argumentos
+
+// Use nullptr en lugar de NULL en C++
+int* ip = nullptr;
+
+// Las cabeceras (headers) estándar de C están disponibles en C ++, 
+// pero tienen el prefijo "c" y no tienen sufijo .h.
+#include <cstdio>
+
+int main()
+{
+    printf("Hola mundo!\n");
+    return 0;
+}
+
+//////////////////////////
+// Sobrecarga de funciones
+//////////////////////////
+
+// C++ soporta sobrecarga de funciones
+// siempre que cada función tenga diferentes parámetros.
+
+void print(char const* myString)
+{
+    printf("String %s\n", myString);
+}
+
+void print(int myInt)
+{
+    printf("Mi entero es %d", myInt);
+}
+
+int main()
+{
+    print("Hello"); // Resolves to void print(const char*)
+    print(15); // Resolves to void print(int)
+}
+
+////////////////////////////////////
+// Argumentos de función por defecto
+////////////////////////////////////
+
+// Puedes proporcionar argumentos por defecto para una función si no son 
+// proporcionados por quien la llama.
+
+void doSomethingWithInts(int a = 1, int b = 4)
+{
+    // Hacer algo con los enteros aqui
+}
+
+int main()
+{
+    doSomethingWithInts();      // a = 1,  b = 4
+    doSomethingWithInts(20);    // a = 20, b = 4
+    doSomethingWithInts(20, 5); // a = 20, b = 5
+}
+
+// Los argumentos predeterminados deben estar al final de la lista de argumentos.
+
+void invalidDeclaration(int a = 1, int b) // Error!
+{
+}
+
+/////////////////////
+// Espacios de nombre
+/////////////////////
+
+// Espacios de nombres proporcionan ámbitos separados para variable, función y 
+// otras declaraciones.
+// Los espacios de nombres se pueden anidar.
+
+namespace First {
+    namespace Nested {
+        void foo()
+        {
+            printf("Esto es First::Nested::foo\n");
+        }
+    } // fin del nombre de espacio Nested
+} // fin del nombre de espacio First
+
+namespace Second {
+    void foo()
+    {
+        printf("Esto es Second::foo\n")
+    }
+}
+
+void foo()
+{
+    printf("Este es global: foo\n");
+}
+
+int main()
+{
+
+	// Incluye todos los símbolos del espacio de nombre Second en el ámbito 
+	// actual. Tenga en cuenta que simplemente foo() no funciona, ya que ahora 
+	// es ambigua si estamos llamando a foo en espacio de nombres Second o en
+	// el nivel superior.
+    using namespace Second;
+
+    Second::foo(); // imprime "Esto es Second::foo"
+    First::Nested::foo(); // imprime "Esto es First::Nested::foo"
+    ::foo(); // imprime "Este es global: foo"
+}
+
+/////////////////
+// Entrada/Salida
+/////////////////
+
+// La entrada y salida de C++ utiliza flujos (streams)
+// cin, cout, y cerr representan a stdin, stdout, y stderr.
+// << es el operador de inserción >> es el operador de extracción.
+
+
+#include <iostream> // Incluir para el flujo de entrada/salida
+
+using namespace std; // Los streams estan en std namespace (libreria estandar)
+
+int main()
+{
+   int myInt;
+
+   // Imprime a la stdout (o terminal/pantalla)
+   cout << "Ingresa tu número favorito:\n";
+   // Toma una entrada
+   cin >> myInt;
+
+   // cout puede también ser formateado
+   cout << "Tu número favorito es " << myInt << "\n";
+   // imprime "Tu número favorito es <myInt>"
+
+    cerr << "Usado para mensajes de error";
+}
+////////////////////
+// Cadenas (Strings)
+////////////////////
+
+// Las cadenas en C++ son objetos y tienen muchas funciones
+#include <string>
+
+using namespace std; // Strings también estan en namespace std
+
+string myString = "Hola";
+string myOtherString = " Mundo";
+
+// + es usado para concatenar.
+cout << myString + myOtherString; // "Hola Mundo"
+
+cout << myString + " Tu"; // "Hola Tu"
+
+// Las cadenas en C++ son mutables y tienen valor semántico.
+myString.append(" Perro");
+cout << myString; // "Hola Perro"
+
+
+//////////////
+// Referencias
+//////////////
+
+// Además de punteros como los de C,
+// C++ tiene _references_.
+// Estos tipos de puntero no pueden ser reasignados una vez establecidos
+// Y no pueden ser nulos.
+// También tienen la misma sintaxis que la propia variable:
+// No es necesaria * para eliminar la referencia y
+// & (dirección) no se utiliza para la asignación.
+
+using namespace std;
+
+string foo = "Yo soy foo";
+string bar = "Yo soy bar";
+
+string& fooRef = foo; // Crea una referencia a foo.
+fooRef += ". Hola!"; // Modifica foo través de la referencia
+cout << fooRef; // Imprime "Yo soy foo. Hola!"
+
+// No trate de reasignar "fooRef". Esto es lo mismo que "foo = bar", y
+//   foo == "Yo soy bar"
+// después de esta linea.
+fooRef = bar;
+
+const string& barRef = bar; // Crea una referencia constante a bar.
+// Como en C, los valores constantes (y punteros y referencias) no pueden ser
+// modificados.
+barRef += ". Hola!"; // Error, referencia constante no puede ser modificada.
+
+// Sidetrack: Antes de hablar más sobre referencias, hay que introducir un 
+// concepto llamado objeto temporal. Supongamos que tenemos el siguiente código:
+string tempObjectFun() { ... }
+string retVal = tempObjectFun();
+
+// Lo que pasa en la segunda línea es en realidad:
+// - Un objeto de cadena es retornado desde tempObjectFun
+// - Una nueva cadena se construye con el objeto devuelto como argumento al
+// constructor
+// - El objeto devuelto es destruido
+// El objeto devuelto se llama objeto temporal. Objetos temporales son
+// creados cada vez que una función devuelve un objeto, y es destruido en el
+// fin de la evaluación de la expresión que encierra (Bueno, esto es lo que la
+// norma dice, pero los compiladores están autorizados a cambiar este 
+// comportamiento. Busca "return value optimization" para ver mas detalles). 
+// Así que en este código:
+foo(bar(tempObjectFun()))
+
+// Suponiendo que foo y bar existen, el objeto retornado de tempObjectFun es
+// pasado al bar, y se destruye antes de llamar foo.
+
+// Ahora, de vuelta a las referencias. La excepción a la regla "en el extremo 
+// de la expresión encerrada" es si un objeto temporal se une a una 
+// referencia constante, en cuyo caso su vida se extiende al ámbito actual:
+
+void constReferenceTempObjectFun() {
+  // ConstRef obtiene el objeto temporal, y es válido hasta el final de esta
+  // función.
+  const string& constRef = tempObjectFun();
+  ...
+}
+
+// Otro tipo de referencia introducida en C ++ 11 es específicamente para
+// objetos temporales. No se puede tener una variable de este tipo, pero tiene 
+// prioridad en resolución de sobrecarga:
+
+void someFun(string& s) { ... }  // Referencia regular
+void someFun(string&& s) { ... }  // Referencia a objeto temporal
+
+string foo;
+someFun(foo);  // Llama la función con referencia regular
+someFun(tempObjectFun());  // Llama la versión con referencia temporal
+
+// Por ejemplo, puedes ver estas dos versiones de constructores para
+// std::basic_string:
+basic_string(const basic_string& other);
+basic_string(basic_string&& other);
+
+// La idea es que si estamos construyendo una nueva cadena de un objeto temporal 
+// (que va a ser destruido pronto de todos modos), podemos tener un constructor
+// mas eficiente que "rescata" partes de esa cadena temporal. Usted verá este
+// Concepto denominado "movimiento semántico".
+
+////////////////////////////////////////////
+// Clases y programación orientada a objetos
+////////////////////////////////////////////
+
+// Primer ejemplo de clases
+#include <iostream>
+
+// Declara una clase.
+// Las clases son usualmente declaradas en archivos de cabeceras (.h o .hpp)
+class Dog {
+    // Variables y funciones de la clase son privados por defecto.
+    std::string name;
+    int weight;
+
+// Todos los miembros siguientes de este son públicos
+// Hasta que se encuentre "private" o "protected".
+// All members following this are public
+// until "private:" or "protected:" is found.
+public:
+
+    // Constructor por defecto
+    Dog();
+
+	// Declaraciones de funciones de la clase (implementaciones a seguir)
+    // Nota que usamos std::string aquí en lugar de colocar
+    // using namespace std;
+    // arriba.
+    // Nunca ponga una declaración "using namespace" en un encabezado.
+    void setName(const std::string& dogsName);
+
+    void setWeight(int dogsWeight);
+	// Funciones que no modifican el estado del objeto
+	// Deben marcarse como const.
+	// Esto le permite llamarlas si se envia una referencia constante al objeto.
+	// También tenga en cuenta que las funciones deben ser declaradas 
+	// explícitamente como _virtual_ para que sea reemplazada en las clases 
+	// derivadas.
+	// Las funciones no son virtuales por defecto por razones de rendimiento.	
+    virtual void print() const;
+
+    // Las funciones también se pueden definir en el interior 
+    // del cuerpo de la clase.
+	// Funciones definidas como tales están entre líneas automáticamente.
+    void bark() const { std::cout << name << " barks!\n"; }
+
+    // Junto a los constructores, C++ proporciona destructores.
+	// Estos son llamados cuando un objeto se elimina o está fuera del ámbito.
+	// Esto permite paradigmas potentes como RAII
+	// (mira abajo)
+	// El destructor debe ser virtual si una clase es dervada desde el;
+	// Si no es virtual, entonces la clase derivada destructor
+	// No será llamada si el objeto se destruye a través de una referencia de 
+	// la clase base o puntero.
+    virtual ~Dog();
+
+
+
+}; // Un punto y coma debe seguir la definición de clase.
+
+// Las funciones de una clase son normalmente implementados en archivos .cpp.
+Dog::Dog()
+{
+    std::cout << "Un perro ha sido construido\n";
+}
+
+// Objetos (tales como cadenas) deben ser pasados por referencia
+// Si los estas modificando o referencia constante en caso contrario.
+void Dog::setName(const std::string& dogsName)
+{
+    name = dogsName;
+}
+
+void Dog::setWeight(int dogsWeight)
+{
+    weight = dogsWeight;
+}
+
+// Nota que "virtual" sólo se necesita en la declaración, no en la definición.
+void Dog::print() const
+{
+    std::cout << "El perro es " << name << " y pesa " << weight << "kg\n";
+}
+
+Dog::~Dog()
+{
+    cout << "Adiós " << name << "\n";
+}
+
+int main() {
+    Dog myDog; // imprime "Un perro ha sido construido"
+    myDog.setName("Barkley");
+    myDog.setWeight(10);
+    myDog.print(); // imprime "El perro es Barkley y pesa 10 kg"
+    return 0;
+} // imprime "Adiós Barkley"
+
+// Herencia:
+
+// Esta clase hereda todo lo público y protegido de la clase Dog
+class OwnedDog : public Dog {
+
+    void setOwner(const std::string& dogsOwner);
+
+	// Reemplaza el comportamiento de la función de impresión 
+	// de todos los OwnedDogs. Mira
+	// http://en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping
+	// Para una introducción más general si no está familiarizado con el
+	// polimorfismo de subtipo.
+	// La palabra clave override es opcional, pero asegura que estás
+	// reemplazando el método de una clase base.
+    void print() const override;
+
+private:
+    std::string owner;
+};
+
+// Mientras tanto, en el archivo .cpp correspondiente:
+
+void OwnedDog::setOwner(const std::string& dogsOwner)
+{
+    owner = dogsOwner;
+}
+
+void OwnedDog::print() const
+{
+    Dog::print(); // Llama a la función de impresión en la clase base Dog
+    std::cout << "El perro es de " << owner << "\n";
+    // Imprime "El perro es <name> y pesa <weight>"
+    //         "El perro es de <owner>"
+}
+
+////////////////////////////////////////////
+// Inicialización y sobrecarga de operadores
+////////////////////////////////////////////
+
+// En C ++ se puede sobrecargar el comportamiento 
+// de los operadores como +, -, *, /, etc.
+// Esto se hace mediante la definición de una función que es llamada
+// cada vez que se utiliza el operador.
+
+#include <iostream>
+using namespace std;
+
+class Point {
+public:
+    // Las variables de la clase pueden dar valores por defecto de esta manera.
+    double x = 0;
+    double y = 0;
+
+	// Define un constructor por defecto que no hace nada
+    // pero inicializa el punto al valor por defecto (0, 0)
+    Point() { };
+
+    // The following syntax is known as an initialization list
+    // and is the proper way to initialize class member values
+    Point (double a, double b) :
+        x(a),
+        y(b)
+    { /* No hace nada excepto inicializar los valores */ }
+
+    // Sobrecarga el operador +
+    Point operator+(const Point& rhs) const;
+
+    // Sobrecarga el operador +=
+    Point& operator+=(const Point& rhs);
+
+    // También tendría sentido añadir los operadores - y -=,
+   	// Pero vamos a omitirlos por razones de brevedad.
+};
+
+Point Point::operator+(const Point& rhs) const
+{
+    // Crea un nuevo punto que es la suma de este y rhs.
+    return Point(x + rhs.x, y + rhs.y);
+}
+
+Point& Point::operator+=(const Point& rhs)
+{
+    x += rhs.x;
+    y += rhs.y;
+    return *this;
+}
+
+int main () {
+    Point up (0,1);
+    Point right (1,0);
+    // Llama al operador + de Point
+    // Point llama la función + con right como parámetro
+    Point result = up + right;
+    // Prints "Result is upright (1,1)"
+    cout << "Result is upright (" << result.x << ',' << result.y << ")\n";
+    return 0;
+}
+
+/////////////////////////
+// Plantillas (Templates)
+/////////////////////////
+
+// Las plantillas en C++ se utilizan sobre todo en la programación genérica, 
+// a pesar de que son mucho más poderoso que los constructores genéricos 
+// en otros lenguajes. Ellos también soportan especialización explícita y 
+// parcial y clases de tipo estilo funcional; de hecho, son un lenguaje 
+// funcional Turing-completo incrustado en C ++!
+
+// Empezamos con el tipo de programación genérica que podría estar 
+// familiarizado. 
+// Para definir una clase o función que toma un parámetro de tipo:
+template<class T>
+class Box {
+public:
+    // En este caso, T puede ser usado como cualquier otro tipo.
+    void insert(const T&) { ... }
+};
+
+// Durante la compilación, el compilador realmente genera copias de cada 
+// plantilla con parámetros sustituidos, por lo que la definición completa 
+// de la clase debe estar presente en cada invocación. 
+// Es por esto que usted verá clases de plantilla definidas
+// Enteramente en archivos de cabecera.
+
+//Para crear una instancia de una clase de plantilla en la pila:
+Box<int> intBox;
+
+y puedes utilizarlo como era de esperar:
+intBox.insert(123);
+
+// Puedes, por supuesto, anidar plantillas:
+Box<Box<int> > boxOfBox;
+boxOfBox.insert(intBox);
+
+// Hasta C++11, había que colocar un espacio entre los dos '>'s, 
+// de lo contrario '>>' serían analizados como el operador de desplazamiento 
+// a la derecha.
+
+
+// A veces verás
+//   template<typename T>
+// en su lugar. La palabra clave "class" y las palabras clave "typename" son
+// mayormente intercambiables en este caso. Para la explicación completa, mira
+//   http://en.wikipedia.org/wiki/Typename
+// (sí, esa palabra clave tiene su propia página de Wikipedia).
+
+// Del mismo modo, una plantilla de función:
+template<class T>
+void barkThreeTimes(const T& input)
+{
+    input.bark();
+    input.bark();
+    input.bark();
+}
+
+// Observe que no se especifica nada acerca de los tipos de parámetros aquí. 
+// El compilador generará y comprobará cada invocación de la plantilla, 
+// por lo que la función anterior funciona con cualquier tipo "T" 
+// que tenga un método 'bark' constante!
+
+
+Dog fluffy;
+fluffy.setName("Fluffy")
+barkThreeTimes(fluffy); // Imprime "Fluffy barks" 3 veces.
+
+Los parámetros de la plantilla no tienen que ser las clases:
+template<int Y>
+void printMessage() {
+  cout << "Aprende C++ en " << Y << " minutos!" << endl;
+}
+
+// Y usted puede especializar explícitamente plantillas 
+// para código más eficiente. 
+// Por supuesto, la mayor parte del mundo real que utiliza una especialización 
+// no son tan triviales como esta.
+// Tenga en cuenta que usted todavía tiene que declarar la función (o clase) 
+// como plantilla incluso si ha especificado de forma explícita todos 
+// los parámetros.
+
+template<>
+void printMessage<10>() {
+  cout << "Aprende C++ rapido en solo 10 minutos!" << endl;
+}
+
+printMessage<20>();  // Prints "Aprende C++ en 20 minutos!"
+printMessage<10>();  // Prints "Aprende C++ rapido en solo 10 minutos!"
+
+
+/////////////////////
+// Manejador de excepciones
+/////////////////////
+
+// La biblioteca estándar proporciona algunos tipos de excepción
+// (mira http://en.cppreference.com/w/cpp/error/exception)
+// pero cualquier tipo puede ser lanzado como una excepción
+#include <exception>
+#include <stdexcept>
+
+//Todas las excepciones lanzadas dentro del bloque _try_ pueden ser 
+// capturados por los siguientes manejadores _catch_.
+try {
+    // No asignar excepciones en el heap usando _new_.
+    throw std::runtime_error("Ocurrió un problema");
+}
+
+// Captura excepciones por referencia const si son objetos
+catch (const std::exception& ex)
+{
+    std::cout << ex.what();
+}
+********************************************************************************
+// Captura cualquier excepción no capturada por bloques _catch_ anteriores
+catch (...)
+{
+    std::cout << "Excepción desconocida capturada";
+    throw; // Re-lanza la excepción
+}
+
+///////
+// RAII
+///////
+
+// RAII significa "Resource Acquisition Is Initialization"
+// (Adquisición de recursos es inicialización).
+// A menudo se considera el paradigma más poderoso en C++
+// Y el concepto es simple: un constructor de un objeto
+// Adquiere recursos de ese objeto y el destructor les libera.
+
+// Para entender cómo esto es útil,
+// Considere una función que utiliza un identificador de archivo C:
+void doSomethingWithAFile(const char* filename)
+{
+    // Para empezar, asuma que nada puede fallar.
+
+    FILE* fh = fopen(filename, "r"); // Abre el archivo en modo lectura
+
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+    fclose(fh); // Cierra el manejador de archivos
+}
+
+// Por desgracia, las cosas se complican rápidamente por el control de errores.
+// Supongamos que fopen puede fallar, y que doSomethingWithTheFile y
+// DoSomethingElseWithIt retornan códigos de error si fallan.
+// 	(Excepciones son la mejor forma de manejar los fallos,
+// 	 pero algunos programadores, especialmente los que tienen un fondo C,
+// 	 estan en desacuerdo sobre la utilidad de las excepciones).
+// Ahora tenemos que comprobar cada llamado por fallos y cerrar el manejador 
+// del archivo si se ha producido un problema.
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); // Abre el archivo en modo lectura
+    if (fh == nullptr) // El puntero retornado es nulo o falla.
+        return false; // Reporta el fallo a quien hizo el llamado.
+
+    // Asume que cada función retorna falso si falla
+    if (!doSomethingWithTheFile(fh)) {
+        fclose(fh); // Cierre el manejador de archivo para que no se filtre.
+        return false; // Propaga el error.
+    }
+    if (!doSomethingElseWithIt(fh)) {
+        fclose(fh); // Cierre el manejador de archivo para que no se filtre.
+        return false; // Propaga el error.
+    }
+
+    fclose(fh); // Cierre el archivo.
+    return true; // Indica que todo funcionó correctamente.
+}
+
+// Programadores C suelen limpiar esto un poco usando goto:
+bool doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r");
+    if (fh == nullptr)
+        return false;
+
+    if (!doSomethingWithTheFile(fh))
+        goto failure;
+
+    if (!doSomethingElseWithIt(fh))
+        goto failure;
+
+    fclose(fh); // Cierre el archivo.
+    return true; // Indica que todo funcionó correctamente.
+
+failure:
+    fclose(fh);
+    return false; // Propagate el error
+}
+
+// Si las funciones indican errores mediante excepciones,
+// Las cosas son un poco más claras, pero pueden optimizarse mas.
+void doSomethingWithAFile(const char* filename)
+{
+    FILE* fh = fopen(filename, "r"); // Abrir el archivo en modo lectura
+    if (fh == nullptr)
+        throw std::runtime_error("No puede abrirse el archivo.");
+
+    try {
+        doSomethingWithTheFile(fh);
+        doSomethingElseWithIt(fh);
+    }
+    catch (...) {
+        fclose(fh); // Asegúrese de cerrar el archivo si se produce un error.
+        throw; // Luego vuelve a lanzar la excepción.
+    }
+
+    fclose(fh); // Cierra el archivo
+}
+
+// Compare esto con el uso de la clase de flujo de archivos de C++ (fstream)
+// fstream utiliza su destructor para cerrar el archivo.
+// Los destructores son llamados automáticamente 
+// cuando un objeto queda fuera del ámbito.
+void doSomethingWithAFile(const std::string& filename)
+{
+    // ifstream es la abreviatura de el input file stream
+    std::ifstream fh(filename); // Abre el archivo
+
+    // Hacer algo con el archivo
+    doSomethingWithTheFile(fh);
+    doSomethingElseWithIt(fh);
+
+} // El archivo se cierra automáticamente aquí por el destructor
+
+
+// Esto tiene ventajas _enormes_:
+// 1. No importa lo que pase,
+//    El recurso (en este caso el manejador de archivo) será limpiado.
+//    Una vez que escribes el destructor correctamente,
+//    Es _imposible_ olvidar cerrar el identificador y permitir 
+//    fugas del recurso.
+// 2. Tenga en cuenta que el código es mucho más limpio.
+//    El destructor se encarga de cerrar el archivo detrás de cámaras
+//    Sin que tenga que preocuparse por ello.
+// 3. El código es seguro.
+//    Una excepción puede ser lanzado en cualquier lugar de la función
+//    y la limpieza ocurrirá.
+
+// Todo el código idiomático C++ utiliza RAII ampliamente para todos los 
+// recursos.
+// Otros ejemplos incluyen
+// - Memoria usando unique_ptr y shared_ptr
+// - Contenedores (Containers) - la biblioteca estándar linked list,
+//   vector (es decir, array con auto-cambio de tamaño), hash maps, etc.
+//   Destruimos todos sus contenidos de forma automática 
+//   cuando quedan fuera del ámbito.
+// - Mutex utilizando lock_guard y unique_lock
+
+
+/////////////////////
+// Cosas divertidas
+/////////////////////
+
+// Aspectos de C ++ que pueden sorprender a los recién llegados 
+// (e incluso algunos veteranos).
+// Esta sección es, por desgracia, salvajemente incompleta; 
+// C++ es uno de los lenguajes con los que mas facil te disparas en el pie.
+
+// Tu puedes sobreescribir métodos privados!
+class Foo {
+  virtual void bar();
+};
+class FooSub : public Foo {
+  virtual void bar();  // Sobreescribe Foo::bar!
+};
+
+
+// 0 == false == NULL (La mayoria de las veces)!
+bool* pt = new bool;
+*pt = 0; // Establece los puntos de valor de 'pt' en falso.
+pt = 0;  // Establece 'pt' al apuntador nulo. Ambas lineas compilan sin error.
+
+// nullptr se supone que arregla un poco de ese tema:
+int* pt2 = new int;
+*pt2 = nullptr; // No compila
+pt2 = nullptr;  // Establece pt2 como null.
+
+// Hay una excepción para los valores bool.
+// Esto es para permitir poner a prueba punteros nulos con if (!ptr),
+// pero como consecuencia se puede asignar nullptr a un bool directamente!
+*pt = nullptr;  // Esto todavía compila, a pesar de que '*pt' es un bool!
+
+// '=' != '=' != '='!
+// Llama Foo::Foo(const Foo&) o alguna variante (mira movimientos semanticos) 
+// copia del constructor.
+Foo f2;
+Foo f1 = f2;
+
+// Llama Foo::Foo(const Foo&) o variante, pero solo copia el 'Foo' parte de
+// 'fooSub'. Cualquier miembro extra de 'fooSub' se descarta. Este 
+// comportamiento horrible se llama "Corte de objetos."
+FooSub fooSub;
+Foo f1 = fooSub;
+
+// Llama a Foo::operator=(Foo&) o variantes.
+Foo f1;
+f1 = f2;
+
+
+// Cómo borrar realmente un contenedor:
+class Foo { ... };
+vector<Foo> v;
+for (int i = 0; i < 10; ++i)
+  v.push_back(Foo());
+// La siguiente línea establece el tamaño de v en 0, 
+// pero los destructores no son llamados y los recursos no se liberan!
+
+v.empty();
+v.push_back(Foo());  // Nuevo valor se copia en el primer Foo que insertamos
+
+// En verdad destruye todos los valores en v. 
+// Consulta la sección acerca de los objetos temporales para la
+// explicación de por qué esto funciona.
+v.swap(vector<Foo>());
+
+```
+Otras lecturas:
+
+Una referencia del lenguaje hasta a la fecha se puede encontrar en
+<http://cppreference.com/w/cpp>
+
+Recursos adicionales se pueden encontrar en <http://cplusplus.com>
diff --git a/es-es/c-es.html.markdown b/es-es/c-es.html.markdown
new file mode 100644
index 00000000..5d3aae0c
--- /dev/null
+++ b/es-es/c-es.html.markdown
@@ -0,0 +1,425 @@
+---
+language: c
+filename: learnc-es.c
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+translators:
+    - ["Francisco García", "http://flaskbreaker.tumblr.com/"]
+lang: es-es
+---
+
+¡Ah!, C. Aun hoy en día sigue siendo el lenguaje por excelencia de la 
+computación moderna de alto rendimiento.
+
+C es el lenguaje de más bajo nivel que la mayoría de los programadores
+llegarán a usar, pero lo compensa de sobra con pura velocidad. Solo
+ten en cuenta el manejo manual de memoria y te llevará tan lejos como
+necesites.
+
+```c
+// Los comentarios de una sola línea comienzan con //
+
+/*
+Los comentarios multilínea tienen este aspecto.
+*/
+
+// Importa cabeceras con #include
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+// Declara por adelantado las armaduras de las funciones en un archivo .h,
+// o al principio de tu archivo .c .
+void function_1();
+void function_2();
+
+// El punto de entrada de tu programa es una función llamada main con
+// retorno de tipo entero (integer).
+int main() {
+
+// Muestra la salida usando printf, para el "formato print"
+// %d es un entero, \n es una nueva línea
+printf("%d\n", 0); // => Muestra 0
+// Todas las sentencias deben terminar con un punto y coma.
+
+///////////////////////////////////////
+// Tipos
+///////////////////////////////////////
+
+// Tienes que declarar una variable antes de usarla. La declaración de una
+// variable necesites que especifiques su tipo; el tipo de una variable
+// determina su tamaño en bytes.
+
+// 'ints' (enteros) son normalmente de 4 bytes
+int x_int = 0;
+
+// 'shorts' son normalmente de 2 bytes
+short x_short = 0;
+
+// 'chars' son fijo de 1 byte
+char x_char = 0;
+char y_char = 'y'; // Los caracteres literales se entrecomillan con ''
+
+// 'longs' son a menudo de 4 a 8 bytes; 'long longs' son fijo de por lo
+// menos 64 bits
+long x_long = 0;
+long long x_long_long = 0; 
+
+// 'floats' son normalmente números de coma flotante de 32 bits
+float x_float = 0.0;
+
+// 'doubles' son normalmente números de coma flotante de 64 bits
+double x_double = 0.0;
+
+// Todos los tipos enteros pueden ser 'unsigned'. Esto significa que no
+// pueden ser negativos, pero el valor máximo de una variable 'unsigned'
+// es mayor que el de una no 'unsigned' del mismo tamaño.
+unsigned char ux_char;
+unsigned short ux_short;
+unsigned int ux_int;
+unsigned long long ux_long_long;
+
+// Todos menos 'char', que es siempre de 1 byte, varían el tamaño 
+// dependiendo de tu máquina. sizeof(T) te dice el tamaño de una variable
+// de tipo T en bytes por lo que podemos expresar el tamaño de estos tipos
+// portatilmente.
+// Por ejemplo,
+printf("%lu\n", sizeof(int)); // => 4 (en máquinas con 'words' de 4 bytes)
+
+// Los arrays deben ser inicializados con un tamaño concreto.
+char my_char_array[20]; // Este array ocupa 1 * 20 = 20 bytes
+int my_int_array[20]; // Este array ocupa 4 * 20 = 80 bytes
+                      // (suponiendo que tenemos 'words' de 4-byte)
+
+
+// Puedes inicializar un array a 0 así:
+char my_array[20] = {0};
+
+// Indexar un array es como en otros lenguajes -o, más bien, otros
+// lenguajes son como C-
+my_array[0]; // => 0
+
+// Los arrays varían; ¡son sólo memoria!
+my_array[1] = 2;
+printf("%d\n", my_array[1]); // => 2
+
+// Las cadenas (strings) son sólo arrays de 'chars' (caracteres)
+// terminados en un byte NUL (0x00), representado en las cadenas como el
+// carácter especial '\0'.
+// (No tenemos porqué añadir el byte nulo en cadenas literales; el
+// compilador lo añade al final por nosotros.)
+char a_string[20] = "Esto es una cadena";
+printf("%s\n", a_string); // %s se sutituye por una cadena.
+
+/*
+Te habrás dado cuenta de que a_string es solo de 18 caracteres.
+El 'char' #19 es el byte nulo. 
+El 'char' #20 es de valor indefinido.
+*/
+
+printf("%d\n", a_string[18]); // => 0
+
+///////////////////////////////////////
+// Operadores
+///////////////////////////////////////
+
+int i1 = 1, i2 = 2; // Forma corta de declaración múltiple
+float f1 = 1.0, f2 = 2.0;
+
+// La aritmética es sencilla
+i1 + i2; // => 3
+i2 - i1; // => 1
+i2 * i1; // => 2
+i1 / i2; // => 0 (0.5, pero es truncado tras el 0)
+
+f1 / f2; // => 0.5, más o menos épsilon
+// Módulo está también
+11 % 3; // => 2
+
+// Los operadores de comparación te resultaran familiares, pero no hay
+// booleanos en C. Usamos enteros (ints) en su lugar. 0 es falso,
+// cualquier otra cosa es verdadero. (Los operadores de comparación 
+// siempre devuelven 0 o 1)
+3 == 2; // => 0 (Falso)
+3 != 2; // => 1 (Verdadero)
+3 > 2; // => 1
+3 < 2; // => 0
+2 <= 2; // => 1
+2 >= 2; // => 1
+
+// La lógica funiona en enteros
+!3; // => 0 (not lógico)
+!0; // => 1
+1 && 1; // => 1 (and lógico)
+0 && 1; // => 0
+0 || 1; // => 1 (or lógico)
+0 || 0; // => 0
+
+// ¡Operadores de bits!
+~0x0F; // => 0xF0 (Negación)
+0x0F & 0xF0; // => 0x00 (AND)
+0x0F | 0xF0; // => 0xFF (OR)
+0x04 ^ 0x0F; // => 0x0B (XOR)
+0x01 << 1; // => 0x02 (desplazar hacia la izquierda (por 1))
+0x02 >> 1; // => 0x01 (desplazar hacia la derecha (por 1))
+
+///////////////////////////////////////
+// Estructuras de Control
+///////////////////////////////////////
+
+if (0) {
+  printf("Yo nunca ocurro\n");
+} else if (0) {
+  printf("Yo tampoco ocurro nunca\n");
+} else {
+  printf("Yo me muestro\n");
+}
+
+// Mientras el bucle exista
+int ii = 0;
+while (ii < 10) {
+    printf("%d, ", ii++); // ii++ incrementa ii en uno, después de usar su valor.
+} // => muestra "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+printf("\n");
+
+int kk = 0;
+do {
+    printf("%d, ", kk);
+} while (++kk < 10); // ++kk incrementa kk en uno, antes de usar su valor.
+// => muestra "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+printf("\n");
+
+// Bucles 'for' también
+int jj;
+for (jj=0; jj < 10; jj++) {
+    printf("%d, ", jj);
+} // => muestra "0, 1, 2, 3, 4, 5, 6, 7, 8, 9, "
+
+printf("\n");
+
+///////////////////////////////////////
+// Cambios de Tipo
+///////////////////////////////////////
+
+// Cada valor en C tiene un tipo,  pero tu puedes ingresar un valor en
+// otro tipo si quieres.
+
+int x_hex = 0x01; // Puedes asignar hexadecimales a variables
+
+// El cambio de tipos intentará mantener sus valores numéricos
+printf("%d\n", x_hex); // => Muestra 1
+printf("%d\n", (short) x_hex); // => Muestra 1
+printf("%d\n", (char) x_hex); // => Muestra 1
+
+// Los tipos se desbordan sin aviso
+printf("%d\n", (char) 257); // => 1 (El valor máximo de un 'char' es 255)
+
+// Los tipos enteros puden cambiarse a tipos de coma flotante, y viceversa
+printf("%f\n", (float)100); // %f se sustituye por un 'float'
+printf("%lf\n", (double)100); // %lf se sustituye por un 'double'
+printf("%d\n", (char)100.0);
+
+///////////////////////////////////////
+// Punteros
+///////////////////////////////////////
+
+// Un puntero es una variable declarada para almacenar una dirección de 
+// memoria. Su declaración además nos dirá el tipo de dato al que apunta. 
+// Puedes obtener la dirección de memoria de tus variables, y después
+// enlazarlas con ellos.
+
+int x = 0;
+printf("%p\n", &x); // Usa & para obtener la dirección de una variable.
+// (%p se sustituye por un puntero)
+// => Muestra alguna dirección de memoria;
+
+// Los tipos de puntero terminan con * en su declaración
+int* px; // px es un puntero a un 'int'
+px = &x; // Almacena la dirección de x en px
+printf("%p\n", px); // => Muestra alguna dirección de memoria
+
+// Para obtener el valor de la dirección a la que apunta un puntero, pon
+// * delante para desreferenciarle. 
+printf("%d\n", *px); // => Muestra 0, el valor de x y de la dirección a la
+                     //    que apunta px
+
+// También puedes cambiar el valor al que está apuntando el puntero.
+// Tenemos que meter la desreferencia entre paréntesis porque ++ tiene
+// prioridad frente a *.
+(*px)++; // Incrementa el valor al que apunta px en 1
+printf("%d\n", *px); // => Muestra 1
+printf("%d\n", x); // => Muestra 1
+
+int x_array[20]; // Los arrays son una buena manera de distribuir bloques
+int xx;          // continuos de memoria.
+for (xx=0; xx<20; xx++) {
+    x_array[xx] = 20 - xx;
+} // Inicializa x_array a 20, 19, 18,... 2, 1
+
+// Declara un puntero de tipo 'int' y lo inicializa para apuntar a x_array
+int* x_ptr = x_array;
+// x_ptr ahira apunta al primer elemento del 'array' (el entero 20).
+// Esto funciona porque las 'arrays' actualmente son solo punteros a su
+// primer elemento.
+
+// Los 'arrays' son punteros a su primer elemento.
+printf("%d\n", *(x_ptr)); // => Muestra 20
+printf("%d\n", x_array[0]); // => Muestra 20
+
+// Los punteros aumentan y disminuyen en función de su tipo.
+printf("%d\n", *(x_ptr + 1)); // => Muestra 19
+printf("%d\n", x_array[1]); // => Muestra 19
+
+// Puedes también asigner dinamicamente bloques contiguos de memoria con
+// la función malloc de la librería estándard, que toma un entero como
+// argumento representando el número de bytes a asignar de la pila.
+int* my_ptr = (int*) malloc(sizeof(int) * 20);
+for (xx=0; xx<20; xx++) {
+    *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx funcionaría también aquí
+} // Inicializa la memoria a 20, 19, 18, 17... 2, 1 (como 'ints')
+
+// Desreferenciando la memoria que no has asignado te dará resultados
+// impredecibles
+printf("%d\n", *(my_ptr + 21)); // => Prints who-knows-what?
+
+// Cuando hayas acabado con el bloque de memoría malloc, necesitas 
+// liberarlo o sino nadie más podrá usarlo hasta que tu programa se cierre
+free(my_ptr);
+
+// Las cadenas pueden ser 'arrays' de chars, pero normalmente se
+// representan con punteros 'char':
+char* my_str = "This is my very own string";
+
+printf("%c\n", *my_str); // => 'T'
+
+function_1();
+} // fin de la función main
+
+///////////////////////////////////////
+// Funciones
+///////////////////////////////////////
+
+// Sintexis de la declaración de funciones:
+// <tipo de retorno> <nombre>(<argumentos>)
+
+int add_two_ints(int x1, int x2){
+    return x1 + x2; // Usa 'return' para dar una salida
+}
+
+/*
+Las funciones son de paso por valor, pero puedes hacer tus propias 
+referencias con punteros de manera que las funciones puedan cambiar sus 
+valores.
+
+Ejemplo: invertidor de cadenas in-situ
+*/
+
+// Una función 'void' no retorna valor
+void str_reverse(char* str_in){
+    char tmp;
+    int ii=0, len = strlen(str_in); // Strlen es parte de la librería 
+    for(ii=0; ii<len/2; ii++){      // estándard
+        tmp = str_in[ii];
+        str_in[ii] = str_in[len - ii - 1]; // ii-th último 'char'
+        str_in[len - ii - 1] = tmp;
+    }
+}
+
+/*
+char c[] = "Esto es una prueba.";
+str_reverse(c);
+printf("%s\n", c); // => ".abeurp anu se otsE"
+*/
+
+///////////////////////////////////////
+// Definición de tipos y estructuras
+///////////////////////////////////////
+
+// Los 'Typedefs' pueden ser utilizados para crear alias de tipos.
+typedef int my_type;
+my_type my_type_var = 0;
+
+// Las estructuras son sólo grupos de datos.
+struct rectangle {
+    int width;
+    int height;
+};
+
+
+void function_1(){
+
+    struct rectangle my_rec;
+
+    // Utiliza los miembros de una estructura con .
+    my_rec.width = 10;
+    my_rec.height = 20;
+
+    // Puedes declarar punteros a estructuras
+    struct rectangle* my_rec_ptr = &my_rec;
+
+    // Usa la desreferencia para modificar sus miembros...
+    (*my_rec_ptr).width = 30;
+
+    // ... o usa la abreviatura ->
+    my_rec_ptr->height = 10; // Lo mismo que (*my_rec_ptr).height = 10;
+}
+
+// Puedes aplicar un 'typedef' a una estructura por conveniencía.
+typedef struct rectangle rect;
+
+int area(rect r){
+    return r.width * r.height;
+}
+
+///////////////////////////////////////
+// Punteros a Funciones
+///////////////////////////////////////
+/*
+En tiempo de ejecución,  las funciones se localizan en unas direcciones de
+memoria concretas. Los punteros a funciones son como cualquier otro 
+puntero (almacenan una dirección de memoria), pero pueden ser usados para 
+utilizar funciones directamente, o para pasar 'handlers' (o funciones 
+'callback') por todos lados.
+Sin embargo, la sintaxis de definición parecera confusa al principio.
+
+Ejemplo: usar str_reverse desde un puntero
+*/
+void str_reverse_through_pointer(char * str_in) {
+    // Define un puntero a una función, llamado f.
+    void (*f)(char *);
+    // La armadura debe coincidir exactamente con al función objetivo.
+
+    // Assigna la dirección de la función (determinado en tiempo de ejecuión)
+    f = &str_reverse;
+
+    // Llamando la función desde el puntero
+    (*f)(str_in);
+
+    // Esta es una alternativa para llamarla pero con una sintaxis igual de válida.
+    // f(str_in);
+}
+
+/*
+Tanto tiempo como las armaduras de las funciones coincidan, podrás asignar
+cualquier función al mismo puntero.
+Los punteros a funciones  son normalmente envueltos en 'typedef' para
+simplificar su legibilidad, como sigue:
+*/
+
+typedef void (*my_fnp_type)(char *);
+
+// Es usado para declarar la variable puntero actual:
+// ...
+// my_fnp_type f; 
+
+```
+
+## Otras lecturas
+
+Lo mejor que puedes en contrar es una copia de [K&R, aka "The C Programming Language"](https://en.wikipedia.org/wiki/The_C_Programming_Language)
+
+Otro buen recurso es [Learn C the hard way](http://c.learncodethehardway.org/book/)
+
+Aparte de eso, Google es tu amigo.
diff --git a/es-es/clojure-es.html.markdown b/es-es/clojure-es.html.markdown
new file mode 100644
index 00000000..150d0bb2
--- /dev/null
+++ b/es-es/clojure-es.html.markdown
@@ -0,0 +1,393 @@
+---
+language: clojure
+filename: learnclojure-es.clj
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+translators:
+    - ["Antonio Hernández Blas", "https://twitter.com/nihilipster"]
+    - ["Guillermo Vayá Pérez", "http://willyfrog.es"]
+lang: es-es
+---
+
+Clojure es un lenguaje de la familia Lisp desarrollado sobre la Máquina Virtual
+de Java. Tiene un énfasis mayor en la [programación funcional](https://es.wikipedia.org/wiki/Programación_funcional) pura
+que Common Lisp, pero incluyendo la posibilidad de usar [SMT](https://es.wikipedia.org/wiki/Memoria_transacional) para manipular
+el estado según se presente.
+
+Esta combinación le permite gestionar la concurrencia de manera muy sencilla
+y a menudo automáticamente.
+
+(Necesitas la versión de Clojure 1.2 o posterior)
+
+
+```clojure
+; Los comentatios comienzan con punto y coma.
+
+; Clojure se escribe mediante "forms" (patrones), los cuales son
+; listas de objectos entre paréntesis, separados por espacios en blanco.
+
+; El "reader" (lector) de Clojure asume que el primer objeto es una
+; función o una macro que se va a llamar, y que el resto son argumentos.
+
+; El primer form en un archivo debe ser ns, para establecer el namespace (espacio de
+; nombres)
+(ns learnclojure)
+
+; Algunos ejemplos básicos:
+
+; str crea una cadena de caracteres a partir de sus argumentos
+(str "Hello" " " "World") ; => "Hello World"
+
+; Las operaciones matemáticas son sencillas
+(+ 1 1) ; => 2
+(- 2 1) ; => 1
+(* 1 2) ; => 2
+(/ 2 1) ; => 2
+
+; La igualdad es =
+(= 1 1) ; => true
+(= 2 1) ; => false
+
+; También es necesaria la negación para las operaciones lógicas
+(not true) ; => false
+
+; Cuando se anidan Los patrones, estos funcionan de la manera esperada
+(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
+
+; Tipos
+;;;;;;;;;;;;;
+
+; Clojure usa los tipos de objetos de Java para booleanos, strings (cadenas de
+; caracteres) y números.
+; Usa class para saber de qué tipo es.
+(class 1); Los enteros son java.lang.Long por defecto
+(class 1.); Los numeros en coma flotante son java.lang.Double
+(class ""); Los strings van entre comillas dobles, y son
+; son java.lang.String
+(class false); Los Booleanos son java.lang.Boolean
+(class nil); El valor "null" se escribe nil
+
+; Si quieres crear una lista de datos, precedela con una comilla
+; simple para evitar su evaluación
+'(+ 1 2) ; => (+ 1 2)
+; (que es una abreviatura de (quote (+ 1 2)) )
+
+; Puedes evaluar una lista precedida por comilla  con eval
+(eval '(+ 1 2)) ; => 3
+
+; Colecciones & Secuencias
+;;;;;;;;;;;;;;;;;;;
+
+; Las Listas están basadas en las listas enlazadas, mientras que los Vectores en
+; arrays.
+; ¡Los Vectores y las Listas también son clases de Java!
+(class [1 2 3]); => clojure.lang.PersistentVector
+(class '(1 2 3)); => clojure.lang.PersistentList
+
+; Una lista podría ser escrita como (1 2 3), pero debemos ponerle una
+; comilla simple delante para evitar que el reader piense que es una función.
+; Además, (list 1 2 3) es lo mismo que '(1 2 3)
+
+; Las "Colecciones" son solo grupos de datos
+; Tanto las listas como los vectores son colecciones:
+(coll? '(1 2 3)) ; => true
+(coll? [1 2 3]) ; => true
+
+; Las "Secuencias" (seqs) son descripciones abstractas de listas de datos.
+; Solo las listas son seqs.
+(seq? '(1 2 3)) ; => true
+(seq? [1 2 3]) ; => false
+
+; Una seq solo necesita proporcionar una entrada cuando es accedida.
+; Así que, las seqs pueden ser perezosas -- pueden establecer series infinitas:
+(range 4) ; => (0 1 2 3)
+(range) ; => (0 1 2 3 4 ...) (una serie infinita)
+(take 4 (range)) ;  (0 1 2 3)
+
+; Usa cons para agregar un elemento al inicio de una lista o vector
+(cons 4 [1 2 3]) ; => (4 1 2 3)
+(cons 4 '(1 2 3)) ; => (4 1 2 3)
+
+; conj agregará un elemento a una colección en la forma más eficiente.
+; Para listas, se añade al inicio. Para vectores, al final.
+(conj [1 2 3] 4) ; => [1 2 3 4]
+(conj '(1 2 3) 4) ; => (4 1 2 3)
+
+; Usa concat para concatenar listas o vectores
+(concat [1 2] '(3 4)) ; => (1 2 3 4)
+
+; Usa filter y map para actuar sobre colecciones
+(map inc [1 2 3]) ; => (2 3 4)
+(filter even? [1 2 3]) ; => (2)
+
+; Usa reduce para combinar sus elementos
+(reduce + [1 2 3 4])
+; = (+ (+ (+ 1 2) 3) 4)
+; => 10
+
+; reduce puede tener un argumento indicando su valor inicial.
+(reduce conj [] '(3 2 1))
+; = (conj (conj (conj [] 3) 2) 1)
+; => [3 2 1]
+
+; Funciones
+;;;;;;;;;;;;;;;;;;;;;
+
+; Usa fn para crear nuevas funciones. Una función siempre devuelve
+; su última expresión
+(fn [] "Hello World") ; => fn
+
+; (Necesitas rodearlo con paréntesis para invocarla)
+((fn [] "Hello World")) ; => "Hello World"
+
+; Puedes crear una var (variable) mediante def
+(def x 1)
+x ; => 1
+
+; Asigna una función a una var
+(def hello-world (fn [] "Hello World"))
+(hello-world) ; => "Hello World"
+
+; Puedes defn como atajo para lo anterior
+(defn hello-world [] "Hello World")
+
+; El [] es el vector de argumentos de la función.
+(defn hello [name]
+  (str "Hello " name))
+(hello "Steve") ; => "Hello Steve"
+
+; Otra abreviatura para crear funciones es:
+(def hello2 #(str "Hello " %1))
+(hello2 "Fanny") ; => "Hello Fanny"
+
+; Puedes tener funciones multi-variadic: funciones con un numero variable de
+; argumentos
+(defn hello3
+  ([] "Hello World")
+  ([name] (str "Hello " name)))
+(hello3 "Jake") ; => "Hello Jake"
+(hello3) ; => "Hello World"
+
+; Las funciones pueden usar argumentos extras dentro de un seq utilizable en la función
+(defn count-args [& args]
+  (str "You passed " (count args) " args: " args))
+(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
+
+; Y puedes mezclarlos con el resto de argumentos declarados de la función.
+(defn hello-count [name & args]
+  (str "Hello " name ", you passed " (count args) " extra args"))
+(hello-count "Finn" 1 2 3)
+; => "Hello Finn, you passed 3 extra args"
+
+
+; Mapas
+;;;;;;;;;;
+
+; Mapas de Hash y mapas de arrays comparten una misma interfaz. Los mapas de Hash
+; tienen búsquedas más rápidas pero no mantienen el orden de las claves.
+(class {:a 1 :b 2 :c 3}) ; => clojure.lang.PersistentArrayMap
+(class (hash-map :a 1 :b 2 :c 3)) ; => clojure.lang.PersistentHashMap
+
+; Los mapas de arrays se convertidos en mapas de Hash en la mayoría de
+; operaciones si crecen mucho, por lo que no debes preocuparte.
+
+; Los mapas pueden usar cualquier tipo para sus claves, pero generalmente las
+; keywords (palabras clave) son lo habitual.
+; Las keywords son parecidas a cadenas de caracteres con algunas ventajas de eficiencia
+(class :a) ; => clojure.lang.Keyword
+
+(def stringmap {"a" 1, "b" 2, "c" 3})
+stringmap  ; => {"a" 1, "b" 2, "c" 3}
+
+(def keymap {:a 1, :b 2, :c 3})
+keymap ; => {:a 1, :c 3, :b 2}
+
+; Por cierto, las comas son equivalentes a espacios en blanco y no hacen
+; nada.
+
+; Recupera un valor de un mapa tratandolo como una función
+(stringmap "a") ; => 1
+(keymap :a) ; => 1
+
+; ¡Las keywords pueden ser usadas para recuperar su valor del mapa, también!
+(:b keymap) ; => 2
+
+; No lo intentes con strings.
+;("a" stringmap)
+; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
+
+; Si preguntamos por una clave que no existe nos devuelve nil
+(stringmap "d") ; => nil
+
+; Usa assoc para añadir nuevas claves a los mapas de Hash
+(def newkeymap (assoc keymap :d 4))
+newkeymap ; => {:a 1, :b 2, :c 3, :d 4}
+
+; Pero recuerda, ¡los tipos de Clojure son inmutables!
+keymap ; => {:a 1, :b 2, :c 3}
+
+; Usa dissoc para eliminar llaves
+(dissoc keymap :a :b) ; => {:c 3}
+
+; Conjuntos
+;;;;;;
+
+(class #{1 2 3}) ; => clojure.lang.PersistentHashSet
+(set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
+
+; Añade un elemento con conj
+(conj #{1 2 3} 4) ; => #{1 2 3 4}
+
+; Elimina elementos con disj
+(disj #{1 2 3} 1) ; => #{2 3}
+
+; Comprueba su existencia usando el conjunto como una función:
+(#{1 2 3} 1) ; => 1
+(#{1 2 3} 4) ; => nil
+
+; Hay más funciones en el namespace clojure.sets
+
+; Patrones útiles
+;;;;;;;;;;;;;;;;;
+
+; Las construcciones lógicas en clojure son macros, y presentan el mismo aspecto
+; que el resto de forms.
+(if false "a" "b") ; => "b"
+(if false "a") ; => nil
+
+; Usa let para crear un binding (asociación) temporal
+(let [a 1 b 2]
+  (> a b)) ; => false
+
+; Agrupa expresiones mediante do
+(do
+  (print "Hello")
+  "World") ; => "World" (prints "Hello")
+
+; Las funciones tienen implicita la llamada a do
+(defn print-and-say-hello [name]
+  (print "Saying hello to " name)
+  (str "Hello " name))
+(print-and-say-hello "Jeff") ;=> "Hello Jeff" (prints "Saying hello to Jeff")
+
+; Y el let también
+(let [name "Urkel"]
+  (print "Saying hello to " name)
+  (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
+
+; Módulos
+;;;;;;;;;;;;;;;
+
+; Usa use para obtener todas las funciones del módulo
+(use 'clojure.set)
+
+; Ahora podemos usar más operaciones de conjuntos
+(intersection #{1 2 3} #{2 3 4}) ; => #{2 3}
+(difference #{1 2 3} #{2 3 4}) ; => #{1}
+
+; Puedes escoger un subgrupo de funciones a importar, también
+(use '[clojure.set :only [intersection]])
+
+; Usa require para importar un módulo
+(require 'clojure.string)
+
+; Usa / para llamar a las funciones de un módulo
+; Aquí, el módulo es clojure.string y la función es blank?
+(clojure.string/blank? "") ; => true
+
+; Puedes asignarle una abreviatura a un modulo al importarlo
+(require '[clojure.string :as str])
+(str/replace "This is a test." #"[a-o]" str/upper-case) ; => "THIs Is A tEst."
+; (#"" es una expresión regular)
+
+; Puedes usar require (y use, pero no lo hagas) desde un espacio de nombre
+; usando :require,
+; No necesitas preceder con comilla simple tus módulos si lo haces de esta
+; forma.
+(ns test
+  (:require
+    [clojure.string :as str]
+    [clojure.set :as set]))
+
+; Java
+;;;;;;;;;;;;;;;;;
+
+; Java tiene una enorme librería estándar, por lo que resulta util
+; aprender como interactuar con ella.
+
+; Usa import para cargar un módulo de java
+(import java.util.Date)
+
+; Puedes importar desde un ns también.
+(ns test
+  (:import java.util.Date
+           java.util.Calendar))
+
+; Usa el nombre de la clase con un "." al final para crear una nueva instancia
+(Date.) ; <un objeto Date>
+
+; Usa "." para llamar a métodos o usa el atajo ".método"
+(. (Date.) getTime) ; <un timestamp>
+(.getTime (Date.)) ; exactamente la misma cosa
+
+; Usa / para llamar métodos estáticos.
+(System/currentTimeMillis) ; <un timestamp> (System siempre está presente)
+
+; Usa doto para hacer frente al uso de clases (mutables) más tolerable
+(import java.util.Calendar)
+(doto (Calendar/getInstance)
+  (.set 2000 1 1 0 0 0)
+  .getTime) ; => A Date. set to 2000-01-01 00:00:00
+
+; STM
+;;;;;;;;;;;;;;;;;
+
+; Software Transactional Memory es un mecanismo que usa clojure para gestionar
+; el estado persistente. Hay unas cuantas construcciones en clojure que
+; hacen uso de este mecanismo.
+
+; Un atom es el más sencillo. Se le da un valor inicial
+(def my-atom (atom {}))
+
+; Actualiza un atom con swap!
+; swap! toma una función y la llama con el valor actual del atom
+; como su primer argumento, y cualquier argumento restante como el segundo
+(swap! my-atom assoc :a 1) ; Establece my-atom al resultado de (assoc {} :a 1)
+(swap! my-atom assoc :b 2) ; Establece my-atom al resultado de (assoc {:a 1} :b 2)
+
+; Usa '@' para no referenciar al atom sino para obtener su valor
+my-atom  ;=> Atom<#...> (Regresa el objeto Atom)
+@my-atom ; => {:a 1 :b 2}
+
+; Un sencillo contador usando un atom sería
+(def counter (atom 0))
+(defn inc-counter []
+  (swap! counter inc))
+
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+
+@counter ; => 5
+
+; Otros forms que utilizan STM son refs y agents.
+; Refs: http://clojure.org/refs
+; Agents: http://clojure.org/agents
+### Lectura adicional
+
+Ésto queda lejos de ser exhaustivo, pero espero que sea suficiente para que puedas empezar tu camino.
+
+Clojure.org tiene muchos artículos:
+[http://clojure.org/](http://clojure.org/)
+
+Clojuredocs.org contiene documentación con ejemplos para la mayoría de
+funciones principales (pertenecientes al core):
+[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
+
+4Clojure es una genial forma de mejorar tus habilidades con clojure/FP:
+[http://www.4clojure.com/](http://www.4clojure.com/)
+
+Clojure-doc.org (sí, de verdad) tiene un buen número de artículos con los que iniciarse en Clojure:
+[http://clojure-doc.org/](http://clojure-doc.org/)
diff --git a/es-es/coffeescript-es.html.markdown b/es-es/coffeescript-es.html.markdown
new file mode 100644
index 00000000..6bf430e6
--- /dev/null
+++ b/es-es/coffeescript-es.html.markdown
@@ -0,0 +1,57 @@
+---
+language: coffeescript
+lang: es-es
+contributors:
+  - ["Tenor Biel", "http://github.com/L8D"]
+translators:
+  - ["Pablo Elices", "http://github.com/pabloelices"]
+filename: coffeescript-es.coffee
+---
+
+``` coffeescript
+# CoffeeScript es un lenguaje hipster.
+# Tiene convenciones de muchos lenguajes modernos.
+# Los comentarios son como en Ruby y Python, usan almohadillas.
+
+###
+Los comentarios en bloque son como estos, y se traducen directamente a '/*' y '*/'
+para el código JavaScript resultante.
+
+Deberías entender la mayor parte de la semántica de JavaScript antes de continuar.
+###
+
+# Asignación:
+number   = 42 #=> var number = 42;
+opposite = true #=> var opposite = true;
+
+# Condiciones:
+number = -42 if opposite #=> if(opposite) { number = -42; }
+
+# Funciones:
+square = (x) -> x * x #=> var square = function(x) { return x * x; }
+
+# Rangos:
+list = [1..5] #=> var list = [1, 2, 3, 4, 5];
+
+# Objetos:
+math =
+  root:   Math.sqrt
+  square: square
+  cube:   (x) -> x * square x
+#=> var math = {
+#  "root": Math.sqrt,
+#  "square": square,
+#  "cube": function(x) { return x * square(x); }
+#}
+
+# Número de argumentos variable:
+race = (winner, runners...) ->
+  print winner, runners
+
+# Existencia:
+alert "I knew it!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
+
+# Listas:
+cubes = (math.cube num for num in list) #=> ...
+```
diff --git a/es-es/csharp-es.html.markdown b/es-es/csharp-es.html.markdown
new file mode 100644
index 00000000..ef26d8ce
--- /dev/null
+++ b/es-es/csharp-es.html.markdown
@@ -0,0 +1,632 @@
+---
+language: c#
+contributors:
+    - ["Irfan Charania", "https://github.com/irfancharania"]
+    - ["Max Yankov", "https://github.com/golergka"]
+translators:
+    - ["Olfran Jiménez", "https://twitter.com/neslux"]	
+filename: LearnCSharp-es.cs
+lang: es-es
+---
+
+C# es un lenguaje orientado a objetos elegante y de tipado seguro que
+permite a los desarrolladores construir una variedad de aplicaciones
+seguras y robustas que se ejecutan en el Framework .NET.
+
+[Lee más aquí.](http://msdn.microsoft.com/es-es/library/vstudio/z1zx9t92.aspx)
+
+```c#
+// Los comentarios de una sola línea comienzan con //
+/*
+Los comentarios de múltiples líneas son de esta manera
+*/
+/// <summary>
+/// Este es un comentario de documentación XML
+/// </summary>
+
+// Especifica el espacio de nombres que estará usando la aplicación
+using System;
+using System.Collections.Generic;
+
+
+// Define un ambito para organizar el código en "paquetes"
+namespace Learning
+{
+	// Cada archivo .cs debe contener al menos una clase con el mismo nombre que el archivo
+    // Se permite colocar cualquier nombre, pero no deberías por cuestiones de consistencia.
+    public class LearnCSharp
+    {
+		// Una aplicación de consola debe tener un método main como punto de entrada
+        public static void Main(string[] args)
+        {
+			// Usa Console.WriteLine para imprimir líneas
+            Console.WriteLine("Hello World");
+            Console.WriteLine(
+                "Integer: " + 10 +
+                " Double: " + 3.14 +
+                " Boolean: " + true);
+
+			// Para imprimir sin una nueva línea, usa Console.Write
+            Console.Write("Hello ");
+            Console.Write("World");
+
+
+            ///////////////////////////////////////////////////
+            // Variables y Tipos
+            //
+            // Declara una variable usando <tipo> <nombre>
+            ///////////////////////////////////////////////////
+
+            // Sbyte - Entero de 8 bits con signo
+            // (-128 <= sbyte <= 127)
+            sbyte fooSbyte = 100;
+
+            // Byte - Entero de 8 bits sin signo
+            // (0 <= byte <= 255)
+            byte fooByte = 100;
+
+            // Short - Entero de 16 bits con signo
+            // (-32,768 <= short <= 32,767)
+            short fooShort = 10000;
+
+            // Ushort - Entero de 16 bits sin signo
+            // (0 <= ushort <= 65,535)
+            ushort fooUshort = 10000;
+
+            // Integer - Entero de 32 bits con signo
+            // (-2,147,483,648 <= int <= 2,147,483,647)
+            int fooInt = 1;
+
+            // Uinteger - Entero de 32 bits sin signo
+            // (0 <= uint <= 4,294,967,295)
+            uint fooUint = 1;
+
+            // Long - Entero de 64 bits con signo
+            // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+            long fooLong = 100000L;
+            // L es usado para indicar que esta variable es de tipo long o ulong
+            // un valor sin este sufijo es tratado como int o uint dependiendo del tamaño.
+
+            // Ulong - Entero de 64 bits sin signo
+            // (0 <= ulong <= 18,446,744,073,709,551,615)
+            ulong fooUlong = 100000L;
+
+            // Float - Precisión simple de 32 bits. IEEE 754 Coma flotante
+            // Precisión: 7 dígitos
+            float fooFloat = 234.5f;
+			// f es usado para indicar que el valor de esta variable es de tipo float
+            // de otra manera sería tratado como si fuera de tipo double.
+
+            // Double - Doble precisión de 32 bits. IEEE 754 Coma flotante
+            // Precisión: 15-16 dígitos
+            double fooDouble = 123.4;
+
+            // Bool - true & false (verdadero y falso)
+            bool fooBoolean = true;
+            bool barBoolean = false;
+
+			// Char - Un solo caracter Unicode de 16 bits
+            char fooChar = 'A';
+
+            // Strings
+            string fooString = "My string is here!";
+            Console.WriteLine(fooString);
+
+            // Formato de cadenas
+            string fooFs = string.Format("Check Check, {0} {1}, {0} {1:0.0}", 1, 2);
+            Console.WriteLine(fooFormattedString);
+
+            // Formato de fechas
+            DateTime fooDate = DateTime.Now;
+            Console.WriteLine(fooDate.ToString("hh:mm, dd MMM yyyy"));
+
+			// \n es un caracter de escape que comienza una nueva línea
+            string barString = "Printing on a new line?\nNo Problem!";
+            Console.WriteLine(barString);
+
+            // Puede ser escrito mejor usando el símbolo @
+            string bazString = @"Here's some stuff
+    on a new line!";
+            Console.WriteLine(bazString);
+
+            // Las comillas deben ser escapadas
+            // usa \" para escaparlas
+            string quotedString = "some \"quoted\" stuff";
+            Console.WriteLine(quotedString);
+
+			// usa "" cuando las cadenas comiencen con @
+            string quotedString2 = @"some MORE ""quoted"" stuff";
+            Console.WriteLine(quotedString2);
+
+			// Usa const o readonly para hacer las variables inmutables
+			// los valores const son calculados en tiempo de compilación
+            const int HOURS_I_WORK_PER_WEEK = 9001;
+
+            // Tipos que aceptan valores NULL (Nullable)
+			// cualquier tipo de dato puede ser un tipo nulo añadiendole el sufijo ?
+            // <tipo>? <variable> = <valor>
+            int? nullable = null;
+            Console.WriteLine("Nullable variable: " + nullable);
+
+			// Para usar valores nulos, tienes que usar la propiedad Value
+			// o usar conversión explícita
+            string? nullableString = "not null";
+            Console.WriteLine("Nullable value is: " + nullableString.Value + " or: " + (string) nullableString );
+
+			// ?? is una manera corta de especificar valores por defecto
+            // en caso de que la variable sea null
+            int notNullable = nullable ?? 0;
+            Console.WriteLine("Not nullable variable: " + notNullable);
+
+			// var - el compilador escogerá el tipo de dato más apropiado basado en el valor
+            var fooImplicit = true;
+
+            ///////////////////////////////////////////////////
+            // Estructura de datos
+            ///////////////////////////////////////////////////
+            Console.WriteLine("\n->Data Structures");
+
+            // Arreglos
+			// El tamaño del arreglo debe decidirse al momento de la declaración
+            // El formato para declarar un arreglo es el siguiente:
+            // <tipo_de_dato>[] <nombre_variable> = new <tipo_de_dato>[<tamaño>];
+            int[] intArray = new int[10];
+            string[] stringArray = new string[1];
+            bool[] boolArray = new bool[100];
+
+			// Otra forma de declarar e inicializar un arreglo
+            int[] y = { 9000, 1000, 1337 };
+
+			// Indexar arreglos - Acceder a un elemento
+            Console.WriteLine("intArray @ 0: " + intArray[0]);
+
+			// Los arreglos son de índice cero y son mutables.
+            intArray[1] = 1;
+            Console.WriteLine("intArray @ 1: " + intArray[1]); // => 1
+
+            // Listas
+			// Las listas son usadas más frecuentemente que los arreglos ya que son más flexibles
+			// El formato para declarar una lista es el siguiente:
+            // List<tipo_de_dato> <nombre_variable> = new List<tipo_de_dato>();
+            List<int> intList = new List<int>();
+            List<string> stringList = new List<string>();
+
+            // Otra forma de declarar e inicializar una lista
+            List<int> z = new List<int> { 9000, 1000, 1337 };
+
+            // Indexar una lista - Acceder a un elemento
+            // Las listas son de índice cero y son mutables.
+            Console.WriteLine("z @ 0: " + z[2]);
+
+            // Las listas no tienen valores por defecto;
+            // Un valor debe ser añadido antes de acceder al índice
+            intList.Add(1);
+            Console.WriteLine("intList @ 0: " + intList[0]);
+
+
+            // Otras estructuras de datos a chequear:
+            //
+            // Pilas/Colas
+            // Diccionarios
+            // Colecciones de sólo lectura
+            // Tuplas (.Net 4+)
+
+
+            ///////////////////////////////////////
+            // Operadores
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Operators");
+
+            int i1 = 1, i2 = 2; // Modo corto para múltiples declaraciones
+
+            // La aritmética es sencilla
+            Console.WriteLine("1+2 = " + (i1 + i2)); // => 3
+            Console.WriteLine("2-1 = " + (i2 - i1)); // => 1
+            Console.WriteLine("2*1 = " + (i2 * i1)); // => 2
+            Console.WriteLine("1/2 = " + (i1 / i2)); // => 0 (0.5 truncated down)
+
+            // Módulo
+            Console.WriteLine("11%3 = " + (11 % 3)); // => 2
+
+            // Operadores de comparación
+            Console.WriteLine("3 == 2? " + (3 == 2)); // => false
+            Console.WriteLine("3 != 2? " + (3 != 2)); // => true
+            Console.WriteLine("3 > 2? " + (3 > 2)); // => true
+            Console.WriteLine("3 < 2? " + (3 < 2)); // => false
+            Console.WriteLine("2 <= 2? " + (2 <= 2)); // => true
+            Console.WriteLine("2 >= 2? " + (2 >= 2)); // => true
+
+            // Operadores a nivel de bits
+            /*
+            ~       Complemento a nivel de bits
+            <<      Desplazamiento a la izquierda con signo
+            >>      Desplazamiento a la derecha con signo
+            >>>     Desplazamiento a la derecha sin signo
+            &       AND a nivel de bits
+            ^       XOR a nivel de bits
+            |       OR a nivel de bits
+            */
+
+            // Incremento
+            int i = 0;
+            Console.WriteLine("\n->Inc/Dec-remento");
+            Console.WriteLine(i++); //i = 1. Posincrementación
+            Console.WriteLine(++i); //i = 2. Preincremento
+            Console.WriteLine(i--); //i = 1. Posdecremento
+            Console.WriteLine(--i); //i = 0. Predecremento
+
+
+            ///////////////////////////////////////
+            // Estructuras de control
+            ///////////////////////////////////////
+            Console.WriteLine("\n->Control Structures");
+
+            // Las condiciones if son como en lenguaje c
+            int j = 10;
+            if (j == 10)
+            {
+                Console.WriteLine("I get printed");
+            }
+            else if (j > 10)
+            {
+                Console.WriteLine("I don't");
+            }
+            else
+            {
+                Console.WriteLine("I also don't");
+            }
+
+            // Operador ternario
+			// Un simple if/else puede ser escrito de la siguiente manera;
+            // <condición> ? <true> : <false>
+            string isTrue = (true) ? "True" : "False";
+            Console.WriteLine("Ternary demo: " + isTrue);
+
+
+            // Bucle while
+            int fooWhile = 0;
+            while (fooWhile < 100)
+            {
+                //Console.WriteLine(fooWhile);
+                //Incrementar el contador
+                //Iterar 99 veces, fooWhile 0->99
+                fooWhile++;
+            }
+            Console.WriteLine("fooWhile Value: " + fooWhile);
+
+            // Bucle Do While
+            int fooDoWhile = 0;
+            do
+            {
+                //Console.WriteLine(fooDoWhile);
+                //Incrementar el contador
+                //Iterar 99 veces, fooDoWhile 0->99
+                fooDoWhile++;
+            } while (fooDoWhile < 100);
+            Console.WriteLine("fooDoWhile Value: " + fooDoWhile);
+
+            // Bucle For
+            int fooFor;
+            //Estructura del bucle for => for(<declaración_inicial>; <condición>; <incremento>)
+            for (fooFor = 0; fooFor < 10; fooFor++)
+            {
+                //Console.WriteLine(fooFor);
+                //Iterated 10 times, fooFor 0->9
+            }
+            Console.WriteLine("fooFor Value: " + fooFor);
+
+            // Switch Case
+			// El switch funciona con los tipos de datos byte, short, char e int
+            // También funciona con las enumeraciones (discutidos en in Tipos Enum),
+            // la clase string y algunas clases especiales que encapsulan
+            // tipos primitivos: Character, Byte, Short, Integer.
+            int month = 3;
+            string monthString;
+            switch (month)
+            {
+                case 1:
+                    monthString = "January";
+                    break;
+                case 2:
+                    monthString = "February";
+                    break;
+                case 3:
+                    monthString = "March";
+                    break;
+                default:
+                    monthString = "Some other month";
+                    break;
+            }
+            Console.WriteLine("Switch Case Result: " + monthString);
+
+
+            ////////////////////////////////
+            // Conversión de tipos de datos
+            ////////////////////////////////
+
+            // Convertir datos
+
+            // Convertir String a Integer
+            // esto generará una excepción al fallar la conversión
+            int.Parse("123");//retorna una versión entera de "123"
+
+            // TryParse establece la variable a un tipo por defecto
+            // en este caso: 0
+            int tryInt;
+            int.TryParse("123", out tryInt);
+
+            // Convertir Integer a String
+            // La clase Convert tiene algunos métodos para facilitar las conversiones
+            Convert.ToString(123);
+
+            ///////////////////////////////////////
+            // Clases y Funciones
+            ///////////////////////////////////////
+
+            Console.WriteLine("\n->Classes & Functions");
+
+            // (Definición de la clase Bicycle (Bicicleta))
+
+            // Usar new para instanciar una clase
+            Bicycle trek = new Bicycle();
+
+            // Llamar a los métodos del objeto
+            trek.speedUp(3); // Siempre deberías usar métodos setter y métodos getter
+            trek.setCadence(100);
+
+            // ToString es una convención para mostrar el valor del objeto.
+            Console.WriteLine("trek info: " + trek.ToString());
+
+            // Instanciar otra nueva bicicleta
+            Bicycle octo = new Bicycle(5, 10);
+            Console.WriteLine("octo info: " + octo.ToString());
+
+            // Instanciar un Penny Farthing (Biciclo)
+            PennyFarthing funbike = new PennyFarthing(1, 10);
+            Console.WriteLine("funbike info: " + funbike.ToString());
+
+            Console.Read();
+        } // Fin del método main
+
+
+    } // Fin de la clase LearnCSharp
+
+    // Puedes incluir otras clases en un archivo .cs
+
+
+    // Sintaxis para la declaración de clases:
+    // <public/private/protected> class <nombre_de_clase>{
+    //    //campos, constructores, funciones todo adentro de la clase.
+    //    //las funciones son llamadas métodos como en java.
+    // }
+
+    public class Bicycle
+    {
+        // Campos/Variables de la clase Bicycle
+        public int cadence; // Public: Accesible desde cualquier lado
+        private int _speed;  // Private: Sólo es accesible desde dentro de la clase
+        protected int gear; // Protected: Accesible desde clases y subclases
+        internal int wheels; // Internal: Accesible en el ensamblado
+        string name; // Todo es privado por defecto: Sólo es accesible desde dentro de esta clase
+
+        // Enum es un tipo valor que consiste un una serie de constantes con nombres
+        public enum Brand
+        {
+            AIST,
+            BMC,
+            Electra,
+            Gitane
+        }
+        // Definimos este tipo dentro de la clase Bicycle, por lo tanto es un tipo anidado
+        // El código afuera de esta clase debería referenciar este tipo como Bicycle.Brand
+
+        public Brand brand; // Declaramos un tipo enum, podemos declarar un campo de este tipo
+
+        // Los miembros estáticos pertenecen al tipo mismo, no a un objeto en específico.
+        static public int bicyclesCreated = 0;
+        // Puedes acceder a ellos sin referenciar ningún objeto:
+        // Console.WriteLine("Bicycles created: " + Bicycle.bicyclesCreated);
+
+        // Los valores readonly (Sólo lectura) son establecidos en tiempo de ejecución
+        // sólo pueden ser asignados al momento de la declaración o dentro de un constructor
+        readonly bool hasCardsInSpokes = false; // privado de sólo lectura
+
+        // Los constructores son una forma de crear clases
+        // Este es un constructor por defecto
+        private Bicycle()
+        {
+            gear = 1;
+            cadence = 50;
+            _speed = 5;
+            name = "Bontrager";
+            brand = Brand.AIST;
+            bicyclesCreated++;
+        }
+
+        // Este es un constructor específico (contiene argumentos)
+        public Bicycle(int startCadence, int startSpeed, int startGear,
+                       string name, bool hasCardsInSpokes, Brand brand)
+        {
+            this.gear = startGear; // La palabra reservada "this" señala el objeto actual
+            this.cadence = startCadence;
+            this._speed = startSpeed;
+            this.name = name; // Puede ser útil cuando hay un conflicto de nombres
+            this.hasCardsInSpokes = hasCardsInSpokes;
+            this.brand = brand;
+        }
+
+        // Los constructores pueden ser encadenados
+        public Bicycle(int startCadence, int startSpeed, Brand brand) :
+            this(startCadence, startSpeed, 0, "big wheels", true)
+        {
+        }
+
+        // Sintaxis para Funciones:
+        // <public/private/protected> <tipo_retorno> <nombre_funcion>(<args>)
+
+        // Las clases pueden implementar getters y setters para sus campos
+        // o pueden implementar propiedades
+
+        // Sintaxis para la declaración de métodos:
+        // <ámbito> <tipo_retorno> <nombre_método>(<argumentos>)
+        public int GetCadence()
+        {
+            return cadence;
+        }
+
+        // Los métodos void no requieren usar return
+        public void SetCadence(int newValue)
+        {
+            cadence = newValue;
+        }
+
+        // La palabra reservada virtual indica que este método puede ser sobrescrito
+        public virtual void SetGear(int newValue)
+        {
+            gear = newValue;
+        }
+
+        // Los parámetros de un método pueden tener valores por defecto.
+		// En este caso, los métodos pueden ser llamados omitiendo esos parámetros
+        public void SpeedUp(int increment = 1)
+        {
+            _speed += increment;
+        }
+
+        public void SlowDown(int decrement = 1)
+        {
+            _speed -= decrement;
+        }
+
+        // Propiedades y valores get/set
+        // Cuando los datos sólo necesitan ser accedidos, considera usar propiedades.
+        // Las propiedades pueden tener get, set o ambos
+        private bool _hasTassles; // variable privada
+        public bool HasTassles // acceso público
+        {
+            get { return _hasTassles; }
+            set { _hasTassles = value; }
+        }
+
+        // Las propiedades pueden ser auto implementadas
+        public int FrameSize
+        {
+            get;
+            // Puedes especificar modificadores de acceso tanto para get como para set
+            // esto significa que sólo dentro de la clase Bicycle se puede modificar Framesize
+            private set;
+        }
+
+        //Método para mostrar los valores de atributos de este objeto.
+        public override string ToString()
+        {
+            return "gear: " + gear +
+                    " cadence: " + cadence +
+                    " speed: " + _speed +
+                    " name: " + name +
+                    " cards in spokes: " + (hasCardsInSpokes ? "yes" : "no") +
+                    "\n------------------------------\n"
+                    ;
+        }
+
+        // Los métodos también pueden ser estáticos. Puede ser útil para métodos de ayuda
+        public static bool DidWeCreateEnoughBycles()
+        {
+            // Dentro de un método esático,
+			// Sólo podemos hacer referencia a miembros estáticos de clases
+            return bicyclesCreated > 9000;
+        }   // Si tu clase sólo necesita miembros estáticos,
+		    // considera establecer la clase como static.
+
+    } // fin de la clase Bicycle
+
+    // PennyFarthing es una subclase de Bicycle
+    class PennyFarthing : Bicycle
+    {
+        // (Penny Farthings son las bicicletas con una rueda delantera enorme.
+        // No tienen engranajes.)
+
+        // llamar al constructor de la clase padre
+        public PennyFarthing(int startCadence, int startSpeed) :
+            base(startCadence, startSpeed, 0, "PennyFarthing", true)
+        {
+        }
+
+        public override void SetGear(int gear)
+        {
+            gear = 0;
+        }
+
+        public override string ToString()
+        {
+            string result = "PennyFarthing bicycle ";
+            result += base.ToString(); // Llamar a la versión base del método
+            return reuslt;
+        }
+    }
+
+    // Las interfaces sólo contienen las declaraciones
+	// de los miembros, sin la implementación.
+    interface IJumpable
+    {
+        void Jump(int meters); // todos los miembros de interfaces son implícitamente públicos
+    }
+
+    interface IBreakable
+    {
+		// Las interfaces pueden contener tanto propiedades como métodos, campos y eventos
+        bool Broken { get; }
+    }
+
+	// Las clases sólo heredan de alguna otra clase, pero pueden implementar
+	// cualquier cantidad de interfaces
+    class MountainBike : Bicycle, IJumpable, IBreakable
+    {
+        int damage = 0;
+
+        public void Jump(int meters)
+        {
+            damage += meters;
+        }
+
+        public void Broken
+        {
+            get
+            {
+                return damage > 100;
+            }
+        }
+    }
+} // Fin del espacio de nombres
+
+```
+
+## Temas no cubiertos
+
+ * Flags
+ * Attributes
+ * Generics (T), Delegates, Func, Actions, lambda expressions
+ * Static properties
+ * Exceptions, Abstraction
+ * LINQ
+ * ASP.NET (Web Forms/MVC/WebMatrix)
+ * Winforms
+ * Windows Presentation Foundation (WPF)
+
+
+
+## Lecturas recomendadas
+
+ * [DotNetPerls](http://www.dotnetperls.com)
+ * [C# in Depth](http://manning.com/skeet2)
+ * [Programming C#](http://shop.oreilly.com/product/0636920024064.do)
+ * [LINQ](http://shop.oreilly.com/product/9780596519254.do)
+ * [MSDN Library](http://msdn.microsoft.com/es-es/library/618ayhy6.aspx)
+ * [ASP.NET MVC Tutorials](http://www.asp.net/mvc/tutorials)
+ * [ASP.NET Web Matrix Tutorials](http://www.asp.net/web-pages/tutorials)
+ * [ASP.NET Web Forms Tutorials](http://www.asp.net/web-forms/tutorials)
+ * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
+
+
+
+[Convenciones de código de C#](http://msdn.microsoft.com/es-es/library/vstudio/ff926074.aspx)
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/elisp-es.html.markdown b/es-es/elisp-es.html.markdown
new file mode 100644
index 00000000..a6cd3934
--- /dev/null
+++ b/es-es/elisp-es.html.markdown
@@ -0,0 +1,378 @@
+---
+language: elisp
+contributors:
+    - ["Bastien Guerry", "http://bzg.fr"]
+translators:
+    - ["Guillermo Vayá", "http://willyfrog.es"]
+lang: es-es
+filename: learn-emacs-lisp-es.el
+---
+
+```scheme
+;; Introduccion a Emacs Lisp en 15 minutos (v0.2d)
+;;
+;; Autor: Bastien / @bzg2 / http://bzg.fr
+;; Traducción: Guillermo Vayá / @Driadan / http://willyfrog.es
+;;
+;; Antes de nada, lee este texto de Peter Norvig:
+;; Traducido: http://loro.sourceforge.net/notes/21-dias.html
+;; Original: http://norvig.com/21-days.html
+;;
+;; Ahora instala GNU Emacs 24.3:
+;;
+;; Debian: apt-get install emacs 
+;; (o sigue las instrucciones de tu distribución preferida)
+;; OSX: http://emacsformacosx.com/emacs-builds/Emacs-24.3-universal-10.6.8.dmg
+;; Windows: http://ftp.gnu.org/gnu/windows/emacs/emacs-24.3-bin-i386.zip
+;;
+;; Puedes encontrar información general sobre Emacs en:
+;; http://www.gnu.org/software/emacs/#Obtaining
+
+;; Aviso importante:
+;;
+;; Seguir este tutorial no provocará daños en tu ordenador a menos que
+;; te enfades tanto que que acabes tirándolo al suelo. En tal caso 
+;; declino cualquier responsabilidad. ¡A divertirse!
+
+
+;; "N. del. T.": Algunos términos comunes de la informática se han dejado 
+;; sin traducir ya que es mucho más probable que el lector los conozca en 
+;; su forma en inglés, siendo la versión en español de muy raro uso.
+;; Además "sexps" se ha decidido traducir por sexpresión.
+;; Por último, añadir que no se han traducido los ejemplos de código ya que no 
+;; es necesario entender qué dice el string para comprender el funcionamiento
+;; y podría llevar a error.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 
+;; Inicia Emacs.
+;;
+;; Pulsa la tecla `q' para pasar el mensaje de bienvenida.
+;;
+;; Mira a la línea gris en la parte inferior de la ventana:
+;;
+;; "*scratch*" es el nombre del espacio editable donde estás.
+;; A este espacio editable se le llama "buffer".
+;;
+;; Scratch es el buffer por defecto cuando abres Emacs.
+;; En Emacs nunca editas ficheros, sino que editas buffers que 
+;; posteriormente pueden grabarse a un fichero.
+;; can save to a file.
+;; 
+;; "Lisp interaction" indica el conjunto de ordenes disponibles.
+;; 
+;; Emacs dispone de un set de comandos disponibles en cualquier buffer
+;; ("built-ins") y aparte varios conjuntos de ordenes disponibles 
+;; según el modo específico que esté activo. En nuestro caso 
+;; estamos usando `lisp-interaction-mode', el cual incluye las
+;; ordenes necesarias para evaluar y navegar código Elisp.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Un punto y coma comienza un comentario. Pueden ponerse en cualquier 
+;; posicion de la linea.
+;;
+;; Los programas en Elisp se componen de expresiones simbólicas
+;; tambien llamadas "sexps":
+(+ 2 2)
+
+;; Esta expresión simbólica se lee tal que "Suma 2 y 2"
+
+;; Las sexpresiones se rodean por paréntesis, y pueden anidarse:
+(+ 2 (+ 1 1))
+
+;; Una expresion simbólica está formada bien por átomos o bien por otras 
+;; expresiones simbólicas. En el ejemplo de arriba, 1 y 2 son átomos, 
+;; mientras que (+ 2 (+ 1 1)) y (+ 1 1) son expresiones simbólicas.
+
+;; Gracias a `lisp-interaction-mode' puedes evaluar las sexpresiones.
+;; Coloca el cursor justo despues del paréntesis de cierre y 
+;; mantén pulsada la tecla Control y la j (para abreviar usaremos "C-j").
+
+(+ 3 (+ 1 2))
+;;           ^ pon aquí el cursor
+;; `C-j' => 6
+
+;; `C-j' añade el resultado de la evaluación al buffer.
+
+;; `C-xC-e' muestra el mismo resultado pero en la linea inferior
+;; la cual se llama "minibuffer".  Este será el metodo que usaremos 
+;; normalmente para no llenar el buffer con texto inútil.
+
+;; `setq' guarda un valor en una variable:
+(setq my-name "Bastien")
+;; `C-xC-e' => "Bastien" (aparece en el mini-buffer)
+
+;; `insert' añade "Hello!" en el punto donde esté tu cursor:
+(insert "Hello!")
+;; `C-xC-e' => "Hello!"
+
+;; Aunque hemos usado `insert' con solo un parámetro "Hello!", se
+;; pueden pasar más. Por ejemplo, en esta otra sexpresión usamos dos:
+
+(insert "Hello" " world!")
+;; `C-xC-e' => "Hello world!"
+
+;; Se pueden usar variables en lugar de strings:
+(insert "Hello, I am " my-name)
+;; `C-xC-e' => "Hello, I am Bastien"
+
+;; Puedes combinar sexpresiones en funciones:
+(defun hello () (insert "Hello, I am " my-name))
+;; `C-xC-e' => hello
+
+;; Evaluemos la funcion:
+(hello)
+;; `C-xC-e' => Hello, I am Bastien
+
+;; Los parentesis vacios en la definicion de una funcion indican
+;; que no acepta parámetros. En cualquier caso, usar `my-name' siempre
+;; es aburrido, asi que vamos a hacer que la función accepte un parámetro
+;; (en este caso el parametro se llama "name"):
+(defun hello (name) (insert "Hello " name))
+;; `C-xC-e' => hello
+
+;; Ahora vamos a llamar a la funcion con el string "you" como valor para 
+;; el único parámetro que posee.
+(hello "you")
+;; `C-xC-e' => "Hello you"
+
+;; ¡Genial!
+
+;; Descansa un poco y respira.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Ahora cambiaremos al nuevo buffer, llamado "*test*", en una nueva ventana.
+
+(switch-to-buffer-other-window "*test*")
+;; `C-xC-e'
+;; => [La pantalla ahora tiene dos ventanas y el cursor está en el buffer *test*]
+
+;; Mueve el ratón sobre la ventana superior y pulsa el boton izdo. para volver. 
+;; Otra forma es usando `C-xo' (pulsa simultaneamente control y x y luego la o)
+;; para ir a la otra ventana.
+
+;; Se pueden combinar varias sexpresiones mediante `progn':
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (hello "you"))
+;; `C-xC-e'
+;; => [De las dos ventanas de la pantalla, el cursor está en la marcada como *test*]
+
+;; A partir de ahora, si no te importa, dejaremos de decir que pulses `C-xC-e': 
+;; tendrás que hacerlo para ejecutar cada sexpresión que siga.
+
+;; También tendrás que volver al buffer *scratch* bien con el ratón o con `C-xo'.
+
+;; En ocasiones será util limpiar el buffer:
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "there"))
+
+;; O volver a la ventana anterior:
+(progn
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello "you")
+  (other-window 1))
+
+;; Puedes enlazar un valor a una variable local con `let':
+(let ((local-name "you"))
+  (switch-to-buffer-other-window "*test*")
+  (erase-buffer)
+  (hello local-name)
+  (other-window 1))
+
+;; En este caso, no hace falta añadir `progn' ya que `let' permite combinar 
+;; varias sexpresiones.
+
+;; Vamos a darle formato a un string:
+(format "Hello %s!\n" "visitor")
+
+;; Cada %s indica la posicion donde irá un string, el cual será reemplazado 
+;; por "visitor". "\n" es el caracter de nueva línea.
+
+;; Mejoremos nuestra funcion usando `format':
+(defun hello (name)
+  (insert (format "Hello %s!\n" name)))
+
+(hello "you")
+
+;; Creemos una nueva funcion que utililce `let':
+(defun greeting (name)
+  (let ((your-name "Bastien"))
+    (insert (format "Hello %s!\n\nI am %s."
+                    name       ; the argument of the function
+                    your-name  ; the let-bound variable "Bastien"
+                    ))))
+
+;; Y ahora la evaluamos:
+(greeting "you")
+
+;; Algunas funciones son interactivas:
+(read-from-minibuffer "Enter your name: ")
+
+;; Al evaluar esta función, ésta devuelve lo que hayas introducido.
+
+;; Ahora hagamos nuestra función `greeting' preguntar por tu nombre:
+(defun greeting (from-name)
+  (let ((your-name (read-from-minibuffer "Enter your name: ")))
+    (insert (format "Hello!\n\nI am %s and you are %s."
+                    from-name ; the argument of the function
+                    your-name ; the let-bound var, entered at prompt
+                    ))))
+
+(greeting "Bastien")
+
+;; Y ahora la completamos mostrando el resultado en la otra ventana:
+(defun greeting (from-name)
+  (let ((your-name (read-from-minibuffer "Enter your name: ")))
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    (insert (format "Hello %s!\n\nI am %s." your-name from-name))
+    (other-window 1)))
+
+;; Probémosla:
+(greeting "Bastien")
+
+;; Descansa un poco y respira.
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Creemos una lista de nombres:
+(setq list-of-names '("Sarah" "Chloe" "Mathilde"))
+
+;; Para coger el primer elemento de la lista usaremos `car':
+(car list-of-names)
+
+;; Para coger todos menos el primer elemento de la lista 
+;; usaremos `cdr':
+(cdr list-of-names)
+
+;; Para añadir un elemento al comienzo de la lista utilizamos `push':
+(push "Stephanie" list-of-names)
+
+;; OJO: `car' y `cdr' no modifican la lista, mientras que `push' sí.
+;; ¡Es una diferencia importante! Algunas funciones no tienen efectos 
+;; colaterales (como `car') mientras que otras sí (como `push').
+;; "N. del T.": estos efectos colaterales se les llama `side-effects' en 
+;; las distintas variantes de lisp.
+
+;; Llamemos a `hello' con cada elemento de `list-of-names':
+(mapcar 'hello list-of-names)
+
+;; Retocamos `greeting' para que salude a todos los que estén en `list-of-names':
+(defun greeting ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    (mapcar 'hello list-of-names)
+    (other-window 1))
+
+(greeting)
+
+;; ¿Te acuerdas de la función `hello' definida un poco más arriba?
+;; Recibía un parámetro: `name'. Así que `mapcar' llama a `hello' con cada 
+;; elemento de `list-of-names' como parámetro de `hello'.
+
+;; Ahora ordenaremos un poco lo que tenemos en el buffer:
+
+(defun replace-hello-by-bonjour ()
+    (switch-to-buffer-other-window "*test*")
+    (goto-char (point-min))
+    (while (search-forward "Hello")
+      (replace-match "Bonjour"))
+    (other-window 1))
+
+;; (goto-char (point-min)) mueve el cursor al principio del buffer.
+;; (search-forward "Hello") busca un string "Hello".
+;; (while x y) evalua la/s sexpresion/es y mientras que x devuelva
+;; alguna cosa.
+;; En el momento que x devuelva `nil' (es decir nada), sale del 
+;; bucle `while'.
+
+(replace-hello-by-bonjour)
+
+;; Observamos que todas las veces que teníamos la palabra "Hello" en el buffer *test*
+;; han sido reemplazadas por "Bonjour".
+
+;; Y además, hemos obtenido un error: "Search failed: Hello".
+;;
+;; Para evitar este error, hay que decirle a `search-forward' si debería dejar de 
+;; buscar en el buffer en algún momento y si debería fallar sin quejarse cuando 
+;; no encuentra nada.
+
+;; (search-forward "Hello" nil t) justo hace eso:
+
+;; El argumento `nil' significa que la busqueda no está ligada a ninguna posición.
+;; Y el argumento `t' le pide que no diga nada si no encuentra el string.
+
+;; Usaremos esta sexpresión en la función siguiente, la cual ya 
+;; no muestra ningún error:
+
+(defun hello-to-bonjour ()
+    (switch-to-buffer-other-window "*test*")
+    (erase-buffer)
+    ;; Say hello to names in `list-of-names'
+    (mapcar 'hello list-of-names)
+    (goto-char (point-min))
+    ;; Replace "Hello" by "Bonjour"
+    (while (search-forward "Hello" nil t)
+      (replace-match "Bonjour"))
+    (other-window 1))
+
+(hello-to-bonjour)
+
+;; Añadamos algo de color a los nombres:
+
+(defun boldify-names ()
+    (switch-to-buffer-other-window "*test*")
+    (goto-char (point-min))
+    (while (re-search-forward "Bonjour \\(.+\\)!" nil t)
+      (add-text-properties (match-beginning 1)
+                           (match-end 1)
+                           (list 'face 'bold)))
+    (other-window 1))
+
+;; Esta función nos presenta `re-search-forward': en vez de 
+;; buscar el string "Bonjour" exacto, se busca por un patrón
+;; usando una "expresión regular" (lo cual se muestra abreviado 
+;; en el prefijo "re-" del inglés "Regular Expression").
+
+;; La expresión regular a utilizar es "Bonjour \\(.+\\)!" y se traduce como:
+;; el string "Bonjour ", seguido de 
+;; un grupo de           | representado por \\( ... \\)
+;;   cualquier caracter  | representado por .
+;;   al menos una vez    | representado por +
+;; y el string "!".
+
+;; ¿Preparado?  ¡Probemoslo!
+
+(boldify-names)
+
+;; `add-text-properties' añade propiedades al texto, como una fuente.
+
+;; ¡Hale! ¡Ya lo tenemos! ¡Feliz hacking!
+
+;; Si quieres saber más sobre una función o una variable:
+;;
+;; C-h v la-variable RET
+;; C-h f la-funcion RET
+;;
+;; Si quieres leer el manual de Emacs Lisp desde dentro de Emacs:
+;;
+;; C-h i m elisp RET
+;;
+;; Para leer una introducción en linea de Emacs Lisp:
+;; https://www.gnu.org/software/emacs/manual/html_node/eintr/index.html
+
+;; Me gustaría agradecer a las siguientes personas su feedback y sugerencias:
+;; - Wes Hardaker
+;; - notbob
+;; - Kevin Montuori
+;; - Arne Babenhauserheide
+;; - Alan Schmitt
+;; - LinXitoW
+;; - Aaron Meurer
+```
diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
new file mode 100644
index 00000000..18b544b4
--- /dev/null
+++ b/es-es/git-es.html.markdown
@@ -0,0 +1,409 @@
+---
+category: tool
+tool: git
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+translator:
+    - ["Raúl Ascencio", "http://rscnt.github.io"]
+filename: LearnGit.txt
+lang: es-es
+
+---
+
+Git es un sistema de control de versiones distribuido diseñado para manejar
+cualquier tipo de proyecto, ya sea grande o pequeño, con velocidad y eficiencia.
+
+Git realiza esto haciendo "snapshots" del proyecto, con ello permite
+versionar y administrar nuestro código fuente.
+
+## Versionamiento, conceptos.
+
+### Qué es el control de versiones?
+El control de versiones es un sistema que guarda todos los cambios realizados en
+uno o varios archivos, a lo largo del tiempo.
+
+### Versionamiento centralizado vs Versionamiento Distribuido.
+
++ El versionamiento centralizado se enfoca en sincronizar, rastrear, y respaldar
+  archivos.
++ El versionamiento distribuido se enfoca en compartir los cambios realizados.
+  Cada cambio tiene un único identificador.
++ El versionamiento distribuido no tiene una estructura definida, incluso se
+  puede mantener el estilo de los repositorios SVN con git.
+
+[Información adicional](http://git-scm.com/book/es/Empezando-Acerca-del-control-de-versiones)
+
+### Por qué usar Git?
+
+* Se puede trabajar sin conexion.
+* ¡Colaborar con otros es sencillo!.
+* Derivar, crear ramas del proyecto (aka: Branching) es fácil.
+* Combinar (aka: Merging)
+* Git es rápido.
+* Git es flexible.
+
+## Arquitectura de Git.
+
+### Repositorio
+
+Un repositorio es un conjunto de archivos, directorios, registros, cambios (aka:
+comits), y encabezados (aka: heads). Imagina que un repositorio es una clase,
+y que sus atributos otorgan acceso al historial del elemento, además de otras
+cosas.
+
+Un repositorio esta compuesto por la carpeta .git y un "árbol de trabajo".
+
+### Directorio .git (componentes del repositorio)
+
+El directorio .git contiene todas las configuraciones, registros, branches, HEAD
+y mas.
+
+[Lista detallada.](http://es.gitready.com/advanced/2009/03/23/whats-inside-your-git-directory.html)
+
+### Directorio de trabajo (componentes del repositorio)
+
+Es basicamente los directorios y archivos dentro del repositorio. La mayoría de
+las veces se le llama "directorio de trabajo".
+
+### Índice (componentes del directorio .git)
+
+El índice es el área de inicio en git. Es basicamente la capa que separa el
+directorio de trabajo del repositorio en git. Esto otorga a los desarrolladores
+más poder sobre lo que se envía y se recibe del repositorio.
+
+### Commit (aka: cambios)
+
+Un commit es una captura de un conjunto de cambios, o modificaciones hechas en
+el directorio de trabajo. Por ejemplo, si se añaden 5 archivos, se eliminan 2,
+estos cambios se almacenarán en un commit (aka: captura). Este commit puede ser o
+no ser enviado (aka: "pusheado") hacia un repositorio.
+
+### Branch (rama)
+
+Un "branch", es escencialmente un apuntador hacia el último commit (cambio
+registrado) que se ha realizado. A medida que se realizan más commits, este
+apuntador se actualizará automaticamente hacia el ultimo commit.
+
+### "HEAD" y "head" (componentes del directorio .git)
+
+"HEAD" es un apuntador hacia la rama (branch) que se esta utilizando. Un
+repositorio solo puede tener un HEAD activo. En cambio "head", es un apuntador a
+cualquier commit realizado, un repositorio puede tener cualquier número de
+"heads".
+
+### conceptos - recursos.
+
+* [Git para informáticos](http://eagain.net/articles/git-for-computer-scientists/)
+* [Git para diseñadores](http://hoth.entp.com/output/git_for_designers.html)
+
+
+## Comandos.
+
+
+### init
+
+Crear un repositorio de git vacio. Las configuraciones, información almacenada y
+demás son almacenadas en el directorio ".git".
+
+```bash
+$ git init
+```
+
+### config
+
+Se utiliza para configurar las opciones ya sea globalmente, o solamente en el
+repositorio.
+
+```bash
+# Imprime y guarda algunas variables de configuracion básicas. (Globalmente)
+$ git config --global user.email
+$ git config --global user.name
+
+$ git config --global user.email "corre@gmail.com"
+$ git config --global user.name "nombre"
+```
+
+[Más sobre git config.](http://git-scm.com/book/es/Personalizando-Git-Configuración-de-Git)
+
+### help
+
+Otorga un accceso rápido a una guía extremadamente detallada de cada comando en
+git. O puede ser usada simplemente como un recordatorio de estos.
+
+```bash
+# Una vista rápida de los comandos disponibles.
+$ git help
+
+# Chequear todos los comandos disponibles
+$ git help -a
+
+# Obtener ayuda especifica de un comando - manual de usuario
+# git help <comando>
+$ git help add
+$ git help commit
+$ git help init
+```
+
+### status
+
+Muestra las diferencias entre el archivo índice y el commit al cual apunta el
+HEAD actualmente.
+
+
+```bash
+# Mostrará el "branch", archivos sin añadir al repo, cambios y otras
+# diferencias
+$ git status
+
+# Devuelve ayuda sobre el comando status.
+$ git help status
+```
+
+### add
+
+Para añadir archivos al árbol (directorio, repositorio) de trabajo. Si no se
+utiliza `git add`, los nuevos archivos no se añadirán al arbol de trabajo, por
+lo que no se incluirán en los commits (cambios).
+
+```bash
+# Añade un archivo en el directorio de trabajo actual.
+$ git add FooBar.java
+
+# Añade un archivo que se encuentra bajo un directorio.
+$ git add /directorio/del/archivo/Foo.c
+
+# Soporte para expresiones regulares!
+$ git add ./*.py
+```
+
+### branch
+
+Administra las ramas del repositorio ("branches"). Puedes ver, editar, crear y
+borrar ramas ("branches"), usando este comando.
+
+```bash
+# lista todas las ramas (remotas y locales)
+$ git branch -a
+
+# Añadir una nueva rama ("branch").
+$ git branch branchNueva
+
+# Eliminar una rama.
+$ git branch -d branchFoo
+
+# Renombrar una rama.
+# git branch -m <anterior> <nuevo>
+$ git branch -m youngling padawan
+
+# Editar la descripcion de la rama.
+$ git branch master --edit-description
+```
+
+### checkout
+
+Actualiza todos los archivos en el directorio de trabajo para que sean igual que
+las versiones almacenadas en el índice, o en un árbol de trabajo especificado.
+
+```bash
+# Despachar un repositorio. - Por defecto la master branch. (la rama principal llamada 'master')
+$ git checkout
+# Despacha una rama especifica.
+$ git checkout padawan
+# Crea una nueva rama y cambia hacia ella, es igual a utilizar: "git brach jedi; git checkout jedi"
+$ git checkout -b jdei
+```
+
+### clone
+
+Clona, o copia, un repositorio existente en un nuevo directorio. También añade el
+seguimiento hacia las ramas existentes del repositorio que ha sido clonado, lo que
+permite subir (push) los archivos hacia una rama remota.
+
+```bash
+# Clonar la repo de jquery.
+$ git clone https://github.com/jquery/jquery.git
+```
+
+### commit
+
+Almacena el contenido actual del índice en un nuevo "commit". Este
+commit contiene los cambios hechos más un resumen proporcionado por el desarrollador.
+
+```bash
+# realizar un commit y añadirle un mensaje.
+$ git commit -m "jedi anakin wil be - jedis.list"
+```
+
+### diff
+
+Muestra las diferencias entre un archivo en el directorio de trabajo, el índice
+y los commits.
+
+```bash
+# Muestra la diferencia entre un directorio de trabajo y el índice.
+$ git diff
+
+# Muestra la diferencia entre el índice y los commits más recientes.
+$ git diff --cached
+
+# Muestra la diferencia entre el directorio de trabajo y el commit más reciente.
+$ git diff HEAD
+```
+
+### grep
+
+Permite realizar una busqueda rápida en un repositorio.
+
+Configuraciones opcionales:
+
+```bash
+# Gracias a Travis Jeffery por compartir lo siguiente.
+# Permite mostrar numeros de lineas en la salida de grep.
+$ git config --global grep.lineNumber true
+
+# Realiza una búsqueda mas legible, incluyendo agrupación.
+$ git config --global alias.g "grep --break --heading --line-number"
+```
+
+```bash
+# Busca por "unaVariable" en todos los archivos .java
+$ git grep 'unaVariable' -- '*.java'
+
+# Busca por una línea que contenga "nombreArreglo" y "agregar" o "remover"
+$ git grep -e 'nombreArreglo' --and \( -e agregar -e remover \)
+```
+
+Más ejemplos:
+
+- [Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+
+### log
+
+Muestra los commits (cambios) registrados en el repositorio.
+
+```bash
+# Muestra todos los commits.
+$ git log
+
+# Muestra un numero x de commits.
+$ git log -n 10
+
+# Muestra solo los commits que se han combinado en el historial.
+$ git log --merges
+```
+
+### merge
+
+Combina los cambios de commits realizados externamente dentro de la rama en la
+que se trabaja.
+
+```bash
+# Combina la rama especificada en la rama actual.
+$ git merge jediMaster
+
+# Siempre genere un solo merge commit cuando se utiliza merge.
+$ git merge --no-ff jediMaster
+```
+
+### mv
+
+Renombra o mueve un archivo
+
+```bash
+# Renombrando un archivo.
+$ git mv HolaMundo.c AdiosMundo.c
+
+# Moviendo un archivo.
+$ git mv HolaOtraVezMundo.c ./nuevo/directorio/NuevoArchivo.c
+
+# Sustituye un archivo.
+$ git mv -f archivoA archivoB
+```
+
+### pull
+
+Trae los cambios de un repositorio y los combina en otro en una rama diferente.
+
+```bash
+# Actualiza el repositorio local, combinando los nuevos cambios
+# de las ramas remotas "origin" y "master".
+# git pull <remota> <rama>
+$ git pull origin master
+```
+
+### push
+
+Envía y combina los cambios de un repositorio local a un repositorio y rama remotos.
+
+```bash
+# Envía y combina cambios de un repositorio local hacia un repositorio remoto
+# llamados "origin" y "master", respectivamente.
+# git push <remota> <rama>
+# git push => por defecto es lo mismo que poner =>  git push origin master
+$ git push origin master
+```
+
+### rebase
+
+Toma todos los cambios que fueron registrados en una rama, y los repite dentro
+de otra rama. *No reescribe los commits que se han empujado antes a un repositorio público.*
+
+```bash
+# Integrar ramaExperimento dentro de la rama "master"
+# git rebase <basebranch> <topicbranch>
+$ git rebase master experimentBranch
+```
+
+[Información adicional.](http://git-scm.com/book/es/Ramificaciones-en-Git-Procedimientos-básicos-para-ramificar-y-fusionar)
+
+### reset (precaución)
+
+Reinicia el HEAD actual hacia un estado especificado. Esto permite deshacer
+combinaciones (merges), pulls, commits, adds y más. Es un comando útil, pero
+tambien peligroso si no se sabe lo que se hace.
+
+```bash
+# Reinicia el área principal, con el último cambio registrado. (deja los
+# directorios sin cambios)
+$ git reset
+
+# Reinicia el área principal, con el último cambio registrado, y reescribe el
+# directorio de trabajo.
+$ git reset --hard
+
+# Mueve la rama actual hacia el commit especificado (no realiza cambios a los
+# directorios), todos los cambios aún existen el directorio.
+$ git reset 31f2bb1
+
+# Mueve la rama actual devuelta a un commit especificado, así como el
+# directorio (borra todos los cambios que no fueron registrados y todos los
+# cambios realizados después del commit especificado).
+$ git reset --hard 31f2bb1
+```
+
+### rm
+
+Lo contrario de git add, git rm elimina los archivos del directorio de trabajo
+actual.
+
+```bash
+# Elimina FooBar.c
+$ git rm FooBar.c
+
+# Elimina un archivo de un directorio.
+$ git rm /directorio/del/archivo/FooBar.c
+```
+
+## Información Adicional
+
+* [tryGit - Una forma entretenida y rapida de aprender Git.](http://try.github.io/levels/1/challenges/1)
+
+* [git-scm - Video-tutoriales](http://git-scm.com/videos)
+
+* [git-scm - Documentacion](http://git-scm.com/book/es)
+
+* [Atlassian Git - Tutoriales y Flujos de trabajo](https://www.atlassian.com/git/)
+
+* [SalesForce Chuleta](https://na1.salesforce.com/help/doc/en/salesforce_git_developer_cheatsheet.pdf)
+
+* [GitGuys](http://www.gitguys.com/)
diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
new file mode 100644
index 00000000..c41d693d
--- /dev/null
+++ b/es-es/go-es.html.markdown
@@ -0,0 +1,450 @@
+---
+name: Go
+category: language
+language: Go
+lang: es-es
+filename: learngo-es.go
+contributors:
+    - ["Sonia Keys", "https://github.com/soniakeys"]
+    - ["Christopher Bess", "https://github.com/cbess"]
+    - ["Jesse Johnson", "https://github.com/holocronweaver"]
+    - ["Quint Guvernator", "https://github.com/qguv"]
+    - ["Jose Donizetti", "https://github.com/josedonizetti"]
+    - ["Alexej Friesen", "https://github.com/heyalexej"]
+translators:
+    - ["Adrian Espinosa", "http://www.adrianespinosa.com"]
+    - ["Jesse Johnson", "https://github.com/holocronweaver"]
+    - ["Nacho Pacheco -- Feb/2015", "https://github.com/gitnacho"]
+---
+
+Go fue creado por la necesidad de hacer el trabajo rápidamente. No es la
+última tendencia en informática, pero es la forma nueva y más rápida de
+resolver problemas reales.
+
+Tiene conceptos familiares de lenguajes imperativos con tipado estático.
+Es rápido compilando y rápido al ejecutar, añade una concurrencia fácil de
+entender para las CPUs de varios núcleos de hoy día, y tiene
+características que ayudan con la programación a gran escala.
+
+Go viene con una biblioteca estándar muy buena y una entusiasta comunidad.
+
+```go
+// Comentario de una sola línea
+/* Comentario
+   multilínea */
+
+// La cláusula `package` aparece al comienzo de cada fichero fuente.
+// `main` es un nombre especial que declara un ejecutable en vez de una
+// biblioteca.
+package main
+
+// La instrucción `import` declara los paquetes de bibliotecas referidos
+// en este fichero.
+import (
+	"fmt"      // Un paquete en la biblioteca estándar de Go.
+	"io/ioutil" // Implementa algunas útiles funciones de E/S.
+	m "math"   // Biblioteca de matemáticas con alias local m.
+	"net/http" // Sí, ¡un servidor web!
+	"strconv"  // Conversiones de cadenas.
+)
+
+// Definición de una función. `main` es especial. Es el punto de entrada
+// para el ejecutable. Te guste o no, Go utiliza llaves.
+func main() {
+	// Println imprime una línea a stdout.
+	// Cualificalo con el nombre del paquete, fmt.
+	fmt.Println("¡Hola mundo!")
+
+	// Llama a otra función de este paquete.
+	másAlláDelHola()
+}
+
+// Las funciones llevan parámetros entre paréntesis.
+// Si no hay parámetros, los paréntesis siguen siendo obligatorios.
+func másAlláDelHola() {
+	var x int // Declaración de una variable.
+ 	          // Las variables se deben declarar antes de utilizarlas.
+	x = 3     // Asignación de variable.
+	// Declaración "corta" con := para inferir el tipo, declarar y asignar.
+	y := 4
+	suma, producto := aprendeMúltiple(x, y) // La función devuelve dos
+											// valores.
+	fmt.Println("suma:", suma, "producto:", producto) // Simple salida.
+	aprendeTipos()                        // < y minutos, ¡aprende más!
+}
+
+// Las funciones pueden tener parámetros y (¡múltiples!) valores de
+// retorno.
+func aprendeMúltiple(x, y int) (suma, producto int) {
+    return x + y, x * y // Devuelve dos valores.
+}
+
+// Algunos tipos incorporados y literales.
+func aprendeTipos() {
+	// La declaración corta suele darte lo que quieres.
+	s := "¡Aprende Go!" // tipo cadena.
+	s2 := `Un tipo cadena "puro" puede incluir
+saltos de línea.` // mismo tipo cadena
+
+	// Literal no ASCII. Los ficheros fuente de Go son UTF-8.
+	g := 'Σ' // Tipo rune, un alias de int32, alberga un carácter 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 iniciadores.
+	var u uint = 7 // Sin signo, pero la implementación depende del tamaño
+	               // como en int.
+	var pi float32 = 22. / 7
+
+	// Sintáxis de conversión con una declaración corta.
+	n := byte('\n') // byte es un alias para uint8.
+
+	// Los Arreglos tienen un tamaño fijo a la hora de compilar.
+	var a4 [4]int           // Un arreglo de 4 ints, iniciados a 0.
+	a3 := [...]int{3, 1, 5} // Un arreglo iniciado con un tamaño fijo de tres
+							// elementos, con valores 3, 1 y 5.
+	// Los Sectores tienen tamaño dinámico. Los arreglos y sectores tienen
+	// sus ventajas y desventajas pero los casos de uso para los sectores
+	// son más comunes.
+	s3 := []int{4, 5, 9}     // Comparar con a3. No hay puntos suspensivos.
+	s4 := make([]int, 4)     // Asigna sectores de 4 ints, iniciados a 0.
+	var d2 [][]float64       // Solo declaración, sin asignación.
+	bs := []byte("a sector") // Sintaxis de conversión de tipo.
+	// Debido a que son dinámicos, los sectores pueden crecer bajo demanda.
+	// Para añadir elementos a un sector, se utiliza la función incorporada
+	// append().
+	// El primer argumento es el sector al que se está anexando. Comúnmente,
+	// la variable del arreglo se actualiza en su lugar, como en el 
+	// siguiente ejemplo.
+	sec := []int{1, 2 , 3}      // El resultado es un sector de longitud 3.
+	sec = append(sec, 4, 5, 6)  // Añade 3 elementos. El sector ahora tiene una
+								// longitud de 6.
+	fmt.Println(sec) // El sector actualizado ahora es [1 2 3 4 5 6]
+	// Para anexar otro sector, en lugar de la lista de elementos atómicos
+	// podemos pasar una referencia a un sector o un sector literal como
+	// este, con elipsis al final, lo que significa tomar un sector y
+	// desempacar sus elementos, añadiéndolos al sector sec.
+	sec = append(sec, []int{7, 8, 9} ...) // El segundo argumento es un
+										  // sector literal.
+	fmt.Println(sec)  // El sector actualizado ahora es [1 2 3 4 5 6 7 8 9]
+	p, q := aprendeMemoria() // Declara p, q para ser un tipo puntero a
+							 // int.
+	fmt.Println(*p, *q)      // * sigue un puntero. Esto imprime dos ints.
+
+	// Los Mapas son arreglos asociativos dinámicos, como los hash o
+	// diccionarios de otros lenguajes.
+	m := map[string]int{"tres": 3, "cuatro": 4}
+	m["uno"] = 1
+
+	// Las variables no utilizadas en Go producen error.
+	// El guión bajo permite "utilizar" una variable, pero descartar su
+	// valor.
+	_, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs
+	// Esto cuenta como utilización de variables.
+	fmt.Println(s, c, a4, s3, d2, m)
+
+	aprendeControlDeFlujo() // Vuelta al flujo.
+}
+
+// Es posible, a diferencia de muchos otros lenguajes tener valores de
+// retorno con nombre en las funciones.
+// Asignar un nombre al tipo que se devuelve en la línea de declaración de
+// la función nos permite volver fácilmente desde múltiples puntos en una
+// función, así como sólo utilizar la palabra clave `return`, sin nada
+// más.
+func aprendeRetornosNombrados(x, y int) (z int) {
+	z = x * y
+	return // aquí z es implícito, porque lo nombramos antes.
+}
+
+// Go posee recolector de basura. Tiene punteros pero no aritmética de
+// punteros. Puedes cometer errores con un puntero nil, pero no
+// incrementando un puntero.
+func aprendeMemoria() (p, q *int) {
+	// Los valores de retorno nombrados q y p tienen un tipo puntero
+	// a int.
+	p = new(int) // Función incorporada que reserva memoria.
+	// La asignación de int se inicia a 0, p ya no es nil.
+	s := make([]int, 20) // Reserva 20 ints en un solo bloque de memoria.
+	s[3] = 7             // Asigna uno de ellos.
+	r := -2              // Declara otra variable local.
+	return &s[3], &r     // & toma la dirección de un objeto.
+}
+
+func cálculoCaro() float64 {
+	return m.Exp(10)
+}
+
+func aprendeControlDeFlujo() {
+	// La declaración If requiere llaves, pero no paréntesis.
+	if true {
+		fmt.Println("ya relatado")
+	}
+	// El formato está estandarizado por la orden "go fmt."
+	if false {
+		// Abadejo.
+	} else {
+		// Relamido.
+	}
+	// Utiliza switch preferentemente para if encadenados.
+	x := 42.0
+	switch x {
+	case 0:
+	case 1:
+	case 42:
+		// Los cases no se mezclan, no requieren de "break".
+	case 43:
+		// No llega.
+	}
+	// Como if, for no utiliza paréntesis tampoco.
+	// Variables declaradas en for e if son locales a su ámbito.
+	for x := 0; x < 3; x++ { // ++ es una instrucción.
+		fmt.Println("iteración", x)
+	}
+	// aquí x == 42.
+
+	// For es la única instrucción de bucle en Go, pero tiene formas
+	// alternativas.
+	for { // Bucle infinito.
+		break    // ¡Solo bromeaba!
+		continue // No llega.
+	}
+
+	// Puedes usar `range` para iterar en un arreglo, un sector, una
+	// cadena, un mapa o un canal.
+	// `range` devuelve o bien, un canal o de uno a dos valores (arreglo,
+	// sector, cadena y mapa).
+	for clave, valor := range map[string]int{"uno": 1, "dos": 2, "tres": 3} {
+		// por cada par en el mapa, imprime la clave y el valor
+		fmt.Printf("clave=%s, valor=%d\n", clave, valor)
+	}
+
+	// Como en for, := en una instrucción if significa declarar y asignar
+	// primero, luego comprobar y > x.
+	if y := cálculoCaro(); y > x {
+		x = y
+    }
+	// Las funciones literales son "cierres".
+	granX := func() bool {
+		return x > 100 // Referencia a x declarada encima de la instrucción
+							// switch.
+	}
+	fmt.Println("granX:", granX()) // cierto (la última vez asignamos
+											 // 1e6 a x).
+	x /= 1.3e3                   // Esto hace a x == 1300
+	fmt.Println("granX:", granX()) // Ahora es falso.
+
+	// Es más las funciones literales se pueden definir y llamar en línea,
+	// actuando como un argumento para la función, siempre y cuando:
+	// a) la función literal sea llamada inmediatamente (),
+	// b) el tipo del resultado sea del tipo esperado del argumento
+	fmt.Println("Suma dos números + doble: ",
+		func(a, b int) int {
+			return (a + b) * 2
+		}(10, 2)) // Llamada con argumentos 10 y 2
+	// => Suma dos números + doble: 24
+
+	// Cuando lo necesites, te encantará.
+	goto encanto
+encanto:
+
+	aprendeFunciónFábrica() // func devolviendo func es divertido(3)(3)
+	aprendeADiferir()       // Un rápido desvío a una importante palabra clave.
+	aprendeInterfaces()     // ¡Buen material dentro de poco!
+}
+
+func aprendeFunciónFábrica() {
+	// Las dos siguientes son equivalentes, la segunda es más práctica
+	fmt.Println(instrucciónFábrica("día")("Un bello", "de verano"))
+
+	d := instrucciónFábrica("atardecer")
+	fmt.Println(d("Un hermoso", "de verano"))
+	fmt.Println(d("Un maravilloso", "de verano"))
+}
+
+// Los decoradores son comunes en otros lenguajes. Lo mismo se puede hacer
+// en Go con funciónes literales que aceptan argumentos.
+func instrucciónFábrica(micadena string) func(antes, después string) string {
+	return func(antes, después string) string {
+		return fmt.Sprintf("¡%s %s %s!", antes, micadena, después) // nueva cadena
+	}
+}
+
+func aprendeADiferir() (ok bool) {
+	// las instrucciones diferidas se ejecutan justo antes de que la
+	// función regrese.
+	defer fmt.Println("las instrucciones diferidas se ejecutan en orden inverso (PEPS).")
+	defer fmt.Println("\nEsta línea se imprime primero debido a que")
+	// Defer se usa comunmente para cerrar un fichero, por lo que la
+	// función que cierra el fichero se mantiene cerca de la función que lo
+	// abrió.
+	return true
+}
+
+// Define Stringer como un tipo interfaz con un método, String.
+type Stringer interface {
+	String() string
+}
+
+// Define par como una estructura con dos campos int, x e y.
+type par struct {
+	x, y int
+}
+
+// Define un método en el tipo par. Par ahora implementa a Stringer.
+func (p par) String() string { // p se conoce como el "receptor"
+	// Sprintf es otra función pública del paquete fmt.
+	// La sintaxis con punto se refiere a los campos de p.
+	return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func aprendeInterfaces() {
+	// La sintaxis de llaves es una "estructura literal". Evalúa a una
+	// estructura iniciada. La sintaxis := declara e inicia p a esta
+	// estructura.
+	p := par{3, 4}
+	fmt.Println(p.String()) // Llama al método String de p, de tipo par.
+	var i Stringer          // Declara i como interfaz de tipo Stringer.
+	i = p                   // Válido porque par implementa Stringer.
+	// Llama al metodo String de i, de tipo Stringer. Misma salida que
+	// arriba.
+	fmt.Println(i.String())
+
+	// Las funciones en el paquete fmt llaman al método String para
+	// consultar un objeto por una representación imprimible de si
+	// mismo.
+	fmt.Println(p) // Salida igual que arriba. Println llama al método
+				   // String.
+	fmt.Println(i) // Salida igual que arriba.
+	aprendeNúmeroVariableDeParámetros("¡gran", "aprendizaje", "aquí!")
+}
+
+// Las funciones pueden tener número variable de argumentos.
+func aprendeNúmeroVariableDeParámetros(misCadenas ...interface{}) {
+	// Itera en cada valor de los argumentos variables.
+	// El espacio en blanco aquí omite el índice del argumento arreglo.
+	for _, parámetro := range misCadenas {
+		fmt.Println("parámetro:", parámetro)
+	}
+
+	// Pasa el valor de múltiples variables como parámetro variadic.
+	fmt.Println("parámetros:", fmt.Sprintln(misCadenas...))
+	aprendeManejoDeError()
+}
+
+func aprendeManejoDeError() {
+	// ", ok" forma utilizada para saber si algo funcionó o no.
+	m := map[int]string{3: "tres", 4: "cuatro"}
+	if x, ok := m[1]; !ok { // ok será falso porque 1 no está en el mapa.
+		fmt.Println("nada allí")
+	} else {
+		fmt.Print(x) // x sería el valor, si estuviera en el mapa.
+	}
+	// Un valor de error comunica más información sobre el problema aparte
+	// de "ok".
+	if _, err := strconv.Atoi("no-int"); err != nil { // _ descarta el
+																	  // valor
+		// Imprime "strconv.ParseInt: parsing "no-int": invalid syntax".
+		fmt.Println(err)
+	}
+	// Revisaremos las interfaces más adelante. Mientras tanto...
+	aprendeConcurrencia()
+}
+
+// c es un canal, un objeto de comunicación concurrente seguro.
+func inc(i int, c chan int) {
+	c <- i + 1 // <- es el operador "enviar" cuando aparece un canal a la
+				  // izquierda.
+}
+
+// Utilizaremos inc para incrementar algunos números concurrentemente.
+func aprendeConcurrencia() {
+	// Misma función make utilizada antes para crear un sector. Make asigna
+	// e inicia sectores, mapas y canales.
+	c := make(chan int)
+	// Inicia tres rutinasgo concurrentes. Los números serán incrementados
+	// concurrentemente, quizás en paralelo si la máquina es capaz y está
+	// correctamente configurada. Las tres envían al mismo canal.
+	go inc(0, c) // go es una instrucción que inicia una nueva rutinago.
+	go inc(10, c)
+	go inc(-805, c)
+	// Lee los tres resultados del canal y los imprime.
+	// ¡No se puede saber en que orden llegarán los resultados!
+	fmt.Println(<-c, <-c, <-c) // Canal a la derecha, <- es el operador
+										// "recibe".
+
+	cs := make(chan string)       // Otro canal, este gestiona cadenas.
+	ccs := make(chan chan string) // Un canal de canales cadena.
+	go func() { c <- 84 }()       // Inicia una nueva rutinago solo para
+											// enviar un valor.
+	go func() { cs <- "verboso" }() // Otra vez, para cs en esta ocasión.
+	// Select tiene una sintáxis parecida a la instrucción switch pero cada
+	// caso involucra una operacion con un canal. Selecciona un caso de
+	// forma aleatoria de los casos que están listos para comunicarse.
+	select {
+	case i := <-c: // El valor recibido se puede asignar a una variable,
+		fmt.Printf("es un %T", i)
+	case <-cs:     // o el valor se puede descartar.
+		fmt.Println("es una cadena")
+	case <-ccs:    // Canal vacío, no está listo para la comunicación.
+		fmt.Println("no sucedió.")
+	}
+
+	// En este punto un valor fue devuelto de c o cs. Una de las dos
+	// rutinasgo que se iniciaron se ha completado, la otrá permancerá
+	// bloqueada.
+
+	aprendeProgramaciónWeb() // Go lo hace. Tú también quieres hacerlo.
+}
+
+// Una simple función del paquete http inicia un servidor web.
+func aprendeProgramaciónWeb() {
+// El primer parámetro es la direccinón TCP a la que escuchar.
+	// El segundo parámetro es una interfaz, concretamente http.Handler.
+	go func() {
+		err := http.ListenAndServe(":8080", par{})
+		fmt.Println(err) // no ignora errores
+	}()
+	consultaAlServidor()
+}
+
+// Hace un http.Handler de par implementando su único método, ServeHTTP.
+func (p par) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Sirve datos con un método de http.ResponseWriter.
+	w.Write([]byte("¡Aprendiste Go en Y minutos!"))
+}
+
+func consultaAlServidor() {
+	resp, err := http.Get("http://localhost:8080")
+	fmt.Println(err)
+	defer resp.Body.Close()
+	cuerpo, err := ioutil.ReadAll(resp.Body)
+	fmt.Printf("\nEl servidor web dijo: `%s`\n", string(cuerpo))
+}
+```
+
+## Más información
+
+La raíz de todas las cosas sobre Go es el
+[sitio web oficial de Go](http://golang.org/).
+Allí puedes seguir el tutorial, jugar interactivamente y leer mucho más.
+
+La definición del lenguaje es altamente recomendada.  Es fácil de leer y
+sorprendentemente corta (como la definición del lenguaje Go en estos
+días).
+
+Puedes jugar con el código en el
+[parque de diversiones Go](https://play.golang.org/p/ncRC2Zevag).  ¡Trata
+de cambiarlo y ejecutarlo desde tu navegador!  Ten en cuenta que puedes
+utilizar [https://play.golang.org]( https://play.golang.org) como un
+[REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) para probar
+cosas y el código en el navegador, sin ni siquiera instalar Go.
+
+En la lista de lecturas para estudiantes de Go está el
+[código fuente de la biblioteca estándar](http://golang.org/src/pkg/). 
+Ampliamente documentado, que demuestra lo mejor del legible y comprensible
+Go, con su característico estilo y modismos.  ¡O puedes hacer clic en un
+nombre de función en [la documentación](http://golang.org/pkg/) y
+aparecerá el código fuente!
+
+Otro gran recurso para aprender Go está en
+[Go con ejemplos](http://goconejemplos.com/).
diff --git a/es-es/haml-es.html.markdown b/es-es/haml-es.html.markdown
new file mode 100644
index 00000000..be90b8f3
--- /dev/null
+++ b/es-es/haml-es.html.markdown
@@ -0,0 +1,159 @@
+---
+language: haml
+filename: learnhaml-es.haml
+contributors:
+  - ["Simon Neveu", "https://github.com/sneveu"]
+translators:
+    - ["Camilo Garrido", "http://www.twitter.com/hirohope"]
+lang: es-es
+---
+
+Haml es un lenguage de marcas principalmente usado con Ruby, que de forma simple y limpia describe el HTML de cualquier documento web sin el uso de código en linea. Es una alternativa popular respecto a usar el lenguage de plantilla de Rails (.erb) y te permite embeber código Ruby en tus anotaciones.
+
+Apunta a reducir la repetición en tus anotaciones cerrando los tags por ti, basándose en la estructura de identación de tu código. El resultado es una anotación bien estructurada, que no se repite, lógica y fácil de leer.
+
+También puedes usar Haml en un proyecto independiente de Ruby, instalando la gema Haml en tu máquina y usando la línea de comandos para convertirlo en html.
+
+$ haml archivo_entrada.haml archivo_salida.html
+
+
+```haml
+/ -------------------------------------------
+/ Identación
+/ -------------------------------------------
+
+/
+  Por la importancia que la identación tiene en cómo tu código es traducido,
+  la identación debe ser consistente a través de todo el documento. Cualquier
+  diferencia en la identación lanzará un error. Es una práctica común usar dos
+  espacios, pero realmente depende de tí, mientras sea consistente.
+
+
+/ -------------------------------------------
+/ Comentarios
+/ -------------------------------------------
+
+/ Así es como un comentario se ve en Haml.
+
+/
+  Para escribir un comentario multilínea, identa tu código a comentar de tal forma
+  que sea envuelto por por una barra.
+
+
+-# Este es un comentario silencioso, significa que no será traducido al código en absoluto
+
+
+/ -------------------------------------------
+/ Elementos Html
+/ -------------------------------------------
+
+/ Para escribir tus tags, usa el signo de porcentaje seguido por el nombre del tag
+%body
+  %header
+    %nav
+
+/ Nota que no hay tags de cierre. El código anterior se traduciría como
+  <body>
+    <header>
+      <nav></nav>
+    </header>
+  </body>
+
+/ El tag div es un elemento por defecto, por lo que pueden ser escritos simplemente así
+.foo
+
+/ Para añadir contenido a un tag, añade el texto directamente después de la declaración
+%h1 Headline copy
+
+/ Para escribir contenido multilínea, anídalo.
+%p
+  Esto es mucho contenido que podríamos dividirlo en dos
+  líneas separadas.
+
+/
+  Puedes escapar html usando el signo ampersand y el signo igual ( &= ).
+  Esto convierte carácteres sensibles en html a su equivalente codificado en html.
+  Por ejemplo
+
+%p
+  &= "Sí & si"
+
+/ se traduciría en 'Sí &amp; si'
+
+/ Puedes desescapar html usando un signo de exclamación e igual ( != )
+%p
+  != "Así es como se escribe un tag párrafo <p></p>"
+
+/ se traduciría como 'Así es como se escribe un tag párrafo <p></p>'
+
+/ Clases CSS puedes ser añadidas a tus tags, ya sea encadenando .nombres-de-clases al tag
+%div.foo.bar
+
+/ o como parte de un hash Ruby
+%div{:class => 'foo bar'}
+
+/ Atributos para cualquier tag pueden ser añadidos en el hash
+%a{:href => '#', :class => 'bar', :title => 'Bar'}
+
+/ Para atributos booleanos asigna el valor verdadero 'true'
+%input{:selected => true}
+
+/ Para escribir atributos de datos, usa la llave :dato  con su valor como otro hash
+%div{:data => {:attribute => 'foo'}}
+
+
+/ -------------------------------------------
+/ Insertando Ruby
+/ -------------------------------------------
+
+/
+  Para producir un valor Ruby como contenido de un tag, usa un signo igual
+  seguido por código Ruby
+
+%h1= libro.nombre
+
+%p
+  = libro.autor
+  = libro.editor
+
+
+/ Para correr un poco de código Ruby sin traducirlo en html, usa un guión
+- libros = ['libro 1', 'libro 2', 'libro 3']
+
+/ Esto te permite hacer todo tipo de cosas asombrosas, como bloques de Ruby
+- libros.shuffle.each_with_index do |libro, indice|
+  %h1= libro
+
+  if libro do
+    %p Esto es un libro
+
+/
+  Nuevamente, no hay necesidad de añadir los tags de cerrado en el código, ni siquiera para Ruby
+  La identación se encargará de ello por tí.
+
+
+/ -------------------------------------------
+/ Ruby en linea / Interpolación de Ruby
+/ -------------------------------------------
+
+/ Incluye una variable Ruby en una línea de texto plano usando #{}
+%p Tu juego con puntaje más alto es #{mejor_juego}
+
+
+/ -------------------------------------------
+/ Filtros
+/ -------------------------------------------
+
+/
+  Usa un signo dos puntos para definir filtros Haml, un ejemplo de filtro que
+  puedes usar es :javascript, el cual puede ser usado para escribir javascript en línea.
+
+:javascript
+  console.log('Este es un <script> en linea');
+
+```
+
+## Recusros adicionales
+
+- [¿Qué es HAML? (en inglés)](http://haml.info/) - Una buena introducción que hace mejor el trabajo de explicar los beneficios de usar haml.
+- [Documentación Oficial (en inglés)](http://haml.info/docs/yardoc/file.REFERENCE.html) - Si deseas ir un poco más profundo.
diff --git a/es-es/java-es.html.markdown b/es-es/java-es.html.markdown
new file mode 100644
index 00000000..b34dca8d
--- /dev/null
+++ b/es-es/java-es.html.markdown
@@ -0,0 +1,410 @@
+---
+language: java
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+translators:
+    - ["Camilo Garrido", "http://www.twitter.com/hirohope"]
+lang: es-es
+filename: LearnJava-es.java
+---
+
+Java es un lenguage de programación de propósito general, concurrente, basado en clases y
+orientado a objetos.
+[Lee más aquí.](http://docs.oracle.com/javase/tutorial/java/index.html)
+
+```java
+// Comentarios de una sóla línea comienzan con //
+/*
+Comentarios multilínea lucen así
+*/
+/**
+Comentarios JavaDoc lucen así. Suelen describir la clase o varios atributos
+de una clase.
+*/
+
+// Importa la clase ArrayList dentro del paquete java.util
+import java.util.ArrayList;
+// Importa todas las clases dentro del paquete java.security
+import java.security.*;
+
+// Cada archivo .java contiene una clase pública, con el mismo nombre del archivo.
+public class AprendeJava {
+
+    // Un programa debe tener un método 'main' como punto de entrada
+    public static void main (String[] args) {
+
+        // Usa System.out.println para imprimir líneas
+        System.out.println("¡Hola mundo!");
+        System.out.println(
+            "Entero (int): " + 10 +
+            " Doble (double): " + 3.14 +
+            " Booleano (boolean): " + true);
+
+        // Para imprimir sin el salto de línea, usa System.out.print
+        System.out.print("Hola ");
+        System.out.print("Mundo");
+
+
+        ///////////////////////////////////////
+        // Tipos & Variables
+        ///////////////////////////////////////
+
+        // Declara una variable usando <tipo> <nombre> [
+        // Byte - Entero complemento a dos con signo de 8-bit
+        // (-128 <= byte <= 127)
+        byte fooByte = 100;
+
+        // Short - Entero complemento a dos con signo de 16-bit
+        // (-32,768 <= short <= 32,767)
+        short fooShort = 10000;
+
+        // Integer - Entero complemento a dos con signo de 32-bit
+        // (-2,147,483,648 <= int <= 2,147,483,647)
+        int fooInt = 1;
+
+        // Long - Entero complemento a dos con signo de 64-bit
+        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
+        long fooLong = 100000L;
+        // L es usado para denotar que el valor de esta variable es del tipo Long;
+        // cualquier cosa sin ella es tratado como un entero por defecto.
+
+        // Nota: Java no tiene tipos sin signo
+
+        // Float - Número de coma flotante IEEE 754 de precisión simple de 32-bit
+        float fooFloat = 234.5f;
+        // f es usado para denotar qeu el valor de esta variable es del tipo float;
+        // de otra manera es tratado como un double.
+
+        // Double - Número de coma flotante IEEE 754 de precisión doble de 64-bit
+        double fooDouble = 123.4;
+
+        // Boolean - true & false
+        boolean fooBoolean = true;
+        boolean barBoolean = false;
+
+        // Char - Un simple carácter unicode de 16-bit
+        char fooChar = 'A';
+
+        // Usa 'final' para hacer inmutable las variables
+        final int HORAS_QUE_TRABAJO_POR_SEMANA = 9001;
+
+        // Strings
+        String fooString = "¡Mi String está aquí!";
+
+        // \n es un carácter escapado que inicia una nueva línea
+        String barString = "¿Imprimiendo en una nueva linea?\n¡Ningun problema!";
+        // \t es un carácter escapado que añade un carácter tab
+        String bazString = "¿Quieres añadir un 'tab'?\t¡Ningun problema!";
+        System.out.println(fooString);
+        System.out.println(barString);
+        System.out.println(bazString);
+
+        // Arreglos
+        //El tamaño del arreglo debe decidirse en la declaración
+        //El formato para la declaración de un arreglo es la siguiente:
+        //<tipo_de_dato> [] <nombre_variable> = new <tipo_de_dato>[<tamaño_arreglo>];
+        int [] arreglo_de_enteros = new int[10];
+        String [] arreglo_de_strings = new String[1];
+        boolean [] arreglo_de_booleanos = new boolean[100];
+
+        // Otra forma de declarar & inicializar un arreglo
+        int [] y = {9000, 1000, 1337};
+
+        // Indexación de un arreglo - Accediendo un elemento
+        System.out.println("arreglo_de_enteros @ 0: " + arreglo_de_enteros[0]);
+
+        // Arreglos comienzan su indexación en cero y son mutables
+        arreglo_de_enteros[1] = 1;
+        System.out.println("arreglo_de_enteros @ 1: " + arreglo_de_enteros[1]); // => 1
+
+        // Otros para echar un vistazo
+        // ArrayLists - Son como arreglos excepto que ofrecen más funcionalidades
+        //              y el tamaño es mutable
+        // LinkedLists
+        // Maps
+        // HashMaps
+
+        ///////////////////////////////////////
+        // Operadores
+        ///////////////////////////////////////
+        System.out.println("\n->Operadores");
+
+        int i1 = 1, i2 = 2; // Abreviación para múltiples declaraciones
+
+        // La aritmética es directa
+        System.out.println("1+2 = " + (i1 + i2)); // => 3
+        System.out.println("2-1 = " + (i2 - i1)); // => 1
+        System.out.println("2*1 = " + (i2 * i1)); // => 2
+        System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 truncado)
+
+        // Módulo
+        System.out.println("11%3 = "+(11 % 3)); // => 2
+
+        // Operadores de comparación
+        System.out.println("3 == 2? " + (3 == 2)); // => false
+        System.out.println("3 != 2? " + (3 != 2)); // => true
+        System.out.println("3 > 2? " + (3 > 2)); // => true
+        System.out.println("3 < 2? " + (3 < 2)); // => false
+        System.out.println("2 <= 2? " + (2 <= 2)); // => true
+        System.out.println("2 >= 2? " + (2 >= 2)); // => true
+
+        // ¡Operaciones a nivel de bits!
+        /*
+        ~       Complemento unario bit a bit
+        <<      Deplazamiento hacia la izquierda con signo
+        >>      Deplazamiento hacia la derecha con signo
+        >>>     Deplazamiento hacia la derecha sin signo
+        &       AND lógico
+        ^       OR lógico exclusivo
+        |       OR lógico inclusivo
+        */
+
+        // Incrementos
+        int i = 0;
+        System.out.println("\n->Incrementos y reducciones");
+        System.out.println(i++); //i = 1. Post-incremento
+        System.out.println(++i); //i = 2. Pre-incremento
+        System.out.println(i--); //i = 1. Post-reducción
+        System.out.println(--i); //i = 0. Pre-reducción
+
+        ///////////////////////////////////////
+        // Estructuras de Control
+        ///////////////////////////////////////
+        System.out.println("\n->Estructuras de Control");
+
+        // Condiciones 'if' son como en c
+        int j = 10;
+        if (j == 10){
+            System.out.println("Me imprimieron");
+        } else if (j > 10) {
+            System.out.println("A mi no");
+        } else {
+            System.out.println("A mi tampoco");
+        }
+
+        // Ciclos 'while'
+        int fooWhile = 0;
+        while(fooWhile < 100)
+        {
+            //System.out.println(fooWhile);
+            //Incrementar el contador
+            //Iteró 99 veces, fooWhile 0->99
+            fooWhile++;
+        }
+        System.out.println("Valor fooWhile: " + fooWhile);
+
+        // Ciclos 'do while'
+        int fooDoWhile = 0;
+        do
+        {
+            //System.out.println(fooDoWhile);
+            //Incrementar el contador
+            //Iteró 99 veces, fooDoWhile 0->99
+            fooDoWhile++;
+        }while(fooDoWhile < 100);
+        System.out.println("Valor fooDoWhile: " + fooDoWhile);
+
+        // Ciclos 'for'
+        int fooFor;
+        //Estructura del ciclo 'for' => for(<declaración_de_inicio>; <condicional>; <paso>)
+        for(fooFor=0; fooFor<10; fooFor++){
+            //System.out.println(fooFor);
+            //Iteró 10 veces, fooFor 0->9
+        }
+        System.out.println("Valor fooFor: " + fooFor);
+
+        // Switch Case
+        // Un 'switch' funciona con un tipo de dato byte, short, char e int
+        // También funciona con tipos enumerados (discutido en tipos Enum),
+        // la clase String y unas pocas clases especiales que envuelven
+        // tipos primitivos: Character, Byte, Short e Integer.
+        int mes = 3;
+        String mesString;
+        switch (mes){
+            case 1:
+                    mesString = "Enero";
+                    break;
+            case 2:
+                    mesString = "Febrero";
+                    break;
+            case 3:
+                    mesString = "Marzo";
+                    break;
+            default:
+                    mesString = "Algun otro mes";
+                    break;
+        }
+        System.out.println("Resultado switch Case: " + mesString);
+
+
+        ///////////////////////////////////////
+        // Convirtiendo Tipos de Datos y Conversión de Tipos
+        ///////////////////////////////////////
+
+        // Convirtiendo datos
+
+        // Convertir String a Integer
+        Integer.parseInt("123");//retorna una versión entera de "123"
+
+        // Convertir Integer a String
+        Integer.toString(123);//retorna una versión string de 123
+
+        // Para otras conversiones fíjate en las siguientes clases
+        // Double
+        // Long
+        // String
+
+        // Conversión de tipos
+        // También puedes convertir objetos java, hay muchos detalles
+        // con unos pocos conceptos intermedios
+        // No dudes en verlos acá
+        // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html
+
+
+        ///////////////////////////////////////
+        // Clases y Funciones
+        ///////////////////////////////////////
+
+        System.out.println("\n->Clases & Funciones");
+
+        // (A continuación la definición de una clase Bicicleta)
+
+        // Usa 'new' para instanciar una clase
+        Bicicleta excursion = new Bicicleta();
+
+        // Llama métodos del objeto
+        excursion.aumentarVelocidad(3); // Siempre deberías usar metodos 'set' (establecer) y 'get' (obtener)
+        excursion.setRitmo(100);
+
+        // 'toString' es una convención para mostrar los valores de este objeto.
+        System.out.println("informacion de la excursion: " + excursion.toString());
+
+    } // Fin del método 'main'
+} // Fin de la clase AprendeJava
+
+
+// Puedes incluir otras clases no públicas en un archivo .java
+
+
+// Sintaxis de declaración de clases:
+// <public/private/protected> class <nombre_de_la_clase>{
+//    //variables_de_clase, constructores, todas las funciones.
+//    //las funciones son llamadas como métodos en Java.
+// }
+
+class Bicicleta {
+
+    // Campos/Variables de Bicicleta
+    public int ritmo; // Public: Puede ser accedido desde cualquier parte
+    private int velocidad;  // Private: Accesible sólo desde esta clase
+    protected int engranaje; // Protected: Accesible desde esta clases y sus subclases
+    String nombre; // default: Sólo accesible desde este paquete
+
+    // Constructores son la manera de crear clases
+    // Este es un constructor por defecto
+    public Bicicleta() {
+        engranaje = 1;
+        ritmo = 50;
+        velocidad = 5;
+        nombre = "Bontrager";
+    }
+
+    // Este es un constructor específico (contiene argumentos)
+    public Bicicleta(int ritmoInicial, int velocidadInicial, int engranajeInicial, String nombre) {
+        this.engranaje = engranajeInicial;
+        this.ritmo = ritmoInicial;
+        this.velocidad = velocidadInicial;
+        this.nombre = nombre;
+    }
+
+    // Sintaxis de función:
+    // <public/private/protected> <tipo_de_retorno> <nombre_funcion>(<argumentos>)
+
+    // Las clases de Java usualmente implementan métodos 'get' (obtener) y 'set' (establecer) para sus campos
+
+    // Sintaxis de declaración de métodos
+    // <alcance> <tipo_de_retorno> <nombre_metodo>(<argumentos>)
+    public int getRitmo() {
+        return ritmo;
+    }
+
+    // Métodos void no requieren retornar
+    public void setRitmo(int nuevoValor) {
+        ritmo = nuevoValor;
+    }
+
+    public void setEngranaje(int nuevoValor) {
+        engranaje = nuevoValor;
+    }
+
+    public void aumentarVelocidad(int incremento) {
+        velocidad += incremento;
+    }
+
+    public void disminuirVelocidad(int reduccion) {
+        velocidad -= reduccion;
+    }
+
+    public void setNombre(String nuevoNombre) {
+        nombre = nuevoNombre;
+    }
+
+    public String getNombre() {
+        return nombre;
+    }
+
+    //Método para mostrar los valores de los atributos de este objeto.
+    @Override
+    public String toString() {
+        return "engranaje: " + engranaje +
+                " ritmo: " + ritmo +
+                " velocidad: " + velocidad +
+                " nombre: " + nombre;
+    }
+} // fin clase Bicicleta
+
+// PennyFarthing es una subclase de Bicicleta
+class PennyFarthing extends Bicicleta {
+    // (Penny Farthings son esas bicicletas con una gran rueda forntal.
+    // No tienen engranajes.)
+
+    public PennyFarthing(int ritmoInicial, int velocidadInicial){
+        // Llama al constructor del padre con super
+        super(ritmoInicial, velocidadInicial, 0, "PennyFarthing");
+    }
+
+    // Deberías marcar un método que estás sobre escribiendo con una @anotacion
+    // Para aprender más sobre que son y el propósito de las anotaciones
+    // echa un vistazo acá: http://docs.oracle.com/javase/tutorial/java/annotations/
+    @Override
+    public void setEngranaje(int engranaje) {
+        engranaje = 0;
+    }
+
+}
+
+```
+
+## Más Lectura
+
+Estos links son sólo para tener un entendimiento del tema, no dudes en
+usar Google y encontrar ejemplos más específicos
+
+Otros temas a investigar:
+
+* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)
+
+* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)
+
+* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
+    * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
+    * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
+    * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)
+
+* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)
+
+* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)
+
+* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)
+
+* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html)
diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
new file mode 100644
index 00000000..036d7082
--- /dev/null
+++ b/es-es/javascript-es.html.markdown
@@ -0,0 +1,528 @@
+---
+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, aunque: Node.js, Un proyecto que proporciona un entorno de ejecución independiente para el motor V8 de Google Chrome, se está volviendo más y más popular.
+
+¡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
+0.1 + 0.2; // = 0.30000000000000004
+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
+null == undefined; // = true
+
+// ...a menos que uses ===
+"5" === 5; // = false
+null === undefined; // 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, Arrays 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
+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.
+}
+
+// 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
new file mode 100644
index 00000000..e4181609
--- /dev/null
+++ b/es-es/julia-es.html.markdown
@@ -0,0 +1,940 @@
+---
+language: Julia
+contributors:
+    - ["Leah Hanson", "http://leahhanson.us"]
+translators:
+    - ["Guillermo Garza", "http://github.com/ggarza"]
+    - ["Ismael Venegas Castelló", "https://github.com/Ismael-VC"]
+filename: learnjulia-es.jl
+lang: es-es
+---
+
+![JuliaLang](http://s13.postimg.org/z89djuwyf/julia_small.png)
+
+[Julia](http://julialanges.github.io) es un [lenguaje de programación](http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n) [multiplataforma](http://es.wikipedia.org/wiki/Multiplataforma) y [multiparadigma](http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_multiparadigma) de [tipado dinámico](http://es.wikipedia.org/wiki/Tipado_din%C3%A1mico), [alto nivel](http://es.wikipedia.org/wiki/Lenguaje_de_alto_nivel) y [alto desempeño](http://es.wikipedia.org/wiki/Computaci%C3%B3n_de_alto_rendimiento) para la computación [genérica](http://es.wikipedia.org/wiki/Lenguaje_de_programaci%C3%B3n_de_prop%C3%B3sito_general), [técnica y científica](http://es.wikipedia.org/wiki/Computaci%C3%B3n_cient%C3%ADfica),  con una sintaxis que es familiar para los usuarios de otros entornos de computación técnica y científica. Provee de un [sofisticado compilador JIT](http://es.wikipedia.org/wiki/Compilaci%C3%B3n_en_tiempo_de_ejecuci%C3%B3n), [ejecución distribuida y paralela](http://docs.julialang.org/en/release-0.3/manual/parallel-computing), [precisión numérica](http://julia.readthedocs.org/en/latest/manual/integers-and-floating-point-numbers) y de una [extensa librería con funciones matemáticas](http://docs.julialang.org/en/release-0.3/stdlib). La librería estándar, escrita casi completamente en Julia, también integra las mejores y más maduras librerías de C y Fortran para el [álgebra lineal](http://docs.julialang.org/en/release-0.3/stdlib/linalg), [generación de números aleatorios](http://docs.julialang.org/en/release-0.3/stdlib/numbers/?highlight=random#random-numbers), [procesamiento de señales](http://docs.julialang.org/en/release-0.3/stdlib/math/?highlight=signal#signal-processing), y [procesamiento de cadenas](http://docs.julialang.org/en/release-0.3/stdlib/strings). Adicionalmente, la comunidad de [desarrolladores de Julia](https://github.com/JuliaLang/julia/graphs/contributors) contribuye un número de [paquetes externos](http://pkg.julialang.org) a través del gestor de paquetes integrado de Julia a un paso acelerado. [IJulia](https://github.com/JuliaLang/IJulia.jl), una colaboración entre las comunidades de [IPython](http://ipython.org) y Julia, provee de una poderosa interfaz gráfica basada en el [navegador para Julia](https://juliabox.org).
+
+En Julia los programas están organizados entorno al [despacho múltiple](http://docs.julialang.org/en/release-0.3/manual/methods/#man-methods); definiendo funciones y sobrecargándolas para diferentes combinaciones de tipos de argumentos, los cuales también pueden ser definidos por el usuario.
+
+### ¡Prueba Julia ahora mismo!
+
+* [TryJupyter](https://try.jupyter.org)
+* [JuliaBox](https://juliabox.org)
+* [SageMathCloud](https://cloud.sagemath.com)
+
+### Resumen de Características:
+
+* [Despacho múltiple](http://en.wikipedia.org/wiki/Multiple_dispatch): permite definir el comportamiento de las funciones a través de múltiples combinaciones de tipos de argumentos (**métodos**).
+* Sistema de **tipado dinámico**: tipos para la documentación, la optimización y el despacho.
+* [Buen desempeño](http://julialang.org/benchmarks), comparado al de lenguajes **estáticamente compilados** como C.
+* [Gestor de paquetes](http://docs.julialang.org/en/release-0.3/stdlib/pkg) integrado.
+* [Macros tipo Lisp](http://docs.julialang.org/en/release-0.3/manual/metaprogramming/#macros) y otras comodidades para la [meta programación](http://docs.julialang.org/en/release-0.3/manual/metaprogramming).
+* Llamar funciones de otros lenguajes, mediante paquetes como: **Python** ([PyCall](https://github.com/stevengj/PyCall.jl)), [Mathematica](http://github.com/one-more-minute/Mathematica.jl), **Java** ([JavaCall](http://github.com/aviks/JavaCall.jl)), **R** ([Rif](http://github.com/lgautier/Rif.jl) y [RCall](http://github.com/JuliaStats/RCall.jl)) y **Matlab** ([MATLAB](http://github.com/JuliaLang/MATLAB.jl)).
+* [Llamar funciones de C y Fortran](http://docs.julialang.org/en/release-0.3/manual/calling-c-and-fortran-code) **directamente**: sin necesidad de usar envoltorios u APIs especiales.
+* Poderosas características de **línea de comandos** para [gestionar otros procesos](http://docs.julialang.org/en/release-0.3/manual/running-external-programs).
+* Diseñado para la [computación paralela y distribuida](http://docs.julialang.org/en/release-0.3/manual/parallel-computing) **desde el principio**.
+* [Corrutinas](http://en.wikipedia.org/wiki/Coroutine): hilos ligeros "**verdes**".
+* Los [tipos definidos por el usuario](http://docs.julialang.org/en/release-0.3/manual/types) son tan **rápidos y compactos** como los tipos estándar integrados.
+* [Generación automática de código](http://docs.julialang.org/en/release-0.3/stdlib/base/?highlight=%40code#internals) **eficiente y especializado** para diferentes tipos de argumentos.
+* [Conversiones y promociones](http://docs.julialang.org/en/release-0.3/manual/conversion-and-promotion) para tipos numéricos y de otros tipos, **elegantes y extensibles**.
+* Soporte eficiente para [Unicode](http://es.wikipedia.org/wiki/Unicode), incluyendo [UTF-8](http://es.wikipedia.org/wiki/UTF-8) pero sin limitarse solo a este.
+* [Licencia MIT](https://github.com/JuliaLang/julia/blob/master/LICENSE.md): libre y de código abierto.
+
+Esto se basa en la versión `0.3.11`.
+
+```ruby
+# Los comentarios de una línea comienzan con una almohadilla (o signo de gato).
+
+#=
+  Los comentarios multilínea pueden escribirse
+  usando '#=' antes de el texto  y '=#'
+  después del texto. También se pueden anidar.
+=#
+
+
+##############################################
+# 1. Tipos de datos primitivos y operadores. #
+##############################################
+
+# Todo en Julia es una expresión (Expr).
+
+# Hay varios tipos básicos de números.
+3          # => 3          # Int64
+3.2        # => 3.2        # Float64
+2 + 1im    # => 2 + 1im    # Complex{Int64}
+2 // 3     # => 2//3       # Rational{Int64}
+
+# Todos los operadores infijos normales están disponibles.
+1 + 1        # => 2
+8 - 1        # => 7
+10 * 2       # => 20
+35 / 5       # => 7.0    # dividir un Int por un Int siempre resulta
+                         # en un Float
+5 / 2        # => 2.5
+div(5, 2)    # => 2      # para un resultado truncado, usa la función div
+5 \ 35       # => 7.0
+2 ^ 2        # => 4      # exponente, no es XOR
+12 % 10      # => 2
+
+# Refuerza la precedencia con paréntesis.
+(1 + 3) * 2    # => 8
+
+# Operadores a nivel de bit.
+~2         # => -3    # bitwise NOT
+3 & 5      # => 1     # bitwise AND
+2 | 4      # => 6     # bitwise OR
+2 $ 4      # => 6     # bitwise XOR
+2 >>> 1    # => 1     # desplazamiento lógico hacia la derecha
+2 >> 1     # => 1     # desplazamiento aritmético hacia la derecha
+2 << 1     # => 4     # desplazamiento lógico/aritmético hacia la izquierda
+
+# Se puede utilizar la función bits para ver la representación
+# binaria de un número.
+bits(12345)
+# => "0000000000000000000000000000000000000000000000000011000000111001"
+
+bits(12345.0)
+# => "0100000011001000000111001000000000000000000000000000000000000000"
+
+# Los valores booleanos (Bool) son primitivos.
+true     # => true
+false    # => false
+
+# Operadores booleanos.
+!true     # => false
+!false    # => true
+1 == 1    # => true
+2 == 1    # => false
+1 != 1    # => false
+2 != 1    # => true
+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
+
+# Los literales de cadenas (String) se crean con la comilla doble: "
+"Esto es una cadena."
+
+# Los literales de caracteres (Char) se crean con la comilla simple: '
+'a'
+
+# Una cadena puede ser indexada como una arreglo de caracteres.
+"Esto es un string."[1]    # => 'E'    # Los índices en Julia comienzan en: 1
+
+# Sin embargo, esto no va a funcionar bien para las cadenas UTF8 (UTF8String),
+# Lo que se recomienda es la iteración (map, for, etc).
+
+# $ puede ser utilizado para la interpolación de cadenas, se puede poner
+# cualquier expresión de Julia dentro los paréntesis.
+"2 + 2 = $(2 + 2)"    # => "2 + 2 = 4"
+
+# Otra forma para formatear cadenas es usando el macro printf.
+@printf "%d es menor de %f\n" 4.5 5.3    # 5 es menor de 5.300000
+
+# ¡Imprimir es muy fácil!
+println("¡Hola Julia!")    # ¡Hola Julia!
+
+
+##############################
+# 2. Variables y Colecciones #
+##############################
+
+# No hay necesidad de declarar las variables antes de asignarlas.
+una_variable = 5    # => 5
+una_variable        # => 5
+
+# Acceder a una variable no asignada previamente es una excepción.
+try
+    otra_variable    # ERROR: otra_variable not defined
+catch e
+    println(e)       # UndefVarError(:otra_variable)
+end
+
+# Los nombres de variables comienzan con una letra o guion bajo: _.
+# Después de eso, puedes utilizar letras, dígitos, guiones bajos y signos de
+# exclamación.
+otraVariable_123! = 6    # => 6
+
+# También puedes utilizar caracteres Unicode.
+☃ = 8    # => 8
+
+# Estos son especialmente útiles para la notación matemática
+# (multiplicación implicita).
+2π    # => 6.283185307179586
+
+#=
+  Una nota sobre las convenciones de nomenclatura de Julia:
+
+  * Los nombres de las variables aparecen en minúsculas, con separación de
+    palabra indicado por un guion bajo:
+
+    otra_variable
+
+  * Los nombres de los tipos comienzan con una letra mayúscula y separación de
+    palabras se muestra con CamelCase en vez de guión bajo:
+
+    OtroTipo
+
+  * Los nombres de las funciones y los macros están en minúsculas, sin
+    underscore:
+
+    otromacro
+
+  * Funciones que modifican sus entradas tienen nombres que terminan en: !.
+    Estas funciones a veces se les llaman funciones transformadoras o
+    funciones in situ:
+
+    otra_funcion!
+=#
+
+# Los arreglos (Array) almacenan una secuencia de valores indexados de entre 1 hasta n.
+a = Int64[]    # => 0-element Array{Int64,1}
+
+# Los literales de arregos unidimensionales se pueden escribir con valores
+# separados por comas.
+b = [4, 5, 6]
+#=
+ => 3-element Array{Int64,1}:
+     4
+     5
+     6
+=#
+b[1]      # => 4
+b[end]    # => 6
+
+# Los arreglos bidimensionales usan valores separados por espacios y filas
+# separadas por punto y coma.
+matrix = [1 2; 3 4]
+#=
+ => 2x2 Array{Int64,2}:
+     1  2
+     3  4
+=#
+
+# Añadir cosas al final de un arreglo con push! y append!.
+push!(a, 1)      # => [1]
+push!(a, 2)      # => [1,2]
+push!(a, 4)      # => [1,2,4]
+push!(a, 3)      # => [1,2,4,3]
+append!(a, b)    # => [1,2,4,3,4,5,6]
+
+# Eliminar del final con pop!.
+pop!(b)    # => 6 y b ahora es: [4,5]
+
+# Vamos a ponerlo de nuevo.
+push!(b, 6)    # b es ahora [4,5,6] de nuevo
+
+a[1]    # => 1    # recuerda, los índices de Julia empiezan desde 1, no desde 0!
+
+# end es una abreviatura para el último índice. Se puede utilizar en cualquier
+# expresión  de indexación.
+a[end]    # => 6
+
+# También hay shift! y unshift!.
+shift!(a)         # => 1 y a es ahora: [2,4,3,4,5,6]
+unshift!(a, 7)    # => [7,2,4,3,4,5,6]
+
+# Los nombres de funciones que terminan en exclamaciones indican que modifican
+# su o sus argumentos de entrada.
+arr = [5, 4, 6]    # => 3-element Array{Int64,1}: [5,4,6]
+sort(arr)          # => [4,5,6] y arr es todavía: [5,4,6]
+sort!(arr)         # => [4,5,6] y arr es ahora: [4,5,6]
+
+# Buscando fuera de límites es un BoundsError.
+try
+    a[0]          # ERROR: BoundsError() in getindex at array.jl:270
+    a[end+1]      # ERROR: BoundsError() in getindex at array.jl:270
+catch e
+    println(e)    # BoundsError()
+end
+
+# Las excepciones y los errores dan la línea y el archivo de su procedencia,
+# aunque provenga de la librería estándar. Si compilas Julia del código fuente,
+# puedes buscar en el código para encontrar estos archivos.
+
+# Se puede inicializar un arreglo con un rango (Range).
+a = [1:5]    # => 5-element Array{Int64,1}: [1,2,3,4,5]
+
+# Puedes mirar en los rangos con la sintaxis de rebanada.
+a[1:3]       # => [1,2,3]
+a[2:end]     # => [2,3,4,5]
+
+# Eliminar elementos de un arreglo por índice con splice!
+arr = [3, 4, 5]
+splice!(arr, 2)    # => 4 y arr es ahora: [3,5]
+
+# Concatenar arreglos con append!
+b = [1, 2, 3]
+append!(a, b)    # a ahora es: [1,2,3,4,5,1,2,3]
+
+# Comprueba la existencia de un elemento en un arreglo con in.
+in(1, a)    # => true
+
+# Examina la longitud con length.
+length(a)    # => 8
+
+# Las tuplas (Tuple) son inmutables.
+tup = (1, 2, 3)    # => (1,2,3)    # una tupla tipo (Int64,Int64,Int64)
+tup[1]             # => 1
+
+try:
+    tup[1] = 3     # ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
+catch e
+    println(e)     # MethodError(setindex!,(:tup,3,1))
+end
+
+# Muchas funciones de arreglos también trabajan en con las tuplas.
+length(tup)    # => 3
+tup[1:2]       # => (1,2)
+in(2, tup)     # => true
+
+# Se pueden desempacar las tuplas en variables individuales.
+a, b, c = (1, 2, 3)    # => (1,2,3)    # ahora a es 1, b es 2 y c es 3
+
+# Los tuplas se crean, incluso si se omiten los paréntesis.
+d, e, f = 4, 5, 6    # => (4,5,6)
+
+# Una tupla de un elemento es distinta del valor que contiene.
+(1,) == 1    # => false
+(1) == 1     # => true
+
+# Mira que fácil es cambiar dos valores!
+e, d = d, e    # => (5,4)    # ahora d es 5 y e es 4
+
+# Los diccionarios (Dict) son arreglos asociativos.
+dicc_vacio = Dict()    # => Dict{Any,Any} with 0 entries
+
+# Se puede crear un diccionario usando una literal.
+dicc_lleno = ["uno" => 1, "dos" => 2, "tres" => 3]
+#=
+ => Dict{ASCIIString,Int64} with 3 entries:
+      "tres" => 3
+      "dos"  => 2
+      "uno"  => 1
+=#
+
+# Busca valores con: [].
+dicc_lleno["uno"]    # => 1
+
+# Obtén todas las claves con.
+keys(dicc_lleno)
+#=
+ => KeyIterator for a Dict{ASCIIString,Int64} with 3 entries. Keys:
+      "tres"
+      "dos"
+      "uno"
+=#
+
+# Nota: los elementos del diccionario no están ordenados y no se guarda el orden
+# en que se insertan.
+
+# Obtén todos los valores.
+values(dicc_lleno)
+#=
+ => ValueIterator for a Dict{ASCIIString,Int64} with 3 entries. Values:
+      3
+      2
+      1
+=#
+
+# Nota: igual que el anterior en cuanto a ordenamiento de los elementos.
+
+# Comprueba si una clave existe en un diccionario con in y haskey.
+in(("uno", 1), dicc_lleno)     # => true
+in(("tres", 3), dicc_lleno)    # => false
+
+haskey(dicc_lleno, "uno")      # => true
+haskey(dicc_lleno, 1)          # => false
+
+# Tratar de obtener un valor con una clave que no existe producirá un error.
+try
+    # ERROR: key not found: cuatro in getindex at dict.jl:489
+    dicc_lleno["cuatro"]
+catch e
+    println(e)    # KeyError("cuatro")
+end
+
+# Utiliza el método get para evitar este error proporcionando un valor
+# predeterminado: get(diccionario, clave, valor_predeterminado).
+get(dicc_lleno, "uno", 4)       # => 1
+get(dicc_lleno, "cuatro", 4)    # => 4
+
+# Usa conjuntos (Set) para representar colecciones de valores únicos, no
+# ordenados.
+conjunto_vacio = Set()    # => Set{Any}({})
+
+# Iniciar una conjunto de valores.
+conjunto_lleno = Set(1, 2, 2, 3, 4)    # => Set{Int64}({4,2,3,1})
+
+# Añadir más valores a un conjunto.
+push!(conjunto_lleno, 5)    # => Set{Int64}({4,2,3,5,1})
+push!(conjunto_lleno, 5)    # => Set{Int64}({4,2,3,5,1})
+
+# Comprobar si los valores están en el conjunto.
+in(2, conjunto_lleno)     # => true
+in(10, conjunto_lleno)    # => false
+
+# Hay funciones de intersección, unión y diferencia de conjuntos.
+otro_conjunto = Set(3, 4, 5, 6)             # => Set{Int64}({6,4,5,3})
+intersect(conjunto_lleno, otro_conjunto)    # => Set{Int64}({3,4,5})
+union(conjunto_lleno, otro_conjunto)        # => Set{Int64}({1,2,3,4,5,6})
+setdiff(Set(1, 2, 3, 4), Set(2, 3, 5))      # => Set{Int64}({1,4})
+
+
+#######################
+# 3. Control de Flujo #
+#######################
+
+# Hagamos una variable.
+una_variable = 5
+
+# Aquí está la declaración de un if. La indentación no es significativa en
+# Julia.
+if una_variable > 10
+    println("una_variable es completamente mayor que 10.")
+elseif una_variable < 10                     # esta condición elseif es opcional
+    println("una_variable es menor que 10.")
+else                                         # esto también es opcional
+    println("De echo una_variable es 10.")
+end
+# imprime: una_variable es menor que 10.
+
+# El bucle for itera sobre tipos iterables, ie. Range, Array, Set,
+# Dict y String.
+for animal in ["perro", "gato", "ratón"]
+    # Se puede usar $ para interpolar variables o expresiones en ls cadenas.
+    println("$animal es un mamífero.")
+end
+#=
+ imprime:
+   perro es un mamífero.
+   gato es un mamífero.
+   ratón es un mamífero.
+=#
+
+for a in ["perro" => "mamífero", "gato" => "mamífero", "ratón" => "mamífero"]
+    println("$(a[1]) es un $(a[2]).")
+end
+#=
+ imprime:
+   perro es un mamífero.
+   gato es un mamífero.
+   ratón es un mamífero.
+=#
+
+for (k,v) in ["perro"=>"mamífero", "gato"=>"mamífero", "ratón"=>"mamífero"]
+    println("$k es un $v.")
+end
+#=
+ imprime:
+   perro es un mamífero.
+   gato es un mamífero.
+   ratón es un mamífero.
+=#
+
+# El bucle while itera hasta que una condición se deje de cumplir.
+x = 0
+while x < 4
+    println(x)
+    x += 1    # versión corta de: x = x + 1
+end
+#=
+imprime:
+  0
+  1
+  2
+  3
+=#
+
+# Maneja excepciones con un bloque try/catch.
+try    # intentar
+   error("Ooops!")
+catch e
+   println("capturando: $e")    # capturando: ErrorException("Ooops!")
+end
+
+
+################
+# 4. Funciones #
+################
+
+# Usa function para crear nuevas funciones.
+
+#=
+    function nombre(arglist)
+        cuerpo...
+    end
+=#
+function suma(x, y)
+    println("x es $x e y es $y")
+
+    # las funciones devuelven el valor de su última expresión
+    x + y
+end
+# => suma (generic function with 1 method)
+
+suma(5, 6)    # => 11    # después de imprimir: x es 5 e y es 6
+
+# También puedes usar esta otra sintaxis para definir funciones!
+resta(x, y) = x - y    # => resta (generic function with 1 method)
+
+# Puedes definir funciones que toman un número variable de
+# argumentos posicionales (el ... se llama un splat).
+function varargs(args...)
+    # Usa la palabra clave return para regresar desde cualquier
+    # lugar de la función.
+    return args
+end
+# => varargs (generic function with 1 method)
+
+varargs(1, 2, 3)      # => (1,2,3)
+varargs([1, 2, 3])    # => ([1,2,3],)
+
+# Acabamos de utilizar el splat (...) en la definición de una función. También
+# se puede utilizar al llamar a una función, donde se esparce un arreglo, tupla
+# o en general una secuencia iterable en la tupla de argumentos.
+varargs([1, 2, 3]...)    # => (1,2,3)    # igual que: varargs(1, 2, 3)
+
+x = (1, 2, 3)    # => (1,2,3)
+varargs(x)       # => ((1,2,3),)
+varargs(x...)    # => (1,2,3)
+
+varargs("abc"...)    # => ('a','b','c')
+
+# Puedes definir funciones con argumentos posicionales opcionales.
+function defaults(a, b, x=5, y=6)
+    return "$a $b y $x $y"
+end
+# => defaults (generic function with 3 methods)
+
+defaults('h', 'g')              # => "h g y 5 6"
+defaults('h', 'g', 'j')         # => "h g y j 6"
+defaults('h', 'g', 'j', 'k')    # => "h g y j k"
+
+try
+    defaults('h')    # ERROR: `defaults` has no method matching defaults(::Char)
+    defaults()       # ERROR: `defaults` has no method matching defaults()
+catch e
+    println(e)       # MethodError(defaults,('h',))
+end
+
+# Puedes definir funciones que tomen argumentos de palabras clave.
+function args_clave(;k1=4, nombre2="hola")    # nota el punto y coma: ;
+    return ["k1" => k1, "nombre2" => nombre2]
+end
+# => args_clave (generic function with 1 method)
+
+args_clave(nombre2="ness")    # => ["nombre2"=>"ness","k1"=>4]
+args_clave(k1="mine")         # => ["k1"=>"mine","nombre2"=>"hola"]
+args_clave()                  # => ["nombre2"=>"hola","k1"=>4]
+
+# Puedes combinar todo tipo de argumentos en la misma función.
+function todos_los_args(arg_posicional, arg_opcional=2; arg_clave="foo")
+    println("argumento posicional: $arg_posicional")
+    println("  argumento opcional: $arg_opcional")
+    println("     argumento clave: $arg_clave")
+end
+# => todos_los_args (generic function with 2 methods)
+
+# No se necesita punto y coma ; al llamar la función usando un argumento clave,
+# esto solo es necesario en la definición de la función.
+todos_los_args(1, 3, arg_clave=4)
+#=
+ imprime:
+   argumento posicional: 1
+     argumento opcional: 3
+        argumento clave: 4
+=#
+
+# Julia tiene funciones de primera clase.
+function crear_suma(x)
+    suma = function (y)    # función anónima
+        return x + y
+    end
+    return suma
+end
+# => crear_suma (generic function with 1 method)
+
+# Esta es otra sintaxis (estilo cálculo lambda), para crear funciones anónimas.
+(x -> x > 2)(3)    # => true
+
+# Esta función es idéntica a la crear_suma implementación anterior.
+crear_suma(x) = y -> x + y
+
+# También puedes nombrar la función interna, si quieres.
+function crear_suma(x)
+    function suma(y)
+        x + y
+    end
+    suma
+end
+# => crear_suma (generic function with 1 method)
+
+suma_10 = crear_suma(10)    # => suma (generic function with 1 method)
+suma_10(3)                  # => 13
+
+# Hay funciones integradas de orden superior.
+map(suma_10, [1, 2, 3])                # => [11,12,13]
+filter(x -> x > 5, [3, 4, 5, 6, 7])    # => [6,7]
+
+# Se puede pasar un bloque a las funciones cuyo primer argumento posicional
+# es otra función, como en map y filter.
+map([1, 2, 3]) do arr
+    suma_10(arr)
+end
+#=
+ => 3-element Array{Int64,1}:
+     11
+     12
+     13
+=#
+
+filter([3, 4, 5, 6, 7]) do arr
+    (x -> x > 5)(arr)
+end
+#=
+ => 2-element Array{Int64,1}:
+     6
+     7
+=#
+
+# Podemos usar comprensiones de listas multidimensionales.
+[suma_10(i) for i = [1, 2, 3]]     # => [11, 12, 13]    # 1D
+[suma_10(i) for i in [1, 2, 3]]    # => [11, 12, 13]
+
+[i*j for i = [1:3], j in [1:3]]    # 2D
+#=
+ => 3x3 Array{Int64,2}:
+     1  2  3
+     2  4  6
+     3  6  9
+=#
+
+[i*j/k for i = [1:3], j = [1:3], k in [1:3]]    # 3D
+#=
+ => 3x3x3 Array{Float64,3}:
+     [:, :, 1] =
+      1.0  2.0  3.0
+      2.0  4.0  6.0
+      3.0  6.0  9.0
+
+     [:, :, 2] =
+      0.5  1.0  1.5
+      1.0  2.0  3.0
+      1.5  3.0  4.5
+
+     [:, :, 3] =
+      0.333333  0.666667  1.0
+      0.666667  1.33333   2.0
+      1.0       2.0       3.0
+=#
+
+
+############
+# 5. Tipos #
+############
+
+# Cada valor tiene un tipo y las variables no tienen propios tipos.
+# Se puede utilizar la función typeof para obtener el tipo de un valor.
+typeof(5)    # => Int64    # en un sistema de 64 bits, de lo contrario: Int32
+
+# Los tipos son valores de primera clase, DataType es el tipo que representa a
+# los tipos, incluyéndose a sí mismo.
+typeof(Int64)       # => DataType
+typeof(DataType)    # => DataType
+
+# Los tipos se usan para la documentación, para optimizaciones
+# y el despacho múltiple. No están comprobados estáticamente.
+
+# Los usuarios pueden definir sus propios tipos.
+# Son como registros o estructuras en otros idiomas.
+# Un nuevo tipos se define utilizado la palabra clave type.
+
+# type Nombre
+#   atributo::UnTipo    # las anotaciones de tipos son opcionales
+#   ...
+# end
+type Tigre
+    longitud_cola::Float64
+    color_pelaje            # sin una anotación de tipo, es lo mismo que `::Any`
+end
+
+# Los argumentos del constructor por defecto son los atributos
+# del tipo, en el orden en que están listados en la definición.
+tigre = Tigre(3.5, "anaranjado")    # => Tigre(3.5,"anaranjado")
+
+# El tipo funciona como método constructor para los valores de ese tipo.
+sherekhan = typeof(tigre)(5.6, "fuego")    # => Tigre(5.6,"fuego")
+
+
+# Este estilo de tipos son llamados tipos concretos.
+# Se pueden crear instancias de estos, pero no pueden tener subtipos.
+# La otra clase de tipos son los tipos abstractos.
+
+# abstract Nombre
+abstract Gato    # sólo un nombre y un punto en la jerarquía de tipos
+
+# No se pueden crear instancias de los tipos abstractos, pero pueden tener
+# subtipos. Por ejemplo, Number es un tipo abstracto.
+subtypes(Number)
+#=
+ => 2-element Array{Any,1}:
+     Complex{T<:Real}
+     Real
+=#
+
+subtypes(Gato)    # => 0-element Array{Any,1}
+
+# Cada tipo tiene un supertipo, utiliza la función súper para conseguirlo.
+typeof(5)               # => Int64
+super(Int64)            # => Signed
+super(Signed)           # => Integer
+super(Integer)          # => Real
+super(Real)             # => Number
+super(Number)           # => Any
+super(super(Signed))    # => Real
+super(Any)              # => Any
+
+# Todos estos tipos, a excepción de Int64, son abstractos.
+
+# <: es el operador de subtipos.
+type Leon <: Gato    # Leon es un subtipo de Gato
+    color_crin
+    rugido::String
+end
+
+# Se pueden definir más constructores para un tipo.
+# Sólo define una función del mismo nombre que el tipo y llama al constructor
+# existente para obtener un valor del tipo correcto.
+
+# Este es un constructor externo porque está fuera de la definición del tipo.
+Leon(rugido::String) = Leon("verde", rugido)
+
+type Pantera <: Gato    # Pantera también es un a subtipo de Gato
+    color_ojos
+
+    # Pantera sólo tendrá este constructor, y ningún constructor predeterminado.
+    Pantera() = new("verde")
+end
+
+# Utilizar constructores internos, como se hace en Pantera, te da control sobre
+# cómo se pueden crear valores de este tipo. Cuando sea posible, debes utilizar
+# constructores externos en lugar de internos.
+
+
+########################
+# 6. Despacho Múltiple #
+########################
+
+# En Julia, todas las funciones nombradas son funciones genéricas.
+# Esto significa que se construyen a partir de muchos métodos más pequeños.
+# Cada constructor de Leon es un método de la función genérica Leon.
+
+# Por ejemplo, vamos a hacer métodos para Leon, Pantera, y Tigre de una
+# función genérica maullar:
+
+# acceso utilizando notación de puntos
+maullar(animal::Leon) = animal.rugido
+# => maullar (generic function with 1 method)
+maullar(animal::Pantera) = "grrr"
+# => maullar (generic function with 2 methods)
+maullar(animal::Tigre) = "rawwwr"
+# => maullar (generic function with 3 methods)
+
+# Se puede obtener una lista de métodos con la función methods.
+methods(maullar)
+#=
+  # 3 methods for generic function "maullar":
+  maullar(animal::Leon) at none:1
+  maullar(animal::Pantera) at none:1
+  maullar(animal::Tigre) at none:1
+=#
+
+# Prueba de la función maullar.
+maullar(tigre)                    # => "rawwwr"
+maullar(Leon("cafe", "ROAAR"))    # => "ROAAR"
+maullar(Pantera())                # => "grrr"
+
+# Revisar la jerarquía de tipos locales.
+issubtype(Tigre, Gato)      # => false    # igual que: Tigre <: Gato
+issubtype(Leon, Gato)       # => true     # igual que: Leon <: Gato
+issubtype(Pantera, Gato)    # => true
+
+# Definición de una función que acepta argumentos de tipo Gato.
+mascota(gato::Gato) = println("El gato dice $(maullar(gato))")
+
+mascota(Leon("42"))    # El gato dice 42
+
+try
+    mascota(tigre)    # ERROR: `mascota` has no method matching mascota(::Tigre)
+catch e
+    println(e)        # MethodError(mascota,(Tigre(3.5,"anaranjado"),))
+end
+
+# En los lenguajes orientados a objetos, el despacho simple es común. Esto
+# significa que la implementación del método a llamar se selecciona en base
+# al tipo del primer argumento.
+
+# En Julia, los tipos de todos los argumentos contribuyen a seleccionar método
+# más específico.
+
+# Vamos a definir una función con más argumentos, para que podamos ver la
+# diferencia
+pelear(t::Tigre, c::Gato) = println("¡El tigre $(t.color_pelaje) gana!")
+# => pelear (generic function with 1 method)
+
+pelear(tigre, Pantera())       # ¡El tigre anaranjado gana!
+pelear(tigre, Leon("ROAR"))    # ¡El tigre anaranjado gana!
+
+# Vamos a cambiar el comportamiento cuando el Gato sea específicamente un Leon.
+pelear(t::Tigre, l::Leon) = println("El león con melena $(l.color_crin) gana.")
+# => pelear (generic function with 2 methods)
+
+pelear(tigre, Pantera())       # ¡El tigre anaranjado gana!
+pelear(tigre, Leon("ROAR"))    # El león con melena verde gana.
+
+# No necesitamos un tigre para poder luchar.
+pelear(l::Leon, c::Gato) = println("El gato victorioso dice $(maullar(c)).")
+# => pelear (generic function with 3 methods)
+
+methods(pelear)
+#=
+  # 3 methods for generic function "pelear":
+  pelear(t::Tigre,l::Leon) at none:2
+  pelear(t::Tigre,c::Gato) at none:1
+  pelear(l::Leon,c::Gato) at none:2
+=#
+
+pelear(Leon("balooga!"), Pantera())    # El gato victorioso dice grrr.
+try
+    # ERROR: `pelear` has no method matching pelear(::Pantera, ::Leon)
+    pelear(Pantera(),Leon("RAWR"))
+catch    # no hacer nada con la excepción atrapada
+end
+
+# Un metodo con el tipo Gato primero.
+pelear(c::Gato,l::Leon) = println("El gato le gana al León")
+#=
+  Warning: New definition
+      pelear(Gato,Leon) at none:1
+  is ambiguous with:
+      pelear(Leon,Gato) at none:1.
+  To fix, define
+      pelear(Leon,Leon)
+  before the new definition.
+  pelear (generic function with 4 methods)
+=#
+
+# Esta advertencia se debe a que no está claro que método de pelear
+# será llamado en:
+pelear(Leon("RAR"),Leon("cafe","rar"))    # El gato victorioso dice rar.
+
+# El resultado puede ser diferente en otras versiones de Julia
+pelear(l::Leon,l2::Leon) = println("Los leones llegan a un empate")
+
+pelear(Leon("GR"),Leon("cafe","rar"))    # Los leones llegan a un empate
+
+
+################################
+# 7. Un vistazo de bajo nivel. #
+################################
+
+# Se puede echar un vistazo al código IR de LLVM y al código
+# ensamblador generado.
+area_cuadrado(l) = l * l    # => area_cuadrado (generic function with 1 method)
+
+area_cuadrado(5)    # => 25
+
+# ¿Qué sucede cuando damos area_cuadrada diferentes tipos de argumentos?
+code_native(area_cuadrado, (Int32,))
+#=
+    .section  __TEXT,__text,regular,pure_instructions
+  Filename: none
+  Source line: 1      # prólogo
+    push  RBP
+    mov RBP, RSP
+  Source line: 1
+    imul  RDI, RDI    # elevar l al cuadrado
+    mov RAX, RDI      # almacenar el resultado en RAX
+    pop RBP           # restaurar el puntero base anterior
+    ret               # el resultado estará en RAX
+=#
+
+code_native(area_cuadrado, (Float32,))
+#=
+    .section  __TEXT,__text,regular,pure_instructions
+  Filename: none
+  Source line: 1
+    push  RBP
+    mov RBP, RSP
+  Source line: 1
+    mulss XMM0, XMM0    # multiplicación escalar de presición simple (AVX)
+    pop RBP
+    ret
+=#
+
+code_native(area_cuadrado, (Float64,))
+#=
+    .section  __TEXT,__text,regular,pure_instructions
+  Filename: none
+  Source line: 1
+    push  RBP
+    mov RBP, RSP
+  Source line: 1
+    mulsd XMM0, XMM0    # multiplicación escalar de presición doble (AVX)
+    pop RBP
+    ret
+=#
+
+# Ten en cuenta que Julia usará instrucciones de punto flotante si el tipo de
+# alguno de los argumentos es flotante.
+
+# Vamos a calcular el área de un círculo.
+area_circulo(r) = π * r * r    # area_circulo (generic function with 1 method)
+area_circulo(5)                # 78.53981633974483
+
+code_native(area_circulo, (Int32,))
+#=
+    .section  __TEXT,__text,regular,pure_instructions
+  Filename: none
+  Source line: 1
+    push  RBP
+    mov RBP, RSP
+  Source line: 1
+    cvtsi2sd  XMM1, EDI            # cargar entero r de la memoria
+    movabs  RAX, 4477117456        # cargar constante matemática π
+    movsd XMM0, QWORD PTR [RAX]
+    mulsd XMM0, XMM1               # π * r
+    mulsd XMM0, XMM1               # (π * r) * r
+    pop RBP
+    ret
+=#
+
+code_native(area_circulo, (Float64,))
+#=
+    .section  __TEXT,__text,regular,pure_instructions
+  Filename: none
+  Source line: 1
+    push  RBP
+    mov RBP, RSP
+    movabs  RAX, 4477120336
+    movsd XMM1, QWORD PTR [RAX]
+  Source line: 1
+    mulsd XMM1, XMM0
+    mulsd XMM1, XMM0
+    movaps  XMM0, XMM1
+    pop RBP
+    ret
+=#
+```
+
+![Julia-tan](http://s27.postimg.org/x37ndhz0j/julia_tan_small.png)
+
+## ¿Listo para más?
+
+Para más detalles, lee el [manual de Julia](http://docs.julialang.org/en/release-0.3).
+
+El mejor lugar para obtener ayuda con Julia, es en su amigable [lista de correos](https://groups.google.com/forum/#!forum/julia-users).
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
new file mode 100644
index 00000000..644182ff
--- /dev/null
+++ b/es-es/perl-es.html.markdown
@@ -0,0 +1,156 @@
+---
+name: perl
+category: language
+language: perl
+filename: learnperl-es.pl
+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 más de 25 años de desarrollo.
+
+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 línea con un carácter hash
+
+#### Tipos de variables en Perl
+
+# 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
+
+## Escalares
+# Un escalar representa un solo valor:
+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
+
+## Arreglos
+# Un arreglo representa una lista de valores:
+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");
+
+# 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 más documentados en perldata (perldoc perldata)
+
+# 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
+
+#### 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 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 ) {
+    ...;
+}
+
+# for y foreach
+for ($i = 0; $i <= $max; $i++) {
+    ...;
+}
+
+for $i (0 .. $max) {
+    ...;
+}
+
+foreach (@array) {
+    print "Este elemento es $_\n";
+}
+
+
+#### Expresiones regulares
+
+# 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:
+
+# 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
+
+
+#### Archivos y E/S
+
+# 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 "<>".
+# 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>;
+
+#### 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:
+logger("Tenemos una subrutina logger!");
+
+```
+
+#### Utilizando módulos 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 de CPAN que puede usar.
+
+#### Material de Lectura
+
+     - [perl-tutorial](http://perl-tutorial.org/)
+     - [Learn Perl](http://www.perl.org/learn.html)
+     - [perldoc](http://perldoc.perl.org/)
+     - y en su propio perl: `perldoc perlintro`
diff --git a/es-es/python-es.html.markdown b/es-es/python-es.html.markdown
new file mode 100644
index 00000000..4930eebc
--- /dev/null
+++ b/es-es/python-es.html.markdown
@@ -0,0 +1,562 @@
+---
+language: python
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+translators:
+    - ["Camilo Garrido", "http://www.twitter.com/hirohope"]
+    - ["Fabio Souto", "http://fabiosouto.me"]
+lang: es-es
+filename: learnpython-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
+
+# Evidentemente puedes realizar operaciones matemáticas
+1 + 1  #=> 2
+8 - 1  #=> 7
+10 * 2  #=> 20
+35 / 5  #=> 7
+
+# La división es un poco complicada. Es división entera y toma la parte entera
+# de los resultados automáticamente.
+5 / 2  #=> 2
+
+# Para arreglar la división necesitamos aprender sobre 'floats'
+# (números de coma flotante).
+2.0     # Esto es un 'float'
+11.0 / 4.0  #=> 2.75 ahhh...mucho mejor
+
+# Resultado de la división de enteros truncada para positivos y negativos
+5 // 3     # => 1
+5.0 // 3.0 # => 1.0 # funciona con números en coma flotante
+-5 // 3  # => -2
+-5.0 // 3.0 # => -2.0
+
+# El operador módulo devuelve el resto de una división entre enteros
+7 % 3 # => 1
+
+# Exponenciación (x elevado a y)
+2**4 # => 16
+
+# Refuerza la precedencia con paréntesis
+(1 + 3) * 2  #=> 8
+
+# Operadores booleanos
+# Nota: "and" y "or" son sensibles a mayúsculas
+True and False #=> False
+False or True #=> True
+
+# Podemos usar operadores booleanos con números enteros
+0 and 2 #=> 0
+-5 or 0 #=> -5
+0 == False #=> True
+2 == True #=> False
+1 == True #=> True
+
+# 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'
+
+# % pueden ser usados para formatear strings, como esto:
+"%s pueden ser %s" % ("strings", "interpolados")
+
+# Una forma más reciente de formatear strings es el método 'format'.
+# Este método es la forma preferida
+"{0} pueden ser {1}".format("strings", "formateados")
+# Puedes usar palabras clave si no quieres contar.
+"{nombre} quiere comer {comida}".format(nombre="Bob", comida="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
+
+# El operador 'is' prueba la identidad del objeto. Esto no es
+# muy útil cuando se trata de datos primitivos, pero es
+# muy útil cuando se trata de objetos.
+
+# None, 0, y strings/listas vacíos(as) todas se evalúan como False.
+# Todos los otros valores son True
+bool(0) #=> False
+bool("") #=> False
+
+
+####################################################
+## 2. Variables y Colecciones
+####################################################
+
+# Imprimir es muy fácil
+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
+
+# 'if' puede ser usado como una expresión
+"yahoo!" if 3 > 2 else 2 #=> "yahoo!"
+
+# Las listas almacenan 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]
+
+# 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
+1 in lista #=> True
+
+# Examina el tamaño de una lista con 'len'
+len(lista) #=> 6
+
+
+# Las tuplas son como las 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
+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
+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' es una manera segura de añadir nuevos pares
+# llave-valor en un diccionario
+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
+
+
+# Sets (conjuntos) almacenan ... bueno, conjuntos
+conjunto_vacio = set()
+# Inicializar un conjunto con montón de valores
+un_conjunto = set([1,2,2,3,4]) # un_conjunto ahora es set([1, 2, 3, 4])
+
+# Desde Python 2.7, {} puede ser usado para declarar un conjunto
+conjunto_lleno = {1, 2, 2, 3, 4} # => {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
+####################################################
+
+# Hagamos sólo una variable
+una_variable = 5
+
+# Aquí está una declaración de un 'if'. ¡La indentación es importante 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 "%s es un mamifero" % 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
+
+# Funciona desde Python 2.6 en adelante:
+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.
+
+
+####################################################
+## 4. Funciones
+####################################################
+
+# Usa 'def' para crear nuevas funciones
+def add(x, y):
+    print "x es %s y y es %s" % (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"}
+
+# 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. Clases
+####################################################
+
+# 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 básico, se llama al instanciar la clase.
+    def __init__(self, nombre):
+        # Asigna el argumento al atributo nombre de la instancia
+        self.nombre = nombre
+
+    # Un método 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 permiten evaluación perezosa
+def duplicar_numeros(iterable):
+    for i in iterable:
+        yield i + i
+
+# Un generador crea valores sobre la marcha
+# En vez de generar y devolver todos los valores de una vez, crea un valor
+# en cada iteración. En este ejemplo los valores mayores que 15 no serán 
+# procesados en duplicar_numeros.
+# Nota: xrange es un generador que hace lo mismo que range.
+# Crear una lista de 1 a 900000000 lleva mucho tiempo y ocupa mucho espacio.
+# xrange crea un generador, mientras que range crea toda la lista.
+# Añadimos un guion bajo a los nombres de variable que coinciden con palabras 
+# reservadas de python.
+xrange_ = xrange(1, 900000000)
+
+# duplica todos los números hasta que encuentra un resultado >= 30
+for i in duplicar_numeros(xrange_):
+    print i
+    if i >= 30:
+        break
+
+# Decoradores
+# en este ejemplo pedir rodea a hablar
+# Si por_favor es True se cambiará el mensaje.
+from functools import wraps
+
+
+def pedir(target_function):
+    @wraps(target_function)
+    def wrapper(*args, **kwargs):
+        msg, por_favor = target_function(*args, **kwargs)
+        if por_favor:
+            return "{} {}".format(msg, "¡Por favor! Soy pobre :(")
+        return msg
+
+    return wrapper
+
+
+@pedir
+def hablar(por_favor=False):
+    msg = "¿Me puedes comprar una cerveza?"
+    return msg, por_favor
+
+print hablar()  # ¿Me puedes comprar una cerveza?
+print hablar(por_favor=True)  # ¿Me puedes comprar 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/)
+* [The Official Docs](http://docs.python.org/2.6/)
+* [Hitchhiker's Guide to Python](http://docs.python-guide.org/en/latest/)
+* [Python Module of the Week](http://pymotw.com/2/)
+* [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/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/ruby-es.html.markdown b/es-es/ruby-es.html.markdown
new file mode 100644
index 00000000..66a5d0fe
--- /dev/null
+++ b/es-es/ruby-es.html.markdown
@@ -0,0 +1,377 @@
+---
+language: ruby
+filename: learnruby-es.rb
+contributors:
+  - ["David Underwood", "http://theflyingdeveloper.com"]
+  - ["Joel Walden", "http://joelwalden.net"]
+  - ["Luke Holder", "http://twitter.com/lukeholder"]
+translators:
+    - ["Camilo Garrido", "http://www.twitter.com/hirohope"]
+lang: es-es
+---
+
+```ruby
+# Esto es un comentario
+
+=begin
+Este es un comentario multilínea
+Nadie los usa.
+Tu tampoco deberías
+=end
+
+# Lo primero y principal: Todo es un objeto
+
+# Los números son objetos
+
+3.class #=> Fixnum
+
+3.to_s #=> "3"
+
+
+# Un poco de aritmética básica
+1 + 1 #=> 2
+8 - 1 #=> 7
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# La aritmética es sólo azúcar sintáctico
+# para llamar un método de un objeto
+1.+(3) #=> 4
+10.* 5 #=> 50
+
+# Los valores especiales son objetos
+nil # Nada que ver aqui
+true # Verdadero
+false # Falso
+
+nil.class #=> NilClass
+true.class #=> TrueClass
+false.class #=> FalseClass
+
+# Igualdad
+1 == 1 #=> true
+2 == 1 #=> false
+
+# Desigualdad
+1 != 1 #=> false
+2 != 1 #=> true
+!true  #=> false
+!false #=> true
+
+# Además de 'false', 'nil' es otro valor falso
+
+!nil   #=> true
+!false #=> true
+!0     #=> false
+
+# Más comparaciones
+1 < 10 #=> true
+1 > 10 #=> false
+2 <= 2 #=> true
+2 >= 2 #=> true
+
+# Los strings son objetos
+
+'Soy un string'.class #=> String
+"Soy un string también".class #=> String
+
+referente = "usar interpolacion de strings"
+"Yo puedo #{referente} usando strings de comillas dobles"
+#=> "Yo puedo usar interpolacion de strings usando strings de comillas dobles"
+
+
+# Imprime a la salida estándar
+puts "¡Estoy imprimiendo!"
+
+# Variables
+x = 25 #=> 25
+x #=> 25
+
+# Nota que la asignación retorna el valor asignado
+# Esto significa que puedes hacer múltiples asignaciones:
+
+x = y = 10 #=> 10
+x #=> 10
+y #=> 10
+
+# Por convención, usa snake_case para nombres de variables
+snake_case = true
+
+# Usa nombres de variables descriptivos
+ruta_para_la_raiz_de_un_projecto = '/buen/nombre/'
+ruta = '/mal/nombre/'
+
+# Los símbolos (son objetos)
+# Los símbolos son inmutables, constantes reusables representadas internamente por un
+# valor entero. Son usalmente usados en vez de strings para expresar eficientemente
+# valores específicos y significativos
+
+:pendiente.class #=> Symbol
+
+status = :pendiente
+
+status == :pendiente #=> true
+
+status == 'pendiente' #=> false
+
+status == :aprovado #=> false
+
+# Arreglos
+
+# Esto es un arreglo
+[1, 2, 3, 4, 5] #=> [1, 2, 3, 4, 5]
+
+# Arreglos pueden contener elementos de distintos tipos
+
+arreglo = [1, "hola", false] #=> => [1, "hola", false]
+
+# Arreglos pueden ser indexados
+# Desde el frente
+arreglo[0] #=> 1
+arreglo[12] #=> nil
+
+# Tal como la aritmética, el acceso como variable[índice]
+# es sólo azúcar sintáctica
+# para llamar el método [] de un objeto
+arreglo.[] 0 #=> 1
+arreglo.[] 12 #=> nil
+
+# Desde el final
+arreglo[-1] #=> 5
+
+# Con un índice de inicio y final
+arreglo[2, 4] #=> [3, 4, 5]
+
+# O con rango
+arreglo[1..3] #=> [2, 3, 4]
+
+# Añade elementos a un arreglo así
+arreglo << 6 #=> [1, 2, 3, 4, 5, 6]
+
+# Hashes son los diccionarios principales de Ruby con pares llave/valor.
+# Hashes se denotan con llaves:
+hash = {'color' => 'verde', 'numero' => 5}
+
+hash.keys #=> ['color', 'numero']
+
+# Hashes pueden buscar rápidamente una llave:
+hash['color'] #=> 'verde'
+hash['numero'] #=> 5
+
+# Preguntarle a un hash por una llave que no existe retorna 'nil':
+hash['nada aqui'] #=> nil
+
+# Itera sobre un hash con el método 'each':
+hash.each do |k, v|
+  puts "#{k} is #{v}"
+end
+
+# Desde Ruby 1.9, hay una sintaxis especial cuando se usa un símbolo como llave:
+
+nuevo_hash = { defcon: 3, accion: true}
+
+nuevo_hash.keys #=> [:defcon, :accion]
+
+# Tip: Tanto los arreglos como los hashes son Enumerable (enumerables)
+# Comparten muchos métodos útiles tales como 'each', 'map', 'count', y más
+
+# Estructuras de Control
+
+if true
+  "declaracion 'if'"
+elsif false
+ "else if, opcional"
+else
+ "else, tambien opcional"
+end
+
+for contador in 1..5
+  puts "iteracion #{contador}"
+end
+#=> iteracion 1
+#=> iteracion 2
+#=> iteracion 3
+#=> iteracion 4
+#=> iteracion 5
+
+# Aunque
+# Nadie usa los ciclos `for`
+# Usa `each`, así:
+
+(1..5).each do |contador|
+  puts "iteracion #{contador}"
+end
+#=> iteracion 1
+#=> iteracion 2
+#=> iteracion 3
+#=> iteracion 4
+#=> iteracion 5
+
+counter = 1
+while counter <= 5 do
+  puts "iteracion #{counter}"
+  counter += 1
+end
+#=> iteracion 1
+#=> iteracion 2
+#=> iteracion 3
+#=> iteracion 4
+#=> iteracion 5
+
+nota = 'B'
+
+case nota
+when 'A'
+  puts "Muy bien muchacho"
+when 'B'
+  puts "Mejor suerte para la proxima"
+when 'C'
+  puts "Puedes hacerlo mejor"
+when 'D'
+  puts "Sobreviviendo"
+when 'F'
+  puts "¡Reprobaste!"
+else
+  puts "Sistema alternativo de notas, ¿eh?"
+end
+
+# Funciones
+
+def doble(x)
+  x * 2
+end
+
+# Funciones (y todos los bloques) implícitamente retornan el valor de la última instrucción
+doble(2) #=> 4
+
+# Paréntesis son opcionales cuando el resultado es ambiguo
+doble 3 #=> 6
+
+doble doble 3 #=> 12
+
+def suma(x,y)
+  x + y
+end
+
+# Arguméntos del método son separados por coma
+suma 3, 4 #=> 7
+
+suma suma(3,4), 5 #=> 12
+
+# yield
+# Todos los métodos tienen un parámetro de bloqueo opcional e implícitp
+# puede llamarse con la palabra clave 'yield'
+
+def alrededor
+  puts "{"
+  yield
+  puts "}"
+end
+
+alrededor { puts 'hola mundo' }
+
+# {
+# hola mundo
+# }
+
+
+# Define una clase con la palabra clave 'class'
+class Humano
+
+  # Una variable de clase. Es compartida por todas las instancias de la clase.
+  @@species = "H. sapiens"
+
+  # Inicializador Básico
+  def initialize(nombre, edad=0)
+    # Asigna el argumento a la variable de instancia 'nombre'
+    @nombre = nombre
+    # Si no dan edad, se usará el valor por defecto en la lista de argumentos.
+    @edad = edad
+  end
+
+  # Método 'setter' (establecer) básico
+  def nombre=(nombre)
+    @nombre = nombre
+  end
+
+  # Método 'getter' (obtener) básico
+  def nombre
+    @nombre
+  end
+
+  # Un método de clase usa 'self' (sí mismo) para distinguirse de métodos de instancia.
+  # Sólo puede ser llamado en la clase, no por una instancia.
+  def self.decir(mensaje)
+    puts "#{mensaje}"
+  end
+
+  def especie
+    @@especie
+  end
+
+end
+
+
+# Instancia una clase
+jim = Humano.new("Jim Halpert")
+
+dwight = Humano.new("Dwight K. Schrute")
+
+# Llamemos un par de métodos
+jim.especie #=> "H. sapiens"
+jim.nombre #=> "Jim Halpert"
+jim.nombre = "Jim Halpert II" #=> "Jim Halpert II"
+jim.nombre #=> "Jim Halpert II"
+dwight.especie #=> "H. sapiens"
+dwight.nombre #=> "Dwight K. Schrute"
+
+# Llama el método de clase
+Humano.decir("Hi") #=> "Hi"
+
+# Las clases también son un objeto en ruby. Por lo cual, las clases también pueden tener variables de instancia.
+# Variables de clase son compartidas a través de la clase y todos sus descendientes.
+
+# clase base
+class Humano
+  @@foo = 0
+
+  def self.foo
+    @@foo
+  end
+
+  def self.foo=(valor)
+    @@foo = valor
+  end
+end
+
+# clase derivada
+class Trabajador < Humano
+end
+
+Humano.foo # 0
+Trabajador.foo # 0
+
+Humano.foo = 2 # 2
+Trabajador.foo # 2
+
+# Las variables de instancia de la clase no son compartidas por los descendientes de la clase.
+
+class Humano
+  @bar = 0
+
+  def self.bar
+    @bar
+  end
+
+  def self.bar=(valor)
+    @bar = valor
+  end
+end
+
+class Doctor < Humano
+end
+
+Human.bar # 0
+Doctor.bar # nil
+
+```
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
+```