summaryrefslogtreecommitdiffhomepage
path: root/es-es
diff options
context:
space:
mode:
Diffstat (limited to 'es-es')
-rw-r--r--es-es/bash-es.html.markdown196
-rw-r--r--es-es/brainfuck-es.html.markdown87
-rw-r--r--es-es/go-es.html.markdown2
-rw-r--r--es-es/javascript-es.html.markdown4
-rw-r--r--es-es/julia-es.html.markdown5
-rw-r--r--es-es/markdown-es.html.markdown2
-rw-r--r--es-es/perl-es.html.markdown120
-rw-r--r--es-es/whip-es.html.markdown255
-rw-r--r--es-es/xml-es.html.markdown131
-rw-r--r--es-es/yaml-es.html.markdown151
10 files changed, 885 insertions, 68 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/go-es.html.markdown b/es-es/go-es.html.markdown
index e788e810..86de33ec 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -77,7 +77,7 @@ func learnTypes() {
saltos de línea.` // mismo tipo cadena
// Literal no ASCII. Los fuentes de Go son UTF-8.
- g := 'Σ' // Tipo rune, un alias de uint32, alberga un punto unicode.
+ g := 'Σ' // Tipo rune, un alias de int32, alberga un punto unicode.
f := 3.14195 // float64, el estándar IEEE-754 de coma flotante 64-bit.
c := 3 + 4i // complex128, representado internamente por dos float64.
// Sintaxis Var con inicializadores.
diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
index 9b412f6e..a1348508 100644
--- a/es-es/javascript-es.html.markdown
+++ b/es-es/javascript-es.html.markdown
@@ -471,8 +471,8 @@ var miNumeroObjeto = new Number(12);
miNumero == miNumeroObjeto; // = true
// No son exactamente iguales.
-typeof(miNumero); // = 'number'
-typeof(miNumeroObjeto); // = 'object'
+typeof miNumero; // = 'number'
+typeof miNumeroObjeto; // = 'object'
miNumero === miNumeroObjeyo; // = false
if (0){
// Este código no se ejecutara porque 0 es false.
diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 41a7c68b..203ee3bb 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -1,8 +1,9 @@
---
-language: julia
+language: Julia
contributors:
- ["Leah Hanson", "http://leahhanson.us"]
- - ["Guillermo Garza" ]
+translators:
+ - ["Guillermo Garza", "http://github.com/ggarza"]
filename: learnjulia-es.jl
lang: es-es
---
diff --git a/es-es/markdown-es.html.markdown b/es-es/markdown-es.html.markdown
index 3865126c..d90e3eb5 100644
--- a/es-es/markdown-es.html.markdown
+++ b/es-es/markdown-es.html.markdown
@@ -14,7 +14,7 @@ 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
diff --git a/es-es/perl-es.html.markdown b/es-es/perl-es.html.markdown
index 4f0c26c1..644182ff 100644
--- a/es-es/perl-es.html.markdown
+++ b/es-es/perl-es.html.markdown
@@ -7,23 +7,24 @@ contributors:
- ["Korjavin Ivan", "http://github.com/korjavin"]
translators:
- ["Francisco Gomez", "http://github.com/frncscgmz"]
+ - ["Joaquín Ferrero", "http://github.com/joaquinferrero"]
lang: es-es
---
-Perl 5 es un lenguaje de programación altamente capaz, rico en características con mas de 25 años de desarrollo.
+Perl 5 es un lenguaje de programación altamente capaz, rico en características, con más de 25 años de desarrollo.
-Perl 5 corre en mas de 100 plataformas desde portales hasta mainframes y es adecuado para realizar prototipos rápidos hasta desarrollar proyectos a gran escala.
+Perl 5 corre en más de 100 plataformas, desde portátiles hasta ordenadores centrales, y es adecuado para realizar desde prototipos rápidos hasta desarrollar proyectos a gran escala.
```perl
-# Comentarios de una sola linea con un carácter hash.
+# Comentarios de una sola línea con un carácter hash
#### Tipos de variables en Perl
-# Las variables comienzan con el símbolo $.
-# Un nombre de variable valido empieza con una letra o un guión bajo,
-# seguido por cualquier numero de letras, números o guiones bajos.
+# Las variables comienzan con el símbolo $
+# Un nombre de variable válido empieza con una letra o un guión bajo,
+# seguido por cualquier número de letras, números o guiones bajos
-### Perl tiene tres tipos principales de variables: escalares, arreglos y hashes.
+### Perl tiene tres tipos principales de variables: escalares, arreglos y hashes
## Escalares
# Un escalar representa un solo valor:
@@ -31,99 +32,98 @@ my $animal = "camello";
my $respuesta = 42;
# Los valores escalares pueden ser cadenas de caracteres, números enteros o
-# de punto flotante, Perl automáticamente los convertirá como sea requerido.
+# de punto flotante; Perl automáticamente los convertirá como sea requerido
## Arreglos
# Un arreglo representa una lista de valores:
-my @animales = {"camello","llama","buho"};
-my @numeros = {23,42,69};
-my @mixto = {"camello",42,1.23};
-
-
+my @animales = ("camello","llama","buho"};
+my @numeros = (23, 42, 69);
+my @mixto = ("camello", 42, 1.23);
## Hashes
-# Un hash representa un conjunto de pares llave/valor:
-
-my %color_fruta = {"manzana","rojo","banana","amarillo"};
-
-# Puedes usar un espacio en blanco y el operador "=>" para asignarlos mas
-# fácilmente.
+# Un hash representa un conjunto de pares llave/valor:
+my %color_fruta = ("manzana","rojo","banana","amarillo");
+# Puede usar un espacio en blanco y el operador "=>" para asignarlos más fácilmente
my %color_fruta = (
manzana => "rojo",
banana => "amarillo",
- );
-# Los escalares, arreglos y hashes están mas documentados en perldata. (perldoc perldata).
+);
-# Los tipos de datos mas complejos pueden ser construidos utilizando
-# referencias, las cuales te permiten construir listas y hashes dentro
-# de listas y hashes.
+# Los escalares, arreglos y hashes están más documentados en perldata (perldoc perldata)
-#### Estructuras condicionales y de ciclos
+# Los tipos de datos más complejos se pueden construir utilizando
+# referencias, las cuales le permiten construir listas y hashes dentro
+# de listas y hashes
-# Perl tiene la mayoría de las estructuras condicionales y de ciclos mas comunes.
+#### Estructuras condicionales y de ciclos
+# Perl tiene la mayoría de las estructuras condicionales y de ciclos más comunes
if ( $var ) {
- ...
+ ...;
} elsif ( $var eq 'bar' ) {
- ...
+ ...;
} else {
- ...
+ ...;
}
unless ( condicion ) {
- ...
- }
-# Esto es proporcionado como una version mas fácil de leer que "if (!condición)"
+ ...;
+}
-# La post condición al modo Perl
+# Esto se ofrece como una versión más fácil de leer que "if (!condición)"
+
+# La postcondición al modo Perl:
print "Yow!" if $zippy;
print "No tenemos bananas" unless $bananas;
# while
- while ( condicion ) {
- ...
- }
-
+while ( condicion ) {
+ ...;
+}
# for y foreach
for ($i = 0; $i <= $max; $i++) {
- ...
- }
+ ...;
+}
+
+for $i (0 .. $max) {
+ ...;
+}
foreach (@array) {
- print "Este elemento es $_\n";
- }
+ print "Este elemento es $_\n";
+}
#### Expresiones regulares
-# El soporte de expresiones regulares en Perl es muy amplio y profundo, y es
-# sujeto a una extensa documentación en perlrequick, perlretut, entre otros.
+# El soporte de expresiones regulares en Perl es muy amplio y profundo, y
+# está sujeto a una extensa documentación en perlrequick, perlretut, entre otros.
# Sin embargo, resumiendo:
-# Pareo simple
+# Coincidencia simple
if (/foo/) { ... } # verdadero si $_ contiene "foo"
if ($a =~ /foo/) { ... } # verdadero si $a contiene "foo"
# Substitución simple
-$a =~ s/foo/bar/; # remplaza foo con bar en $a
-$a =~ s/foo/bar/g; # remplaza TODAS LAS INSTANCIAS de foo con bar en $a
+$a =~ s/foo/bar/; # remplaza "foo" con "bar" en $a
+$a =~ s/foo/bar/g; # remplaza TODAS LAS INSTANCIAS de "foo" con "bar" en $a
-#### Archivos e I/O
+#### Archivos y E/S
-# Puedes abrir un archivo para obtener datos o escribirlos utilizando la
-# función "open()".
+# Puede abrir un archivo para obtener datos o escribirlos utilizando la
+# función "open()"
open(my $entrada, "<" "entrada.txt") or die "No es posible abrir entrada.txt: $!";
open(my $salida, ">", "salida.txt") or die "No es posible abrir salida.txt: $!";
open(my $log, ">>", "mi.log") or die "No es posible abrir mi.log: $!";
-# Es posible leer desde un gestor de archivo abierto utilizando el operador "<>"
-# operador. En contexto escalar leer una sola linea desde el gestor de
-# archivo, y en contexto de lista leer el archivo completo en donde, asigna
-# cada linea a un elemento de la lista.
+# Es posible leer desde un gestor de archivo abierto utilizando el operador "<>".
+# En contexto escalar, leer una sola línea desde el gestor de archivo, y
+# en contexto de lista, leer el archivo completo en donde asigna
+# cada línea a un elemento de la lista
my $linea = <$entrada>;
my @lineas = <$entrada>;
@@ -131,30 +131,26 @@ my @lineas = <$entrada>;
#### Escribiendo subrutinas
# Escribir subrutinas es fácil:
-
sub logger {
my $mensajelog = shift;
open my $archivolog, ">>", "mi.log" or die "No es posible abrir mi.log: $!";
print $archivolog $mensajelog;
}
-# Ahora podemos utilizar la subrutina al igual que cualquier otra función
-# incorporada:
-
+# Ahora podemos utilizar la subrutina al igual que cualquier otra función incorporada:
logger("Tenemos una subrutina logger!");
-
```
#### Utilizando módulos Perl
-Los módulos en Perl proveen una gama de funciones que te pueden ayudar a evitar reinventar la rueda, estas pueden ser descargadas desde CPAN( http://www.cpan.org/ ). Algunos de los módulos mas populares ya están incluidos con la misma distribución de Perl.
+Los módulos en Perl proveen de una gama de funciones que le pueden ayudar a evitar reinventar la rueda. Éstas se pueden descargar desde CPAN ( http://www.cpan.org/ ). Algunos de los módulos más populares ya están incluidos con la misma distribución de Perl.
-perlfaq contiene preguntas y respuestas relacionadas con muchas tareas comunes, y algunas veces provee sugerencias sobre buenos módulos CPAN para usar.
+perlfaq contiene preguntas y respuestas relacionadas con muchas tareas comunes, y algunas veces provee sugerencias sobre buenos módulos de CPAN que puede usar.
#### Material de Lectura
- [perl-tutorial](http://perl-tutorial.org/)
- - [Aprende en www.perl.com](http://www.perl.org/learn.html)
+ - [Learn Perl](http://www.perl.org/learn.html)
- [perldoc](http://perldoc.perl.org/)
- - y perl incorporado: `perldoc perlintro`
+ - y en su propio perl: `perldoc perlintro`
diff --git a/es-es/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
+```