From df6ff15f9f0b70e8c1307a14c5ceaa44ee76ea08 Mon Sep 17 00:00:00 2001
From: FlaskBreaker <flaskbreaker@gmail.com>
Date: Mon, 5 Aug 2013 12:51:58 +0200
Subject: Added c-es

---
 es-es/c-es.html.markdown | 417 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 417 insertions(+)
 create mode 100644 es-es/c-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/c-es.html.markdown b/es-es/c-es.html.markdown
new file mode 100644
index 00000000..72902dd2
--- /dev/null
+++ b/es-es/c-es.html.markdown
@@ -0,0 +1,417 @@
+---
+language: c
+filename: learnc.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 hallas 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.
+    f = &str_reverse; // Assigna la dirección de la función (determinado en tiempo de ejecuión)
+    (*f)(str_in); // Llamando la función desde el puntero
+    // f(str_in); // Esta es una alternativa para llamarla pero con una sintaxis igual de válida.
+}
+
+/*
+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.
-- 
cgit v1.2.3


From 2dac6eb4f98db6a930e0101eb3529ffc7290496a Mon Sep 17 00:00:00 2001
From: Guillermo Vaya <guillermo.vaya@gigas.com>
Date: Fri, 2 Aug 2013 14:24:27 +0200
Subject: emacs lisp translated

---
 es-es/elisp-es.html.markdown | 377 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 377 insertions(+)
 create mode 100644 es-es/elisp-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/elisp-es.html.markdown b/es-es/elisp-es.html.markdown
new file mode 100644
index 00000000..8c220109
--- /dev/null
+++ b/es-es/elisp-es.html.markdown
@@ -0,0 +1,377 @@
+---
+language: elisp
+contributors:
+    - ["Bastien Guerry", "http://bzg.fr"]
+translators:
+    - ["Guillermo Vayá", "http://willyfrog.es"]
+lang: es-es
+filename: learn-emacs-lisp.el
+---
+
+```scheme
+;; Introduccion a Emacs Lisp en 15 minutos (v0.2d)
+;;
+;; Autor: Bastien / @bzg2 / http://bzg.fr
+;; Traducción: Guillermo Vayá
+;;
+;; Antes de nada, lee este texto de Peter Norvig:
+;; 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
+```
-- 
cgit v1.2.3


From c10f6a688865b667aa2936d7bd748122560f5c91 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Mon, 5 Aug 2013 08:33:24 -0700
Subject: Changed c-es to utf8

---
 es-es/c-es.html.markdown | 168 +++++++++++++++++++++++------------------------
 1 file changed, 84 insertions(+), 84 deletions(-)

(limited to 'es-es')

diff --git a/es-es/c-es.html.markdown b/es-es/c-es.html.markdown
index 72902dd2..2e7cf8be 100644
--- a/es-es/c-es.html.markdown
+++ b/es-es/c-es.html.markdown
@@ -4,23 +4,23 @@ filename: learnc.c
 contributors:
     - ["Adam Bard", "http://adambard.com/"]
 translators:
-    - ["Francisco García", "http://flaskbreaker.tumblr.com/"]
+    - ["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.
+¡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
+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 de una sola línea comienzan con //
 
 /*
-Los comentarios multilínea tienen este aspecto.
+Los comentarios multilínea tienen este aspecto.
 */
 
 // Importa cabeceras con #include
@@ -33,12 +33,12 @@ Los comentarios multil
 void function_1();
 void function_2();
 
-// El punto de entrada de tu programa es una función llamada main con
+// 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
+// %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.
 
@@ -46,9 +46,9 @@ printf("%d\n", 0); // => Muestra 0
 // Tipos
 ///////////////////////////////////////
 
-// Tienes que declarar una variable antes de usarla. La declaración de una
+// 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.
+// determina su tamaño en bytes.
 
 // 'ints' (enteros) son normalmente de 4 bytes
 int x_int = 0;
@@ -65,53 +65,53 @@ char y_char = 'y'; // Los caracteres literales se entrecomillan con ''
 long x_long = 0;
 long long x_long_long = 0; 
 
-// 'floats' son normalmente números de coma flotante de 32 bits
+// '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
+// '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.
+// 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
+// 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)
+printf("%lu\n", sizeof(int)); // => 4 (en máquinas con 'words' de 4 bytes)
 
-// Los arrays deben ser inicializados con un tamaño concreto.
+// 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í:
+// 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
+// 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!
+// 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.)
+// 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.
+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.
 */
@@ -122,22 +122,22 @@ printf("%d\n", a_string[18]); // => 0
 // Operadores
 ///////////////////////////////////////
 
-int i1 = 1, i2 = 2; // Forma corta de declaración múltiple
+int i1 = 1, i2 = 2; // Forma corta de declaración múltiple
 float f1 = 1.0, f2 = 2.0;
 
-// La aritmética es sencilla
+// 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
+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
+// 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 
+// cualquier otra cosa es verdadero. (Los operadores de comparación 
 // siempre devuelven 0 o 1)
 3 == 2; // => 0 (Falso)
 3 != 2; // => 1 (Verdadero)
@@ -146,16 +146,16 @@ f1 / f2; // => 0.5, m
 2 <= 2; // => 1
 2 >= 2; // => 1
 
-// La lógica funiona en enteros
-!3; // => 0 (not lógico)
+// La lógica funiona en enteros
+!3; // => 0 (not lógico)
 !0; // => 1
-1 && 1; // => 1 (and lógico)
+1 && 1; // => 1 (and lógico)
 0 && 1; // => 0
-0 || 1; // => 1 (or lógico)
+0 || 1; // => 1 (or lógico)
 0 || 0; // => 0
 
-// ¡Operadores de bits!
-~0x0F; // => 0xF0 (Negación)
+// ¡Operadores de bits!
+~0x0F; // => 0xF0 (Negación)
 0x0F & 0xF0; // => 0x00 (AND)
 0x0F | 0xF0; // => 0xFF (OR)
 0x04 ^ 0x0F; // => 0x0B (XOR)
@@ -177,7 +177,7 @@ if (0) {
 // Mientras el bucle exista
 int ii = 0;
 while (ii < 10) {
-    printf("%d, ", ii++); // ii++ incrementa ii en uno, después de usar su valor.
+    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");
@@ -190,7 +190,7 @@ do {
 
 printf("\n");
 
-// Bucles 'for' también
+// Bucles 'for' también
 int jj;
 for (jj=0; jj < 10; jj++) {
     printf("%d, ", jj);
@@ -207,13 +207,13 @@ printf("\n");
 
 int x_hex = 0x01; // Puedes asignar hexadecimales a variables
 
-// El cambio de tipos intentará mantener sus valores numéricos
+// 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)
+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'
@@ -224,28 +224,28 @@ 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
+// 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.
+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;
+// => Muestra alguna dirección de memoria;
 
-// Los tipos de puntero terminan con * en su declaración
+// 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
+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
+// 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
+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
+// 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
@@ -267,24 +267,24 @@ int* x_ptr = x_array;
 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.
+// 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.
+// 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í
+    *(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
+// Desreferenciando la memoria que no has asignado te dará resultados
 // impredecibles
 printf("%d\n", *(my_ptr + 21)); // => Prints who-knows-what?
 
-// Cuando hallas acabado con el bloque de memoría malloc, necesitas 
-// liberarlo o sino nadie más podrá usarlo hasta que tu programa se cierre
+// Cuando hallas 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
@@ -294,13 +294,13 @@ char* my_str = "This is my very own string";
 printf("%c\n", *my_str); // => 'T'
 
 function_1();
-} // fin de la función main
+} // fin de la función main
 
 ///////////////////////////////////////
 // Funciones
 ///////////////////////////////////////
 
-// Sintexis de la declaración de funciones:
+// Sintexis de la declaración de funciones:
 // <tipo de retorno> <nombre>(<argumentos>)
 
 int add_two_ints(int x1, int x2){
@@ -315,13 +315,13 @@ valores.
 Ejemplo: invertidor de cadenas in-situ
 */
 
-// Una función 'void' no retorna valor
+// 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
+    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[ii] = str_in[len - ii - 1]; // ii-th último 'char'
         str_in[len - ii - 1] = tmp;
     }
 }
@@ -333,14 +333,14 @@ printf("%s\n", c); // => ".abeurp anu se otsE"
 */
 
 ///////////////////////////////////////
-// Definición de tipos y estructuras
+// 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.
+// Las estructuras son sólo grupos de datos.
 struct rectangle {
     int width;
     int height;
@@ -365,7 +365,7 @@ void function_1(){
     my_rec_ptr->height = 10; // Lo mismo que (*my_rec_ptr).height = 10;
 }
 
-// Puedes aplicar un 'typedef' a una estructura por conveniencía.
+// Puedes aplicar un 'typedef' a una estructura por conveniencía.
 typedef struct rectangle rect;
 
 int area(rect r){
@@ -376,26 +376,26 @@ int area(rect r){
 // Punteros a Funciones
 ///////////////////////////////////////
 /*
-En tiempo de ejecución,  las funciones se localizan en unas direcciones de
+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 
+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.
+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.
-    f = &str_reverse; // Assigna la dirección de la función (determinado en tiempo de ejecuión)
-    (*f)(str_in); // Llamando la función desde el puntero
-    // f(str_in); // Esta es una alternativa para llamarla pero con una sintaxis igual de válida.
+    // Define un puntero a una función, llamado f.
+    void (*f)(char *); // La armadura debe coincidir exactamente con al función objetivo.
+    f = &str_reverse; // Assigna la dirección de la función (determinado en tiempo de ejecuión)
+    (*f)(str_in); // Llamando la función desde el puntero
+    // f(str_in); // Esta es una alternativa para llamarla pero con una sintaxis igual de válida.
 }
 
 /*
-Tanto tiempo como las armaduras de las funciones coincidan, podrás asignar
-cualquier función al mismo puntero.
+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:
 */
-- 
cgit v1.2.3


From 54f682e5d2932121139350381cc23526b4c8002e Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Mon, 5 Aug 2013 08:38:09 -0700
Subject: Line lenght edits for c-es

---
 es-es/c-es.html.markdown | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

(limited to 'es-es')

diff --git a/es-es/c-es.html.markdown b/es-es/c-es.html.markdown
index 2e7cf8be..0624f4be 100644
--- a/es-es/c-es.html.markdown
+++ b/es-es/c-es.html.markdown
@@ -104,9 +104,10 @@ 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'.
+// 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.)
+// 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.
 
@@ -387,10 +388,17 @@ 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.
-    f = &str_reverse; // Assigna la dirección de la función (determinado en tiempo de ejecuión)
-    (*f)(str_in); // Llamando la función desde el puntero
-    // f(str_in); // Esta es una alternativa para llamarla pero con una sintaxis igual de válida.
+    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);
 }
 
 /*
-- 
cgit v1.2.3


From dae7c446926b338a05c8dfcfc68e64acf5b80128 Mon Sep 17 00:00:00 2001
From: Guillermo Vaya <guillermo.vaya@gigas.com>
Date: Tue, 6 Aug 2013 10:01:42 +0200
Subject: added contact info and norvig's text translated link

---
 es-es/elisp-es.html.markdown | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'es-es')

diff --git a/es-es/elisp-es.html.markdown b/es-es/elisp-es.html.markdown
index 8c220109..431ea794 100644
--- a/es-es/elisp-es.html.markdown
+++ b/es-es/elisp-es.html.markdown
@@ -12,10 +12,11 @@ filename: learn-emacs-lisp.el
 ;; Introduccion a Emacs Lisp en 15 minutos (v0.2d)
 ;;
 ;; Autor: Bastien / @bzg2 / http://bzg.fr
-;; Traducción: Guillermo Vayá
+;; Traducción: Guillermo Vayá / @Driadan / http://willyfrog.es
 ;;
 ;; Antes de nada, lee este texto de Peter Norvig:
-;; http://norvig.com/21-days.html
+;; Traducido: http://loro.sourceforge.net/notes/21-dias.html
+;; Original: http://norvig.com/21-days.html
 ;;
 ;; Ahora instala GNU Emacs 24.3:
 ;;
-- 
cgit v1.2.3


From 6db6606d2e5e7a22e30dd004bf67dc399f5627fc Mon Sep 17 00:00:00 2001
From: Camilo Garrido <hiro.hope@gmail.com>
Date: Wed, 7 Aug 2013 22:54:20 -0400
Subject: Add python-es file

---
 es-es/python-es.html.markdown | 490 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 490 insertions(+)
 create mode 100644 es-es/python-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/python-es.html.markdown b/es-es/python-es.html.markdown
new file mode 100644
index 00000000..1ec8d7e4
--- /dev/null
+++ b/es-es/python-es.html.markdown
@@ -0,0 +1,490 @@
+---
+language: python
+contributors:
+    - ["Louie Dinh", "http://ldinh.ca"]
+translators:
+    - ["Camilo Garrido", "http://www.twitter.com/hirohope"]
+lang: es-es
+filename: learnpython.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
+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
+
+# 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'
+
+# % 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 claves 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
+0 == False  #=> True
+"" == False #=> True
+
+
+####################################################
+## 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!"
+
+# Listas sobre 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 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
+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 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 "%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 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)
+
+
+```
+
+## ¿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/)
+
+### 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)
+
-- 
cgit v1.2.3


From 191552ad49210a98e4b9e6620abf092755bf3d18 Mon Sep 17 00:00:00 2001
From: Camilo Garrido <hiro.hope@gmail.com>
Date: Thu, 8 Aug 2013 12:25:00 -0400
Subject: Java file translated to spanish

---
 es-es/java-es.html.markdown | 410 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 410 insertions(+)
 create mode 100644 es-es/java-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/java-es.html.markdown b/es-es/java-es.html.markdown
new file mode 100644
index 00000000..90a43935
--- /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.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)
-- 
cgit v1.2.3


From 80ea89b58a470f9b1a4ce7710f4de6ac69dee5ee Mon Sep 17 00:00:00 2001
From: Camilo Garrido <hiro.hope@gmail.com>
Date: Sun, 11 Aug 2013 12:45:31 -0400
Subject: Ruby file translated to spanish

---
 es-es/ruby-es.html.markdown | 377 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 377 insertions(+)
 create mode 100644 es-es/ruby-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/ruby-es.html.markdown b/es-es/ruby-es.html.markdown
new file mode 100644
index 00000000..fa039676
--- /dev/null
+++ b/es-es/ruby-es.html.markdown
@@ -0,0 +1,377 @@
+---
+language: ruby
+filename: learnruby.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
+
+```
-- 
cgit v1.2.3


From bd48b7062c51aff7d27114326f64fde505cea49c Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Mon, 12 Aug 2013 09:53:40 -0700
Subject: Updated translation filenames to prevent collisions

---
 es-es/c-es.html.markdown      | 2 +-
 es-es/elisp-es.html.markdown  | 2 +-
 es-es/java-es.html.markdown   | 2 +-
 es-es/python-es.html.markdown | 2 +-
 es-es/ruby-es.html.markdown   | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

(limited to 'es-es')

diff --git a/es-es/c-es.html.markdown b/es-es/c-es.html.markdown
index 0624f4be..b109f761 100644
--- a/es-es/c-es.html.markdown
+++ b/es-es/c-es.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: c
-filename: learnc.c
+filename: learnc-es.c
 contributors:
     - ["Adam Bard", "http://adambard.com/"]
 translators:
diff --git a/es-es/elisp-es.html.markdown b/es-es/elisp-es.html.markdown
index 431ea794..a6cd3934 100644
--- a/es-es/elisp-es.html.markdown
+++ b/es-es/elisp-es.html.markdown
@@ -5,7 +5,7 @@ contributors:
 translators:
     - ["Guillermo Vayá", "http://willyfrog.es"]
 lang: es-es
-filename: learn-emacs-lisp.el
+filename: learn-emacs-lisp-es.el
 ---
 
 ```scheme
diff --git a/es-es/java-es.html.markdown b/es-es/java-es.html.markdown
index 90a43935..b34dca8d 100644
--- a/es-es/java-es.html.markdown
+++ b/es-es/java-es.html.markdown
@@ -5,7 +5,7 @@ contributors:
 translators:
     - ["Camilo Garrido", "http://www.twitter.com/hirohope"]
 lang: es-es
-filename: LearnJava.java
+filename: LearnJava-es.java
 ---
 
 Java es un lenguage de programación de propósito general, concurrente, basado en clases y
diff --git a/es-es/python-es.html.markdown b/es-es/python-es.html.markdown
index 1ec8d7e4..f92f5cde 100644
--- a/es-es/python-es.html.markdown
+++ b/es-es/python-es.html.markdown
@@ -5,7 +5,7 @@ contributors:
 translators:
     - ["Camilo Garrido", "http://www.twitter.com/hirohope"]
 lang: es-es
-filename: learnpython.py
+filename: learnpython-es.py
 ---
 
 Python fue creado por Guido Van Rossum en el principio de los 90'. Ahora es uno
diff --git a/es-es/ruby-es.html.markdown b/es-es/ruby-es.html.markdown
index fa039676..66a5d0fe 100644
--- a/es-es/ruby-es.html.markdown
+++ b/es-es/ruby-es.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: ruby
-filename: learnruby.rb
+filename: learnruby-es.rb
 contributors:
   - ["David Underwood", "http://theflyingdeveloper.com"]
   - ["Joel Walden", "http://joelwalden.net"]
-- 
cgit v1.2.3


From 7d015d8cee3a71fb54ed205a348428ab589ef1a6 Mon Sep 17 00:00:00 2001
From: Pablo Elices <pablodanielgomezelices@gmail.com>
Date: Wed, 14 Aug 2013 13:12:27 +0200
Subject: Translate CoffeeScript file to spanish.

---
 es-es/coffeescript-es.html.markdown | 56 +++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 es-es/coffeescript-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/coffeescript-es.html.markdown b/es-es/coffeescript-es.html.markdown
new file mode 100644
index 00000000..eb6825c0
--- /dev/null
+++ b/es-es/coffeescript-es.html.markdown
@@ -0,0 +1,56 @@
+---
+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 almohadilla.
+
+###
+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); }
+#}
+
+# Símbolos:
+race = (winner, runners...) ->
+  print winner, runners
+
+# Existencia:
+alert "I knew it!" if elvis?
+#=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
+
+# Colecciones por comprensión:
+cubes = (math.cube num for num in list) #=> ...
+```
-- 
cgit v1.2.3


From f29098292c71a897efbcdbe702146831e5ca4831 Mon Sep 17 00:00:00 2001
From: Pablo Elices <pablodanielgomezelices@gmail.com>
Date: Wed, 14 Aug 2013 13:13:56 +0200
Subject: Fix typo.

---
 es-es/coffeescript-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/coffeescript-es.html.markdown b/es-es/coffeescript-es.html.markdown
index eb6825c0..a58c0d07 100644
--- a/es-es/coffeescript-es.html.markdown
+++ b/es-es/coffeescript-es.html.markdown
@@ -11,7 +11,7 @@ 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 almohadilla.
+# 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.
-- 
cgit v1.2.3


From e938d244fcd4095a6dc8be117fdabb4d2370ca2f Mon Sep 17 00:00:00 2001
From: Pablo Elices <pablodanielgomezelices@gmail.com>
Date: Wed, 14 Aug 2013 17:56:15 +0200
Subject: Split long line.

---
 es-es/coffeescript-es.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/coffeescript-es.html.markdown b/es-es/coffeescript-es.html.markdown
index a58c0d07..78bb9be5 100644
--- a/es-es/coffeescript-es.html.markdown
+++ b/es-es/coffeescript-es.html.markdown
@@ -14,7 +14,8 @@ filename: coffeescript-es.coffee
 # 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.
+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.
 ###
-- 
cgit v1.2.3


From cf5730cebc5756e5b5cb18e93fe53092c3d6a036 Mon Sep 17 00:00:00 2001
From: Yury <y.timofeyev@gmail.com>
Date: Fri, 16 Aug 2013 00:21:28 +0400
Subject: fixed typo in C spanish version adressed in #230

---
 es-es/c-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/c-es.html.markdown b/es-es/c-es.html.markdown
index b109f761..5d3aae0c 100644
--- a/es-es/c-es.html.markdown
+++ b/es-es/c-es.html.markdown
@@ -284,7 +284,7 @@ for (xx=0; xx<20; xx++) {
 // impredecibles
 printf("%d\n", *(my_ptr + 21)); // => Prints who-knows-what?
 
-// Cuando hallas acabado con el bloque de memoría malloc, necesitas 
+// 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);
 
-- 
cgit v1.2.3


From 4d522544f2644d2fdbc8bcd41fd3afa0fcc11583 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Antonio=20Hern=C3=A1ndez=20Blas?= <hba.nihilismus@gmail.com>
Date: Sat, 31 Aug 2013 04:09:41 -0500
Subject: Spanish translation for Clojure.

---
 es-es/clojure-es.html.markdown | 395 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 395 insertions(+)
 create mode 100644 es-es/clojure-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/clojure-es.html.markdown b/es-es/clojure-es.html.markdown
new file mode 100644
index 00000000..7102b361
--- /dev/null
+++ b/es-es/clojure-es.html.markdown
@@ -0,0 +1,395 @@
+---
+language: clojure
+filename: learnclojure-es.clj
+contributors:
+    - ["Adam Bard", "http://adambard.com/"]
+translators:
+    - ["Antonio Hernández Blas", "https://twitter.com/nihilipster"]
+lang: es-es
+---
+
+Clojure es un lenguaje de la familia Lisp desarrollado para la Máquina Virtual
+de Java. Tiene un énfasis más fuerte en la [programación funcional](https://es.wikipedia.org/wiki/Programación_funcional) pura
+que Common Lisp, pero incluye varias facilidades de [SMT](https://es.wikipedia.org/wiki/Memoria_transacional) para manipular
+el estado según se presente.
+
+Esta combinación le permite manejar el procesamiento concurrente muy simple,
+y a menudo automáticamente.
+
+(Necesitas la versión de Clojure 1.2 o nueva)
+
+
+```clojure
+; Los comentatios inician con punto y coma.
+
+; Clojure es escrito en "forms" (patrones), los cuales son solo
+; listas de objectos dentro de paréntesis, separados por espacios en blanco.
+
+; El reader (lector) de Clojure asume que el primer objeto es una
+; función o una macro a llamar, y que el resto son argumentos.
+
+; La primera llamada en un archivo debe ser ns, para establecer el espacio de
+; nombre
+(ns learnclojure)
+
+; Más ejemplos básicos:
+
+; str creará una cadena de caracteres a partir de sus argumentos
+(str "Hello" " " "World") ; => "Hello World"
+
+; Las 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
+
+; Necesitas de la negación para la lógica, también
+(not true) ; => false
+
+; Los patrones anidados funcionan como lo esperas
+(+ 1 (- 3 2)) ; = 1 + (3 - 2) => 2
+
+; Tipos
+;;;;;;;;;;;;;
+
+; Clojure usa los tipos de objetos de Java para booleanos,cadenas de
+; caracteres y números.
+; Usa class para inspeccionarlos.
+(class 1); Los enteros literales son java.lang.Long por default
+(class 1.); Los flotantes literales son java.lang.Double
+(class ""); Las cadenas de caracteres van entre comillas dobles, y son
+; son java.lang.String
+(class false); Los Booleanos son java.lang.Boolean
+(class nil); El valor "null" es llamado nil
+
+; Si quieres crear una lista literal de datos, precede la con una comilla
+; simple para evitar su evaluación
+'(+ 1 2) ; => (+ 1 2)
+; (abreviatura de (quote (+ 1 2))
+
+; Puedes evaluar una lista precedida por comilla simple con eval
+(eval '(+ 1 2)) ; => 3
+
+; Colecciones & Secuencias
+;;;;;;;;;;;;;;;;;;;
+
+; Las Listas están basadas en listas enlazadas, mientras que los Vectores en
+; arreglos.
+; ¡Los Vectores y las Listas son clases de Java también!
+(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 precidirla con
+; comilla simple para evitar que el lector 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 agrega 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, map para actuar sobre colecciones
+(map inc [1 2 3]) ; => (2 3 4)
+(filter even? [1 2 3]) ; => (2)
+
+; Usa reduce para reducirlos
+(reduce + [1 2 3 4])
+; = (+ (+ (+ 1 2) 3) 4)
+; => 10
+
+; reduce puede tomar un argumento como valor inicial también
+(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 regresa
+; su última expresión
+(fn [] "Hello World") ; => fn
+
+; (Necesitas encerrarlo en paréntesis para llamarlo)
+((fn [] "Hello World")) ; => "Hello World"
+
+; Puedes crear una var (variable) usando def
+(def x 1)
+x ; => 1
+
+; Asigna una función a una var
+(def hello-world (fn [] "Hello World"))
+(hello-world) ; => "Hello World"
+
+; Puedes acortar este proceso al usar defn
+(defn hello-world [] "Hello World")
+
+; El [] es el vector de argumentos para la función.
+(defn hello [name]
+  (str "Hello " name))
+(hello "Steve") ; => "Hello Steve"
+
+; Puedes usar también esta abreviatura para crear funciones:
+(def hello2 #(str "Hello " %1))
+(hello2 "Fanny") ; => "Hello Fanny"
+
+; Puedes tener funciones multi-variadic (múltiple numero variable de
+; argumentos), también
+(defn hello3
+  ([] "Hello World")
+  ([name] (str "Hello " name)))
+(hello3 "Jake") ; => "Hello Jake"
+(hello3) ; => "Hello World"
+
+; Las funciones pueden colocar argumentos extras dentro de una seq por ti
+(defn count-args [& args]
+  (str "You passed " (count args) " args: " args))
+(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
+
+; Puedes mezclar argumentos regulares y dentro de una seq
+(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 Arreglos comparten una interfaz. Los mapas de Hash
+; tienen búsquedas más rápidas pero no mantienen el orden de las llaves.
+(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 Arreglos serán convertidos en mapas de Hash en la mayoría de
+; operaciones si crecen lo suficiente, así que no necesitas preocuparte.
+
+; Los mapas pueden usar cualquier tipo para sus llaves, pero usualmente las
+; keywords (llaves) son mejor.
+; Las keywords son como cadenas de caracteres con algunas ventajas en 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 siempre tratadas como espacios en blanco y no hacen
+; nada.
+
+; Recupera un valor de un mapa tratando la 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 intentes ésto con cadenas de caracteres.
+;("a" stringmap)
+; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
+
+; Recuperando un valor no presente regresa nil
+(stringmap "d") ; => nil
+
+; Usa assoc para agregar nuevas llaves 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 remover 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}
+
+; Agrega un miembro con conj
+(conj #{1 2 3} 4) ; => #{1 2 3 4}
+
+; Remueve uno con disj
+(disj #{1 2 3} 1) ; => #{2 3}
+
+; Comprueba la existencia tratando al conjunto como una función:
+(#{1 2 3} 1) ; => 1
+(#{1 2 3} 4) ; => nil
+
+; Hay más funciones en el espacio de nombre clojure.sets
+
+; Patrones útiles
+;;;;;;;;;;;;;;;;;
+
+; Las construcciones lógicas en clojure son macros, y tienen el mismo aspecto
+; que todo lo demás
+(if false "a" "b") ; => "b"
+(if false "a") ; => nil
+
+; Usa let para crear una binding (asociación) temporal
+(let [a 1 b 2]
+  (> a b)) ; => false
+
+; Agrupa expresiones con do
+(do
+  (print "Hello")
+  "World") ; => "World" (prints "Hello")
+
+; Las funciones tienen un do implicito
+(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")
+
+; De igual forma let
+(let [name "Urkel"]
+  (print "Saying hello to " name)
+  (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
+
+; Modulos
+;;;;;;;;;;;;;;;
+
+; Usa use para obtener todas las funciones del modulo
+(use 'clojure.set)
+
+; Ahora podemos usar 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 modulo
+(require 'clojure.string)
+
+; Usa / para llamar funciones de un modulo
+; Aquí, el modulo 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 literal)
+
+; 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 y útil librería estándar, así que
+; querrás aprender como llegar a ella.
+
+; Usa import para cargar un modulo 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 clojure usa para manejar
+; el estado persistente. Hay algunas cuantas construcciones en clojure que
+; usan esto.
+
+; Un atom es el más simple. Dale una 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 y obtener su valor
+my-atom  ;=> Atom<#...> (Regresa el objeto Atom)
+@my-atom ; => {:a 1 :b 2}
+
+; Aquí está un simple contador usando un atom
+(def counter (atom 0))
+(defn inc-counter []
+  (swap! counter inc))
+
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+(inc-counter)
+
+@counter ; => 5
+
+; Otros constructores 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
+encaminarte.
+
+Clojure.org tiene muchos artículos:
+[http://clojure.org/](http://clojure.org/)
+
+Clojuredocs.org tiene documentación con ejemplos para la mayoría de
+funciones core:
+[http://clojuredocs.org/quickref/Clojure%20Core](http://clojuredocs.org/quickref/Clojure%20Core)
+
+4Clojure es una grandiosa forma de fortalecer tus habilidades con clojure/FP:
+[http://www.4clojure.com/](http://www.4clojure.com/)
+
+Clojure-doc.org (sí, de verdad) tiene un número de artículos para empezar:
+[http://clojure-doc.org/](http://clojure-doc.org/)
-- 
cgit v1.2.3


From 3a09a727ac9720df81a2fcea4efff57e8863f959 Mon Sep 17 00:00:00 2001
From: Guillermo Vaya <guivaya@gmail.com>
Date: Tue, 3 Sep 2013 00:25:40 +0200
Subject: From robot to human, corrected gender, some clojure idioms reverted
 to unsranslated (no one uses the spanish translation for some), general
 review

---
 es-es/clojure-es.html.markdown | 190 ++++++++++++++++++++---------------------
 1 file changed, 94 insertions(+), 96 deletions(-)

(limited to 'es-es')

diff --git a/es-es/clojure-es.html.markdown b/es-es/clojure-es.html.markdown
index 7102b361..1ccdc50e 100644
--- a/es-es/clojure-es.html.markdown
+++ b/es-es/clojure-es.html.markdown
@@ -5,39 +5,40 @@ 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 para la Máquina Virtual
-de Java. Tiene un énfasis más fuerte en la [programación funcional](https://es.wikipedia.org/wiki/Programación_funcional) pura
-que Common Lisp, pero incluye varias facilidades de [SMT](https://es.wikipedia.org/wiki/Memoria_transacional) para manipular
+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 manejar el procesamiento concurrente muy simple,
+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 nueva)
+(Necesitas la versión de Clojure 1.2 o posterior)
 
 
 ```clojure
-; Los comentatios inician con punto y coma.
+; Los comentatios comienzan con punto y coma.
 
-; Clojure es escrito en "forms" (patrones), los cuales son solo
-; listas de objectos dentro de paréntesis, separados por espacios en blanco.
+; 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 a llamar, y que el resto son argumentos.
+; 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.
 
-; La primera llamada en un archivo debe ser ns, para establecer el espacio de
-; nombre
+; El primer form en un archivo debe ser ns, para establecer el namespace (espacio de
+; nombres)
 (ns learnclojure)
 
-; Más ejemplos básicos:
+; Algunos ejemplos básicos:
 
-; str creará una cadena de caracteres a partir de sus argumentos
+; str crea una cadena de caracteres a partir de sus argumentos
 (str "Hello" " " "World") ; => "Hello World"
 
-; Las matemáticas son sencillas
+; Las operaciones matemáticas son sencillas
 (+ 1 1) ; => 2
 (- 2 1) ; => 1
 (* 1 2) ; => 2
@@ -47,44 +48,44 @@ y a menudo automáticamente.
 (= 1 1) ; => true
 (= 2 1) ; => false
 
-; Necesitas de la negación para la lógica, también
+; También es necesaria la negación para las operaciones lógicas
 (not true) ; => false
 
-; Los patrones anidados funcionan como lo esperas
+; 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,cadenas de
-; caracteres y números.
-; Usa class para inspeccionarlos.
-(class 1); Los enteros literales son java.lang.Long por default
-(class 1.); Los flotantes literales son java.lang.Double
-(class ""); Las cadenas de caracteres van entre comillas dobles, y son
+; 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" es llamado nil
+(class nil); El valor "null" se escribe nil
 
-; Si quieres crear una lista literal de datos, precede la con una comilla
+; Si quieres crear una lista de datos, precedela con una comilla
 ; simple para evitar su evaluación
 '(+ 1 2) ; => (+ 1 2)
-; (abreviatura de (quote (+ 1 2))
+; (que es una abreviatura de (quote (+ 1 2))
 
-; Puedes evaluar una lista precedida por comilla simple con eval
+; Puedes evaluar una lista precedida por comilla  con eval
 (eval '(+ 1 2)) ; => 3
 
 ; Colecciones & Secuencias
 ;;;;;;;;;;;;;;;;;;;
 
-; Las Listas están basadas en listas enlazadas, mientras que los Vectores en
-; arreglos.
-; ¡Los Vectores y las Listas son clases de Java también!
+; 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 precidirla con
-; comilla simple para evitar que el lector piense que es una función.
+; 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
@@ -108,23 +109,23 @@ y a menudo automáticamente.
 (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 agrega al inicio. Para vectores, al final.
+; 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, map para actuar sobre colecciones
+; 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 reducirlos
+; Usa reduce para combinar sus elementos
 (reduce + [1 2 3 4])
 ; = (+ (+ (+ 1 2) 3) 4)
 ; => 10
 
-; reduce puede tomar un argumento como valor inicial también
+; reduce puede tener un argumento indicando su valor inicial.
 (reduce conj [] '(3 2 1))
 ; = (conj (conj (conj [] 3) 2) 1)
 ; => [3 2 1]
@@ -132,14 +133,14 @@ y a menudo automáticamente.
 ; Funciones
 ;;;;;;;;;;;;;;;;;;;;;
 
-; Usa fn para crear nuevas funciones. Una función siempre regresa
+; Usa fn para crear nuevas funciones. Una función siempre devuelve
 ; su última expresión
 (fn [] "Hello World") ; => fn
 
-; (Necesitas encerrarlo en paréntesis para llamarlo)
+; (Necesitas rodearlo con paréntesis para invocarla)
 ((fn [] "Hello World")) ; => "Hello World"
 
-; Puedes crear una var (variable) usando def
+; Puedes crear una var (variable) mediante def
 (def x 1)
 x ; => 1
 
@@ -147,32 +148,32 @@ x ; => 1
 (def hello-world (fn [] "Hello World"))
 (hello-world) ; => "Hello World"
 
-; Puedes acortar este proceso al usar defn
+; Puedes defn como atajo para lo anterior
 (defn hello-world [] "Hello World")
 
-; El [] es el vector de argumentos para la función.
+; El [] es el vector de argumentos de la función.
 (defn hello [name]
   (str "Hello " name))
 (hello "Steve") ; => "Hello Steve"
 
-; Puedes usar también esta abreviatura para crear funciones:
+; Otra abreviatura para crear funciones es:
 (def hello2 #(str "Hello " %1))
 (hello2 "Fanny") ; => "Hello Fanny"
 
-; Puedes tener funciones multi-variadic (múltiple numero variable de
-; argumentos), también
+; 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 colocar argumentos extras dentro de una seq por ti
+; 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)"
 
-; Puedes mezclar argumentos regulares y dentro de una seq
+; 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)
@@ -182,17 +183,17 @@ x ; => 1
 ; Mapas
 ;;;;;;;;;;
 
-; Mapas de Hash y mapas de Arreglos comparten una interfaz. Los mapas de Hash
-; tienen búsquedas más rápidas pero no mantienen el orden de las llaves.
+; 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 Arreglos serán convertidos en mapas de Hash en la mayoría de
-; operaciones si crecen lo suficiente, así que no necesitas preocuparte.
+; 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 llaves, pero usualmente las
-; keywords (llaves) son mejor.
-; Las keywords son como cadenas de caracteres con algunas ventajas en eficiencia
+; 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})
@@ -201,31 +202,31 @@ 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 siempre tratadas como espacios en blanco y no hacen
+; Por cierto, las comas son equivalentes a espacios en blanco y no hacen
 ; nada.
 
-; Recupera un valor de un mapa tratando la como una función
+; 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 intentes ésto con cadenas de caracteres.
+; No lo intentes con strings.
 ;("a" stringmap)
 ; => Exception: java.lang.String cannot be cast to clojure.lang.IFn
 
-; Recuperando un valor no presente regresa nil
+; Si preguntamos por una clave que no existe nos devuelve nil
 (stringmap "d") ; => nil
 
-; Usa assoc para agregar nuevas llaves a los mapas de Hash
+; 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!
+; Pero recuerda, ¡los tipos de Clojure son inmutables!
 keymap ; => {:a 1, :b 2, :c 3}
 
-; Usa dissoc para remover llaves
+; Usa dissoc para eliminar llaves
 (dissoc keymap :a :b) ; => {:c 3}
 
 ; Conjuntos
@@ -234,70 +235,70 @@ keymap ; => {:a 1, :b 2, :c 3}
 (class #{1 2 3}) ; => clojure.lang.PersistentHashSet
 (set [1 2 3 1 2 3 3 2 1 3 2 1]) ; => #{1 2 3}
 
-; Agrega un miembro con conj
+; Añade un elemento con conj
 (conj #{1 2 3} 4) ; => #{1 2 3 4}
 
-; Remueve uno con disj
+; Elimina elementos con disj
 (disj #{1 2 3} 1) ; => #{2 3}
 
-; Comprueba la existencia tratando al conjunto como una función:
+; 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 espacio de nombre clojure.sets
+; Hay más funciones en el namespace clojure.sets
 
 ; Patrones útiles
 ;;;;;;;;;;;;;;;;;
 
-; Las construcciones lógicas en clojure son macros, y tienen el mismo aspecto
-; que todo lo demás
+; 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 una binding (asociación) temporal
+; Usa let para crear un binding (asociación) temporal
 (let [a 1 b 2]
   (> a b)) ; => false
 
-; Agrupa expresiones con do
+; Agrupa expresiones mediante do
 (do
   (print "Hello")
   "World") ; => "World" (prints "Hello")
 
-; Las funciones tienen un do implicito
+; 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")
 
-; De igual forma let
+; Y el let también
 (let [name "Urkel"]
   (print "Saying hello to " name)
   (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
 
-; Modulos
+; Módulos
 ;;;;;;;;;;;;;;;
 
-; Usa use para obtener todas las funciones del modulo
+; Usa use para obtener todas las funciones del módulo
 (use 'clojure.set)
 
-; Ahora podemos usar operaciones de conjuntos
+; 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 modulo
+; Usa require para importar un módulo
 (require 'clojure.string)
 
-; Usa / para llamar funciones de un modulo
-; Aquí, el modulo es clojure.string y la función es blank?
+; 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 literal)
+; (#"" es una expresión regular)
 
 ; Puedes usar require (y use, pero no lo hagas) desde un espacio de nombre
 ; usando :require,
@@ -311,10 +312,10 @@ keymap ; => {:a 1, :b 2, :c 3}
 ; Java
 ;;;;;;;;;;;;;;;;;
 
-; Java tiene una enorme y útil librería estándar, así que
-; querrás aprender como llegar a ella.
+; Java tiene una enorme librería estándar, por lo que resulta util
+; aprender como interactuar con ella.
 
-; Usa import para cargar un modulo de java
+; Usa import para cargar un módulo de java
 (import java.util.Date)
 
 ; Puedes importar desde un ns también.
@@ -325,7 +326,7 @@ keymap ; => {:a 1, :b 2, :c 3}
 ; 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"
+; Usa "." para llamar a métodos o usa el atajo ".método"
 (. (Date.) getTime) ; <un timestamp>
 (.getTime (Date.)) ; exactamente la misma cosa
 
@@ -341,11 +342,11 @@ keymap ; => {:a 1, :b 2, :c 3}
 ; STM
 ;;;;;;;;;;;;;;;;;
 
-; Software Transactional Memory es un mecanismo que clojure usa para manejar
-; el estado persistente. Hay algunas cuantas construcciones en clojure que
-; usan esto.
+; 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 simple. Dale una valor inicial
+; Un atom es el más sencillo. Se le da un valor inicial
 (def my-atom (atom {}))
 
 ; Actualiza un atom con swap!
@@ -354,11 +355,11 @@ keymap ; => {:a 1, :b 2, :c 3}
 (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 y obtener su valor
+; Usa '@' para no referenciar al atom sino para obtener su valor
 my-atom  ;=> Atom<#...> (Regresa el objeto Atom)
 @my-atom ; => {:a 1 :b 2}
 
-; Aquí está un simple contador usando un atom
+; Un sencillo contador usando un atom sería
 (def counter (atom 0))
 (defn inc-counter []
   (swap! counter inc))
@@ -371,25 +372,22 @@ my-atom  ;=> Atom<#...> (Regresa el objeto Atom)
 
 @counter ; => 5
 
-; Otros constructores STM son refs y agents.
+; 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
-encaminarte.
+É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 tiene documentación con ejemplos para la mayoría de
-funciones core:
+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 grandiosa forma de fortalecer tus habilidades con clojure/FP:
+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 número de artículos para empezar:
+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/)
-- 
cgit v1.2.3


From d2ff3969a6f4aa66a3b13c15c600d758136060af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Olfran=20Jim=C3=A9nez?= <olfran@gmail.com>
Date: Tue, 3 Sep 2013 16:27:06 -0430
Subject: Spanish translation for the csharp article

---
 es-es/csharp-es.html.markdown | 631 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 631 insertions(+)
 create mode 100644 es-es/csharp-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/csharp-es.html.markdown b/es-es/csharp-es.html.markdown
new file mode 100644
index 00000000..7d1a1201
--- /dev/null
+++ b/es-es/csharp-es.html.markdown
@@ -0,0 +1,631 @@
+---
+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
+---
+
+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)
-- 
cgit v1.2.3


From b392e48e712e791152856ad7e72d743122154032 Mon Sep 17 00:00:00 2001
From: Adrian Espinosa <aespinosamoreno@gmail.com>
Date: Sun, 8 Sep 2013 19:43:37 +0200
Subject: Working on spanish translation

---
 es-es/go-es.html.markdown | 299 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 299 insertions(+)
 create mode 100644 es-es/go-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
new file mode 100644
index 00000000..5bc4844f
--- /dev/null
+++ b/es-es/go-es.html.markdown
@@ -0,0 +1,299 @@
+---
+name: Go
+category: language
+language: Go
+filename: learngo.go
+contributors:
+    - ["Sonia Keys", "https://github.com/soniakeys"]
+
+translators:
+	- ["Adrian Espinosa", "http://www.adrianespinosa.com"]
+
+---
+
+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 probemas 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 en día, y tiene características que ayudan con la programación a gran escala.
+Go viene con una librería estándar muy buena y una comunidad entusiasta.
+
+```go
+// Comentario de una sola línea
+/* Comentario 
+   multi línea */
+
+// La cláusula package aparece al comienzo de cada archivo fuente.
+// Main es un nombre especial que declara un ejecutable en vez de una librería.
+package main
+
+// La declaración Import declara los paquetes de librerías referenciados en este archivo.
+import (
+    "fmt"      // Un paquete en la librería estándar de Go
+    "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("Hello world!")
+
+    // Llama a otra función de este paquete.
+    beyondHello()
+}
+
+// Las funciones llevan parámetros entre paréntesis.
+// Si no hay parámetros, los paréntesis siguen siendo obligatorios.
+func beyondHello() {
+    var x int // Declaración de una variable. Las variables se deben declarar antes de 			  // utilizarlas.
+    x = 3     // Asignación de variables.
+    // Declaración "corta" con := para inferir el tipo, declarar y asignar.
+    y := 4
+    sum, prod := learnMultiple(x, y)        // función devuelve dos valores
+    fmt.Println("sum:", sum, "prod:", prod) // simple salida
+    learnTypes()                            // < y minutes, learn more!
+}
+
+// Las funciones pueden tener parámetros y (múltiples!) valores de retorno.
+func learnMultiple(x, y int) (sum, prod int) {
+    return x + y, x * y // devolver dos valores
+}
+
+// Algunos tipos incorporados y literales.
+func learnTypes() {
+    // La declaración corta suele darte lo que quieres.
+    s := "Learn Go!" // tipo cadena
+
+    s2 := ` Un tipo cadena "puro" puede incluir
+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.
+    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.
+    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 de uint8
+
+    // Los Arrays tienen un tamaño fijo a la hora de compilar.
+    var a4 [4]int           // un array de 4 ints, inicializados a 0
+    a3 := [...]int{3, 1, 5} // un array de 3 ints, inicializados como se indica
+
+    // Los Slices tienen tamaño dinámico. Los arrays y slices tienen sus ventajas
+    // y desventajas pero los casos de uso para los slices son más comunes.
+    s3 := []int{4, 5, 9}    // Comparar con a3. No hay puntos suspensivos
+    s4 := make([]int, 4)    // Asigna slices de 4 ints, inicializados a 0
+    var d2 [][]float64      // solo declaración, sin asignación
+    bs := []byte("a slice") // sintaxis de conversión de tipo
+
+    p, q := learnMemory() // declares p, q to be type pointer to int.
+    fmt.Println(*p, *q)   // * follows a pointer.  This prints two ints.
+
+    // Maps are a dynamically growable associative array type, like the
+    // hash or dictionary types of some other languages.
+    m := map[string]int{"three": 3, "four": 4}
+    m["one"] = 1
+
+    // Unused variables are an error in Go.
+    // The underbar lets you "use" a variable but discard its value.
+    _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs
+    // Output of course counts as using a variable.
+    fmt.Println(s, c, a4, s3, d2, m)
+
+    learnFlowControl() // back in the flow
+}
+
+// Go is fully garbage collected.  It has pointers but no pointer arithmetic.
+// You can make a mistake with a nil pointer, but not by incrementing a pointer.
+func learnMemory() (p, q *int) {
+    // Named return values p and q have type pointer to int.
+    p = new(int) // built-in function new allocates memory.
+    // The allocated int is initialized to 0, p is no longer nil.
+    s := make([]int, 20) // allocate 20 ints as a single block of memory
+    s[3] = 7             // assign one of them
+    r := -2              // declare another local variable
+    return &s[3], &r     // & takes the address of an object.
+}
+
+func expensiveComputation() int {
+    return 1e6
+}
+
+func learnFlowControl() {
+    // If statements require brace brackets, and do not require parens.
+    if true {
+        fmt.Println("told ya")
+    }
+    // Formatting is standardized by the command line command "go fmt."
+    if false {
+        // pout
+    } else {
+        // gloat
+    }
+    // Use switch in preference to chained if statements.
+    x := 1
+    switch x {
+    case 0:
+    case 1:
+        // cases don't "fall through"
+    case 2:
+        // unreached
+    }
+    // Like if, for doesn't use parens either.
+    for x := 0; x < 3; x++ { // ++ is a statement
+        fmt.Println("iteration", x)
+    }
+    // x == 1 here.
+
+    // For is the only loop statement in Go, but it has alternate forms.
+    for { // infinite loop
+        break    // just kidding
+        continue // unreached
+    }
+    // As with for, := in an if statement means to declare and assign y first,
+    // then test y > x.
+    if y := expensiveComputation(); y > x {
+        x = y
+    }
+    // Function literals are closures.
+    xBig := func() bool {
+        return x > 100 // references x declared above switch statement.
+    }
+    fmt.Println("xBig:", xBig()) // true (we last assigned 1e6 to x)
+    x /= 1e5                     // this makes it == 10
+    fmt.Println("xBig:", xBig()) // false now
+
+    // When you need it, you'll love it.
+    goto love
+love:
+
+    learnInterfaces() // Good stuff coming up!
+}
+
+// Define Stringer as an interface type with one method, String.
+type Stringer interface {
+    String() string
+}
+
+// Define pair as a struct with two fields, ints named x and y.
+type pair struct {
+    x, y int
+}
+
+// Define a method on type pair.  Pair now implements Stringer.
+func (p pair) String() string { // p is called the "receiver"
+    // Sprintf is another public function in package fmt.
+    // Dot syntax references fields of p.
+    return fmt.Sprintf("(%d, %d)", p.x, p.y)
+}
+
+func learnInterfaces() {
+    // Brace syntax is a "struct literal."  It evaluates to an initialized
+    // struct.  The := syntax declares and initializes p to this struct.
+    p := pair{3, 4}
+    fmt.Println(p.String()) // call String method of p, of type pair.
+    var i Stringer          // declare i of interface type Stringer.
+    i = p                   // valid because pair implements Stringer
+    // Call String method of i, of type Stringer.  Output same as above.
+    fmt.Println(i.String())
+
+    // Functions in the fmt package call the String method to ask an object
+    // for a printable representation of itself.
+    fmt.Println(p) // output same as above. Println calls String method.
+    fmt.Println(i) // output same as above
+
+    learnErrorHandling()
+}
+
+func learnErrorHandling() {
+    // ", ok" idiom used to tell if something worked or not.
+    m := map[int]string{3: "three", 4: "four"}
+    if x, ok := m[1]; !ok { // ok will be false because 1 is not in the map.
+        fmt.Println("no one there")
+    } else {
+        fmt.Print(x) // x would be the value, if it were in the map.
+    }
+    // An error value communicates not just "ok" but more about the problem.
+    if _, err := strconv.Atoi("non-int"); err != nil { // _ discards value
+        // prints "strconv.ParseInt: parsing "non-int": invalid syntax"
+        fmt.Println(err)
+    }
+    // We'll revisit interfaces a little later.  Meanwhile,
+    learnConcurrency()
+}
+
+// c is a channel, a concurrency-safe communication object.
+func inc(i int, c chan int) {
+    c <- i + 1 // <- is the "send" operator when a channel appears on the left.
+}
+
+// We'll use inc to increment some numbers concurrently.
+func learnConcurrency() {
+    // Same make function used earlier to make a slice.  Make allocates and
+    // initializes slices, maps, and channels.
+    c := make(chan int)
+    // Start three concurrent goroutines.  Numbers will be incremented
+    // concurrently, perhaps in parallel if the machine is capable and
+    // properly configured.  All three send to the same channel.
+    go inc(0, c) // go is a statement that starts a new goroutine.
+    go inc(10, c)
+    go inc(-805, c)
+    // Read three results from the channel and print them out.
+    // There is no telling in what order the results will arrive!
+    fmt.Println(<-c, <-c, <-c) // channel on right, <- is "receive" operator.
+
+    cs := make(chan string)       // another channel, this one handles strings.
+    cc := make(chan chan string)  // a channel of string channels.
+    go func() { c <- 84 }()       // start a new goroutine just to send a value
+    go func() { cs <- "wordy" }() // again, for cs this time
+    // Select has syntax like a switch statement but each case involves
+    // a channel operation.  It selects a case at random out of the cases
+    // that are ready to communicate.
+    select {
+    case i := <-c: // the value received can be assigned to a variable
+        fmt.Printf("it's a %T", i)
+    case <-cs: // or the value received can be discarded
+        fmt.Println("it's a string")
+    case <-cc: // empty channel, not ready for communication.
+        fmt.Println("didn't happen.")
+    }
+    // At this point a value was taken from either c or cs.  One of the two
+    // goroutines started above has completed, the other will remain blocked.
+
+    learnWebProgramming() // Go does it.  You want to do it too.
+}
+
+// A single function from package http starts a web server.
+func learnWebProgramming() {
+    // ListenAndServe first parameter is TCP address to listen at.
+    // Second parameter is an interface, specifically http.Handler.
+    err := http.ListenAndServe(":8080", pair{})
+    fmt.Println(err) // don't ignore errors
+}
+
+// Make pair an http.Handler by implementing its only method, ServeHTTP.
+func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+    // Serve data with a method of http.ResponseWriter
+    w.Write([]byte("You learned Go in Y minutes!"))
+}
+```
+
+## Further Reading
+
+The root of all things Go is the [official Go web site](http://golang.org/).
+There you can follow the tutorial, play interactively, and read lots.
+
+The language definition itself is highly recommended.  It's easy to read
+and amazingly short (as language definitions go these days.)
+
+On the reading list for students of Go is the source code to the standard
+library.  Comprehensively documented, it demonstrates the best of readable
+and understandable Go, Go style, and Go idioms.  Click on a function name
+in the documentation and the source code comes up!
+
-- 
cgit v1.2.3


From 38ff402322c0fd4fefbd2277bfba982e4bb011de Mon Sep 17 00:00:00 2001
From: Adrian Espinosa <aespinosamoreno@gmail.com>
Date: Mon, 9 Sep 2013 16:40:07 +0200
Subject: Half done through the translation

I need moar time gosh >.<
---
 es-es/go-es.html.markdown | 89 ++++++++++++++++++++++++-----------------------
 1 file changed, 45 insertions(+), 44 deletions(-)

(limited to 'es-es')

diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
index 5bc4844f..52f9fc5b 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -48,7 +48,8 @@ func main() {
 // Las funciones llevan parámetros entre paréntesis.
 // Si no hay parámetros, los paréntesis siguen siendo obligatorios.
 func beyondHello() {
-    var x int // Declaración de una variable. Las variables se deben declarar antes de 			  // utilizarlas.
+    var x int // Declaración de una variable. Las variables se deben declarar antes de 
+    // utilizarlas.
     x = 3     // Asignación de variables.
     // Declaración "corta" con := para inferir el tipo, declarar y asignar.
     y := 4
@@ -92,33 +93,33 @@ saltos de línea.` // mismo tipo cadena
     var d2 [][]float64      // solo declaración, sin asignación
     bs := []byte("a slice") // sintaxis de conversión de tipo
 
-    p, q := learnMemory() // declares p, q to be type pointer to int.
-    fmt.Println(*p, *q)   // * follows a pointer.  This prints two ints.
+    p, q := learnMemory() // declara p, q para ser un tipo puntero a int.
+    fmt.Println(*p, *q)   // * sigue un puntero. Esto imprime dos ints.
 
-    // Maps are a dynamically growable associative array type, like the
-    // hash or dictionary types of some other languages.
+    // Los Maps son arrays asociativos dinámicos, como los hash o diccionarios
+    // de otros lenguajes
     m := map[string]int{"three": 3, "four": 4}
     m["one"] = 1
 
-    // Unused variables are an error in Go.
-    // The underbar lets you "use" a variable but discard its value.
+    // 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
-    // Output of course counts as using a variable.
+    // Esto cuenta como utilización de variables.
     fmt.Println(s, c, a4, s3, d2, m)
 
-    learnFlowControl() // back in the flow
+    learnFlowControl() // vuelta al flujo
 }
 
-// Go is fully garbage collected.  It has pointers but no pointer arithmetic.
-// You can make a mistake with a nil pointer, but not by incrementing a pointer.
+// Go posee recolector de basura. Tiene puntero pero no aritmética de punteros.
+// Puedes cometer un errores con un puntero nil, pero no incrementando un puntero.
 func learnMemory() (p, q *int) {
-    // Named return values p and q have type pointer to int.
-    p = new(int) // built-in function new allocates memory.
-    // The allocated int is initialized to 0, p is no longer nil.
-    s := make([]int, 20) // allocate 20 ints as a single block of memory
-    s[3] = 7             // assign one of them
-    r := -2              // declare another local variable
-    return &s[3], &r     // & takes the address of an object.
+    // q y p tienen un tipo puntero a int.
+    p = new(int) // función incorporada que asigna memoria.
+    // La asignación de int se inicializa a 0, p ya no es nil.
+    s := make([]int, 20) // asigna 20 ints a un solo bloque de memoria.
+    s[3] = 7             // asignar uno de ellos
+    r := -2              // declarar otra variable local
+    return &s[3], &r     // & toma la dirección de un objeto.
 }
 
 func expensiveComputation() int {
@@ -126,69 +127,69 @@ func expensiveComputation() int {
 }
 
 func learnFlowControl() {
-    // If statements require brace brackets, and do not require parens.
+    // La declaración If requiere llaves, pero no paréntesis.
     if true {
         fmt.Println("told ya")
     }
-    // Formatting is standardized by the command line command "go fmt."
+    // El formato está estandarizado por el comando "go fmt."
     if false {
         // pout
     } else {
         // gloat
     }
-    // Use switch in preference to chained if statements.
+    // Utiliza switch preferiblemente para if encadenados.
     x := 1
     switch x {
     case 0:
     case 1:
-        // cases don't "fall through"
+        // los cases no se mezclan, no requieren de "break"
     case 2:
-        // unreached
+        // no llega
     }
-    // Like if, for doesn't use parens either.
-    for x := 0; x < 3; x++ { // ++ is a statement
+    // Como if, for no utiliza paréntesis tampoco.
+    for x := 0; x < 3; x++ { // ++ es una sentencia
         fmt.Println("iteration", x)
     }
-    // x == 1 here.
+    // x == 1 aqui.
 
-    // For is the only loop statement in Go, but it has alternate forms.
-    for { // infinite loop
-        break    // just kidding
-        continue // unreached
+    // For es la única sentencia de bucle en Go, pero tiene formas alternativas.
+    for { // bucle infinito
+        break    // solo bromeaba!
+        continue // no llega
     }
-    // As with for, := in an if statement means to declare and assign y first,
-    // then test y > x.
+    // Como en for, := en una sentencia if significa declarar y asignar primero,
+    // luego comprobar y > x.
     if y := expensiveComputation(); y > x {
         x = y
     }
-    // Function literals are closures.
+    // Los literales de funciones son "closures".
     xBig := func() bool {
-        return x > 100 // references x declared above switch statement.
+        return x > 100 // referencia a x declarada encima de la sentencia switch.
     }
-    fmt.Println("xBig:", xBig()) // true (we last assigned 1e6 to x)
-    x /= 1e5                     // this makes it == 10
-    fmt.Println("xBig:", xBig()) // false now
+    fmt.Println("xBig:", xBig()) // verdadero (la última vez asignamos 1e6 a x)
+    x /= 1e5                     // esto lo hace  == 10
+    fmt.Println("xBig:", xBig()) // ahora es falso
 
-    // When you need it, you'll love it.
+    // Cuando lo necesites, te encantará.
     goto love
 love:
 
-    learnInterfaces() // Good stuff coming up!
+    learnInterfaces() // Buen material dentro de poco!
 }
 
-// Define Stringer as an interface type with one method, String.
+// Define Stringer como un tipo interfaz con un método, String.
 type Stringer interface {
     String() string
 }
 
-// Define pair as a struct with two fields, ints named x and y.
+// Define pair como un struct con dos campos int, x e y.
 type pair struct {
     x, y int
 }
 
-// Define a method on type pair.  Pair now implements Stringer.
-func (p pair) String() string { // p is called the "receiver"
-    // Sprintf is another public function in package fmt.
+// Define un método del tipo pair. Pair ahora implementa Stringer.
+func (p pair) String() string { // p se llama "recibidor"
+    // Sprintf es otra función pública del paquete fmt.
     // Dot syntax references fields of p.
     return fmt.Sprintf("(%d, %d)", p.x, p.y)
 }
-- 
cgit v1.2.3


From f9b2c181a3b6e5fe67c965f11addc8e5a907b2bd Mon Sep 17 00:00:00 2001
From: Adrian Espinosa <aespinosamoreno@gmail.com>
Date: Tue, 10 Sep 2013 00:42:39 +0200
Subject: Go spanish translation.

---
 es-es/go-es.html.markdown | 122 +++++++++++++++++++++++-----------------------
 1 file changed, 61 insertions(+), 61 deletions(-)

(limited to 'es-es')

diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
index 52f9fc5b..f2b069d6 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -8,11 +8,11 @@ contributors:
 
 translators:
 	- ["Adrian Espinosa", "http://www.adrianespinosa.com"]
-
+lang: es-es
 ---
 
 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 probemas reales.
+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 en día, y tiene características que ayudan con la programación a gran escala.
@@ -190,111 +190,111 @@ type pair struct {
 // Define un método del tipo pair. Pair ahora implementa Stringer.
 func (p pair) String() string { // p se llama "recibidor"
     // Sprintf es otra función pública del paquete fmt.
-    // Dot syntax references fields of p.
+    // La sintaxis con punto referencia campos de p.
     return fmt.Sprintf("(%d, %d)", p.x, p.y)
 }
 
 func learnInterfaces() {
-    // Brace syntax is a "struct literal."  It evaluates to an initialized
-    // struct.  The := syntax declares and initializes p to this struct.
+    // La sintaxis de llaves es un "literal struct". Evalúa a un struct
+    // inicializado.  La sintaxis := declara e inicializa p a este struct.
     p := pair{3, 4}
-    fmt.Println(p.String()) // call String method of p, of type pair.
-    var i Stringer          // declare i of interface type Stringer.
-    i = p                   // valid because pair implements Stringer
-    // Call String method of i, of type Stringer.  Output same as above.
+    fmt.Println(p.String()) // llamar al método String de p, de tipo pair.
+    var i Stringer          // declarar i como interfaz tipo Stringer.
+    i = p                   // válido porque pair implementa Stringer
+    // Llamar al metodo String de i, de tipo Stringer. Misma salida que arriba
     fmt.Println(i.String())
 
-    // Functions in the fmt package call the String method to ask an object
-    // for a printable representation of itself.
-    fmt.Println(p) // output same as above. Println calls String method.
-    fmt.Println(i) // output same as above
+    // Las funciones en el paquete fmt llaman al método String para preguntar a un objeto
+    // por una versió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.
 
     learnErrorHandling()
 }
 
 func learnErrorHandling() {
-    // ", ok" idiom used to tell if something worked or not.
+    // ", ok" forma utilizada para saber si algo funcionó o no.
     m := map[int]string{3: "three", 4: "four"}
-    if x, ok := m[1]; !ok { // ok will be false because 1 is not in the map.
+    if x, ok := m[1]; !ok { // ok será falso porque 1 no está en el map.
         fmt.Println("no one there")
     } else {
-        fmt.Print(x) // x would be the value, if it were in the map.
+        fmt.Print(x) // x sería el valor, si estuviera en el map.
     }
-    // An error value communicates not just "ok" but more about the problem.
-    if _, err := strconv.Atoi("non-int"); err != nil { // _ discards value
-        // prints "strconv.ParseInt: parsing "non-int": invalid syntax"
+    // Un valor de error comunica más información sobre el problema aparte de "ok".
+    if _, err := strconv.Atoi("non-int"); err != nil { // _ descarta el valor
+        // imprime "strconv.ParseInt: parsing "non-int": invalid syntax"
         fmt.Println(err)
     }
-    // We'll revisit interfaces a little later.  Meanwhile,
+    // Revisarmeos las interfaces más tarde. Mientras tanto,
     learnConcurrency()
 }
 
-// c is a channel, a concurrency-safe communication object.
+// c es un canal,  un objeto de comunicación de concurrencia segura.
 func inc(i int, c chan int) {
-    c <- i + 1 // <- is the "send" operator when a channel appears on the left.
+    c <- i + 1 // <- es el operador "enviar" cuando un canal aparece a la izquierda.
 }
 
-// We'll use inc to increment some numbers concurrently.
+// Utilizaremos inc para incrementar algunos números concurrentemente.
 func learnConcurrency() {
-    // Same make function used earlier to make a slice.  Make allocates and
-    // initializes slices, maps, and channels.
+    // Misma función make utilizada antes para crear un slice. Make asigna e
+    // inicializa slices, maps, y channels.
     c := make(chan int)
-    // Start three concurrent goroutines.  Numbers will be incremented
-    // concurrently, perhaps in parallel if the machine is capable and
-    // properly configured.  All three send to the same channel.
-    go inc(0, c) // go is a statement that starts a new goroutine.
+    // Iniciar tres goroutines 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 channel.
+    go inc(0, c) // go es una sentencia que inicia una nueva goroutine.
     go inc(10, c)
     go inc(-805, c)
-    // Read three results from the channel and print them out.
-    // There is no telling in what order the results will arrive!
-    fmt.Println(<-c, <-c, <-c) // channel on right, <- is "receive" operator.
-
-    cs := make(chan string)       // another channel, this one handles strings.
-    cc := make(chan chan string)  // a channel of string channels.
-    go func() { c <- 84 }()       // start a new goroutine just to send a value
-    go func() { cs <- "wordy" }() // again, for cs this time
-    // Select has syntax like a switch statement but each case involves
-    // a channel operation.  It selects a case at random out of the cases
-    // that are ready to communicate.
+    // Leer los tres resultados del channel e imprimirlos.
+    // No se puede saber en que orden llegarán los resultados!
+    fmt.Println(<-c, <-c, <-c) // channel a la derecha, <- es el operador "recibir".
+
+    cs := make(chan string)       // otro channel, este gestiona cadenas.
+    cc := make(chan chan string)  // un channel de cadenas de channels.
+    go func() { c <- 84 }()       // iniciar una nueva goroutine solo para enviar un valor.
+    go func() { cs <- "wordy" }() // otra vez, para cs en esta ocasión
+    // Select tiene una sintáxis parecida a la sentencia switch pero cada caso involucra
+    // una operacion de channels. Selecciona un caso de forma aleatoria de los casos
+    // que están listos para comunicarse.
     select {
-    case i := <-c: // the value received can be assigned to a variable
+    case i := <-c: // el valor recibido puede ser asignado a una variable
         fmt.Printf("it's a %T", i)
-    case <-cs: // or the value received can be discarded
+    case <-cs: // o el valor puede ser descartado
         fmt.Println("it's a string")
-    case <-cc: // empty channel, not ready for communication.
+    case <-cc: // channel vacío, no está listo para la comunicación.
         fmt.Println("didn't happen.")
     }
-    // At this point a value was taken from either c or cs.  One of the two
-    // goroutines started above has completed, the other will remain blocked.
+    // En este punto un valor fue devuelvto de c o cs. Uno de las dos
+    // goroutines que se iniciaron se ha completado, la otrá permancerá bloqueada.
 
-    learnWebProgramming() // Go does it.  You want to do it too.
+    learnWebProgramming() // Go lo hace. Tu también quieres hacerlo.
 }
 
-// A single function from package http starts a web server.
+// Una simple función del paquete http inicia un servidor web.
 func learnWebProgramming() {
-    // ListenAndServe first parameter is TCP address to listen at.
-    // Second parameter is an interface, specifically http.Handler.
+    // El primer parámetro de la direccinón TCP a la que escuchar.
+    // El segundo parámetro es una interfaz, concretamente http.Handler.
     err := http.ListenAndServe(":8080", pair{})
-    fmt.Println(err) // don't ignore errors
+    fmt.Println(err) // no ignorar errores
 }
 
-// Make pair an http.Handler by implementing its only method, ServeHTTP.
+// Haz pair un http.Handler implementando su único método, ServeHTTP.
 func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-    // Serve data with a method of http.ResponseWriter
+    // Servir datos con un método de http.ResponseWriter
     w.Write([]byte("You learned Go in Y minutes!"))
 }
 ```
 
-## Further Reading
+## Para leer más 
 
-The root of all things Go is the [official Go web site](http://golang.org/).
-There you can follow the tutorial, play interactively, and read lots.
+La raíz de todas las cosas de Go es la [web oficial de Go](http://golang.org/).
+Ahí puedes seguir el tutorial, jugar interactivamente y leer mucho.
 
-The language definition itself is highly recommended.  It's easy to read
-and amazingly short (as language definitions go these days.)
+La propia definición del lenguaje también está altamente recomendada. Es fácil de leer
+e increíblemente corta (como otras definiciones de lenguajes hoy en día)
 
-On the reading list for students of Go is the source code to the standard
-library.  Comprehensively documented, it demonstrates the best of readable
-and understandable Go, Go style, and Go idioms.  Click on a function name
-in the documentation and the source code comes up!
+En la lista de lectura de estudiantes de Go está el código fuente de la
+librería estándar. Muy bien documentada, demuestra lo mejor de Go leíble, comprendible,
+estilo Go y formas Go. Pincha en el nombre de una función en la documentación
+y te aparecerá el código fuente!
 
-- 
cgit v1.2.3


From 2ab5910d38224a2d529bcbf249b32018b5eceabd Mon Sep 17 00:00:00 2001
From: Adrian Espinosa <aespinosamoreno@gmail.com>
Date: Tue, 10 Sep 2013 00:44:29 +0200
Subject: Spanish translation fix.

---
 es-es/go-es.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
index f2b069d6..6f65a6ad 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -5,10 +5,11 @@ language: Go
 filename: learngo.go
 contributors:
     - ["Sonia Keys", "https://github.com/soniakeys"]
-
 translators:
 	- ["Adrian Espinosa", "http://www.adrianespinosa.com"]
 lang: es-es
+
+
 ---
 
 Go fue creado por la necesidad de hacer el trabajo rápidamente.  No es la última
-- 
cgit v1.2.3


From c515c37bd9889b07aa3fee73bbc7f5a2a32e0bb0 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Thu, 12 Sep 2013 09:53:20 -0700
Subject: Fix c# es

---
 es-es/csharp-es.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'es-es')

diff --git a/es-es/csharp-es.html.markdown b/es-es/csharp-es.html.markdown
index 7d1a1201..ef26d8ce 100644
--- a/es-es/csharp-es.html.markdown
+++ b/es-es/csharp-es.html.markdown
@@ -6,6 +6,7 @@ contributors:
 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
-- 
cgit v1.2.3


From 1dd0e00f2249526520b047c6852d22a7ee2df7ad Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Fri, 13 Sep 2013 10:28:48 -0700
Subject: Fixed a bunch of headers

---
 es-es/go-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
index 6f65a6ad..434f6713 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -6,7 +6,7 @@ filename: learngo.go
 contributors:
     - ["Sonia Keys", "https://github.com/soniakeys"]
 translators:
-	- ["Adrian Espinosa", "http://www.adrianespinosa.com"]
+    - ["Adrian Espinosa", "http://www.adrianespinosa.com"]
 lang: es-es
 
 
-- 
cgit v1.2.3


From abb39e92d4bede85777e11c50fb97ae1bee4215f Mon Sep 17 00:00:00 2001
From: Francisco Gomez <mail@frncscgmz.me>
Date: Wed, 18 Sep 2013 11:58:59 -0700
Subject: Perl spanish translation.

---
 es-es/perl-es.html.markdown | 157 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 157 insertions(+)
 create mode 100644 es-es/perl-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/perl-es.html.markdown b/es-es/perl-es.html.markdown
new file mode 100644
index 00000000..b1327997
--- /dev/null
+++ b/es-es/perl-es.html.markdown
@@ -0,0 +1,157 @@
+---
+name: perl
+category: language
+language: perl
+filename: learnperl-es.pl
+contributors:
+    - ["Francisco Gomez", "http://github.com/frncscgmz"]
+---
+
+Perl 5 es un lenguaje de programación altamente capaz, rico en características con mas 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
+# Comentarios de una sola linea 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.
+
+### 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"};
+
+#  Puedes usar un espacio en blanco y el operador "=>" para asignarlos mas
+#  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.
+
+#### Estructuras condicionales y de ciclos
+
+# Perl tiene la mayoría de las estructuras condicionales y de ciclos mas 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
+print "Yow!" if $zippy;
+print "No tenemos bananas" unless $bananas;
+
+# while
+  while ( condicion ) {
+                  ...
+               }
+
+
+# for y foreach
+for ($i = 0; $i <= $max; $i++) {
+                  ...
+               }
+
+foreach (@array) {
+                   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.
+# Sin embargo, resumiendo:
+
+# Pareo 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 e I/O
+
+# Puedes 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.
+
+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 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. 
+
+perlfaq contiene preguntas y respuestas relacionadas con muchas tareas comunes, y algunas veces provee sugerencias sobre buenos módulos CPAN para usar.
+
+#### Material de Lectura
+
+     - [perl-tutorial](http://perl-tutorial.org/)
+     - [Aprende en www.perl.com](http://www.perl.org/learn.html)
+     - [perldoc](http://perldoc.perl.org/)
+     - y perl incorporado: `perldoc perlintro`
-- 
cgit v1.2.3


From bc4fbec14d8d343aa2da7a3bcab97fcce71867b8 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Thu, 19 Sep 2013 23:23:20 -0700
Subject: Updated perl-es

---
 es-es/perl-es.html.markdown | 3 +++
 1 file changed, 3 insertions(+)

(limited to 'es-es')

diff --git a/es-es/perl-es.html.markdown b/es-es/perl-es.html.markdown
index b1327997..4f0c26c1 100644
--- a/es-es/perl-es.html.markdown
+++ b/es-es/perl-es.html.markdown
@@ -4,7 +4,10 @@ category: language
 language: perl
 filename: learnperl-es.pl
 contributors:
+    - ["Korjavin Ivan", "http://github.com/korjavin"]
+translators:
     - ["Francisco Gomez", "http://github.com/frncscgmz"]
+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.
-- 
cgit v1.2.3


From a18773edbac72a994c57f44cb8d3644ebf701bc9 Mon Sep 17 00:00:00 2001
From: Guillermo Vaya <guillermo.vaya@gigas.com>
Date: Wed, 9 Oct 2013 11:21:55 +0200
Subject: Correct relevant fix from issue #374

---
 es-es/clojure-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/clojure-es.html.markdown b/es-es/clojure-es.html.markdown
index 1ccdc50e..150d0bb2 100644
--- a/es-es/clojure-es.html.markdown
+++ b/es-es/clojure-es.html.markdown
@@ -70,7 +70,7 @@ y a menudo automáticamente.
 ; 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))
+; (que es una abreviatura de (quote (+ 1 2)) )
 
 ; Puedes evaluar una lista precedida por comilla  con eval
 (eval '(+ 1 2)) ; => 3
-- 
cgit v1.2.3


From e0fbcf5b83f9dbc9185ef5b6e4d2fd2d35c4c915 Mon Sep 17 00:00:00 2001
From: Pablo Elices <pablodanielgomezelices@gmail.com>
Date: Sat, 12 Oct 2013 17:56:51 +0200
Subject: Better translation.

---
 es-es/coffeescript-es.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'es-es')

diff --git a/es-es/coffeescript-es.html.markdown b/es-es/coffeescript-es.html.markdown
index 78bb9be5..6bf430e6 100644
--- a/es-es/coffeescript-es.html.markdown
+++ b/es-es/coffeescript-es.html.markdown
@@ -44,7 +44,7 @@ math =
 #  "cube": function(x) { return x * square(x); }
 #}
 
-# Símbolos:
+# Número de argumentos variable:
 race = (winner, runners...) ->
   print winner, runners
 
@@ -52,6 +52,6 @@ race = (winner, runners...) ->
 alert "I knew it!" if elvis?
 #=> if(typeof elvis !== "undefined" && elvis !== null) { alert("I knew it!"); }
 
-# Colecciones por comprensión:
+# Listas:
 cubes = (math.cube num for num in list) #=> ...
 ```
-- 
cgit v1.2.3


From 9f1034674a4524946ae8b34cf26f4b9eb58e06e6 Mon Sep 17 00:00:00 2001
From: rscnt <raul_ascencio@lavabit.com>
Date: Mon, 25 Nov 2013 10:56:11 -0600
Subject: git -es

---
 es-es/git-es.html.markdown | 411 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 411 insertions(+)
 create mode 100644 es-es/git-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
new file mode 100644
index 00000000..2c439fc2
--- /dev/null
+++ b/es-es/git-es.html.markdown
@@ -0,0 +1,411 @@
+---
+category: tool
+tool: git
+contributors:
+    - ["Jake Prather", "http:#github.com/JakeHP"]
+translator:
+    - ["Raúl Ascencio", "http:#rscnt.github.io"]
+filename: LearnGit.txt
+language: es-es
+
+---
+
+Git es un sistema de control de versiones distribuido diseñado para manejar
+cualquier tipo de proyecto ya sea largos o pequeños, con velocidad y eficiencia.
+
+Git realiza esto haciendo "snapshots" del proyecto, con ello permite
+versionar y administrar nuestro código fuente.
+
+## Versionamiento, conceptos.
+
+### Que es el control de versiones?
+El control de versiones es un sistema que guarda todos los cambios realizados a
+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.
+
+[Informacion adicional](http://git-scm.com/book/es/Empezando-Acerca-del-control-de-versiones)
+
+### Por que usar Git?
+
+* Se puede trabajar sin conexion.
+* Colaborar con otros es sencillo!.
+* Derivar, Crear ramas del proyecto (aka: Branching) es facil!.
+* Combinar (aka: Marging)
+* Git es rapido.
+* Git es flexible.
+
+## Arquitectura de Git.
+
+### Repositorio
+
+Un repositorio es un conjunto de archivos, directorios, registros, cambios (aka:
+comits), y encabezados (aka: headss). Imagina que un repositorio es una clase,
+y que sus atributos otorgan  acceso al historial del elemento, ademas de otras
+cosas.
+
+Un repositorio esta compuesto por la carpeta .git y un "arbol 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 mayorioa de
+las veces se le llama "directorio de trabajo".
+
+### Inidice (componentes del directorio .git)
+
+El inidice es la area de inicio en git. Es basicamente la capa que separa el
+directorio de trabajo, del repositorio en git. Esto otorga a los desarrolladores
+mas poder sobre lo que envia y recibe en el 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 remueven 2,
+estos cambios se almacenaran en un commit (aka: captura). Este commit puede ser o
+no ser enviado (aka: "pusheado") hacia un repositorio.
+
+### Branch (rama)
+
+Un "brach", es escencialmente un apuntador hacia el ultimo commit (cambio
+registrado) que se ha realizado. A medida que se realizan mas commits, este
+apuntador se actualizara automaticamente hacia el ultimo commit.
+
+### "HEAD" y "head" (component of .git dir)
+
+"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 numero de
+"heads".
+
+### conceptos - recursos.
+
+* [Git para informaticos](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, informacion almacenada y
+demas 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 basicas. (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"
+```
+
+[Mas sobre git config.](http://git-scm.com/book/es/Personalizando-Git-Configuración-de-Git)
+
+### help
+
+Otorga un accceso rapido a una guia extremadamente detallada de cada comando en
+git. O puede ser usada simplemente como un recordatorio de estos.
+
+```bash
+# Una vista rapido 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 indice y el commit al cual apunta el
+HEAD actualmente.
+
+
+```bash
+# Mostrara el "branch", archivos sin añadir a la repo, cambios y otras
+# diferencias
+$ git status
+
+# Devuelve ayuda sobre el comando status.
+$ git help status
+```
+
+### add
+
+Para añadir archivos al arbol (directorio, repositorio) de trabajo. Si no se
+utiliza `git add`, los nuevos archivos no se añadiran al arbol de trabajo, por
+lo que no se incluiran 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 repositorios ("branches"). Puedes ver, editar, crear y
+borrar ramas ("branches"), usando este comando.
+
+```bash
+# lista todas las ramas (remotas y locales)
+$ git branch -a
+
+# Añada una nueva rama ("branch").
+$ git branch branchNueva
+
+# Eliminar una rama.
+$ git branch -d branchFoo
+
+# Renombra una rama.
+# git branch -m <anterior> <nuevo>
+$ git branch -m youngling padawan
+
+# Edita 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 indice, o en un arbol 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, una repo existente en un nuevo directorio. Tambien añada el
+seguimiento hacia las ramas existentes del repo que ha sido clonada, 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 los cambios que almacenados en el indice en un nuevo "commit". Este
+commit contiene los cambios hechos mas un resumen hecho por el desarrollador.
+
+```bash
+# commit with a message
+# 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 indice
+y commits.
+
+```bash
+# Muestra la diferencia entre un directorio de trabajo y el indice.
+$ git diff
+
+# Muestra la diferencia entre el indice y los commits mas recientes.
+$ git diff --cached
+
+# Muestra la diferencia entre el directorio de trabajo y el commit mas reciente.
+$ git diff HEAD
+```
+
+### grep
+
+Permite realizar una busqueda rapida en un repositorio.
+
+Configuracion 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 busqueda mas lejible, incluyendo agrupacion.
+$ 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 linea que contenga "nombreArreglo" y , "agregar" o "remover"
+$ git grep -e 'nombreArreglo' --and \( -e agregar -e remover \)
+```
+
+Mas 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 repositotrio.
+
+```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 hisotrial
+$ 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 utilizar 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
+
+Sube (Empuja) de un repositorio y lo combina en otro en una rama diferente.
+
+```bash
+# Actualiza el repositorio local, combinando los nuevos cambios.
+# de las ramas remotas "origin" y "master".
+# from the remote "origin" and "master" branch.
+# git pull <remota> <rama>
+$ git pull origin master
+```
+
+### push
+
+Push and merge changes from a branch to a remote & branch.
+
+```bash
+# Push and merge changes from a local repo to a
+# Empuja y combina cambios de un repositorio local hacian 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
+```
+
+
+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 publico*
+
+```bash
+# Integrar ramaExperimento dentro de la rama "master"
+# git rebase <basebranch> <topicbranch>
+$ git rebase master experimentBranch
+```
+
+[Informacion adicional.](http://git-scm.com/book/es/Ramificaciones-en-Git-Procedimientos-básicos-para-ramificar-y-fusionar)
+
+### reset (precaucion)
+
+Reinicia el cabezal actual hacia un estado especificado. Esto permite desacer
+combinaciones (merges), pulls, commits, adds y mas. Es un comando util, pero
+tambien peligrosa si no se sabe lo que se hace.
+
+```bash
+# Reinica el area principal, con el ultimo cambio registrado. (deja los
+# directorios sin cambios)
+$ git reset
+
+# Reinica el area principal, con el ultimo 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 aun existen el directorio.
+$ git reset 31f2bb1
+
+# Mueve la rama actual devuelta a un commit especificado asi como el
+# directorios (borra todos los cambios que no fueron registros y todos los
+# cambios realizados despues del commit especificado).
+$ git reset --hard 31f2bb1
+```
+
+### rm
+
+Lo contrario de git add, git rm remueve los archivos del directorio de trabajo
+actual.
+
+```bash
+# Remueve FooBar.c
+$ git rm FooBar.c
+
+# Remueve un archivo de un directorio.
+$ git rm /directorio/del/archivo/FooBar.c
+```
+
+## Informacion 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/)
-- 
cgit v1.2.3


From 816bf94956f88b8bcaa56d800ca1f19bbc9b5bd0 Mon Sep 17 00:00:00 2001
From: rscnt <raul_ascencio@lavabit.com>
Date: Mon, 25 Nov 2013 12:09:10 -0600
Subject: git es # -> //

---
 es-es/git-es.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'es-es')

diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
index 2c439fc2..54771bb6 100644
--- a/es-es/git-es.html.markdown
+++ b/es-es/git-es.html.markdown
@@ -2,9 +2,9 @@
 category: tool
 tool: git
 contributors:
-    - ["Jake Prather", "http:#github.com/JakeHP"]
+    - ["Jake Prather", "http://github.com/JakeHP"]
 translator:
-    - ["Raúl Ascencio", "http:#rscnt.github.io"]
+    - ["Raúl Ascencio", "http://rscnt.github.io"]
 filename: LearnGit.txt
 language: es-es
 
-- 
cgit v1.2.3


From 1b3053b3448cee90486204f4eeb9f28b5cb57eac Mon Sep 17 00:00:00 2001
From: rscnt <raul_ascencio@lavabit.com>
Date: Mon, 25 Nov 2013 12:13:11 -0600
Subject: last check

---
 es-es/git-es.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'es-es')

diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
index 54771bb6..0623b29b 100644
--- a/es-es/git-es.html.markdown
+++ b/es-es/git-es.html.markdown
@@ -47,7 +47,7 @@ uno o varios archivos, a lo largo del tiempo.
 ### Repositorio
 
 Un repositorio es un conjunto de archivos, directorios, registros, cambios (aka:
-comits), y encabezados (aka: headss). Imagina que un repositorio es una clase,
+comits), y encabezados (aka: heads). Imagina que un repositorio es una clase,
 y que sus atributos otorgan  acceso al historial del elemento, ademas de otras
 cosas.
 
@@ -80,7 +80,7 @@ no ser enviado (aka: "pusheado") hacia un repositorio.
 
 ### Branch (rama)
 
-Un "brach", es escencialmente un apuntador hacia el ultimo commit (cambio
+Un "branch", es escencialmente un apuntador hacia el ultimo commit (cambio
 registrado) que se ha realizado. A medida que se realizan mas commits, este
 apuntador se actualizara automaticamente hacia el ultimo commit.
 
-- 
cgit v1.2.3


From 283f3d4089e566ead35fe6dae0a239ed9071007d Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Sat, 4 Jan 2014 16:56:24 -0800
Subject: Updated git-es to us lang:, not language:

---
 es-es/git-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
index 0623b29b..5c9d3378 100644
--- a/es-es/git-es.html.markdown
+++ b/es-es/git-es.html.markdown
@@ -6,7 +6,7 @@ contributors:
 translator:
     - ["Raúl Ascencio", "http://rscnt.github.io"]
 filename: LearnGit.txt
-language: es-es
+lang: es-es
 
 ---
 
-- 
cgit v1.2.3


From 8185f5e033c74f2ff9c7be0af117c8d296fe55f9 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Wed, 29 Jan 2014 23:20:11 -0800
Subject: Updated learngo filenames

---
 es-es/go-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
index 434f6713..661a7dad 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -2,7 +2,7 @@
 name: Go
 category: language
 language: Go
-filename: learngo.go
+filename: learngo-es.go
 contributors:
     - ["Sonia Keys", "https://github.com/soniakeys"]
 translators:
-- 
cgit v1.2.3


From 88492baf332c100e52512bd755e9e2bcfa6726f6 Mon Sep 17 00:00:00 2001
From: Jesse Johnson <holocronweaver@gmail.com>
Date: Thu, 30 Jan 2014 18:45:42 -0500
Subject: [go/es] Update translation, format comments.

---
 es-es/go-es.html.markdown | 193 ++++++++++++++++++++++++++--------------------
 1 file changed, 110 insertions(+), 83 deletions(-)

(limited to 'es-es')

diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
index 661a7dad..a7166dc1 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -7,16 +7,20 @@ contributors:
     - ["Sonia Keys", "https://github.com/soniakeys"]
 translators:
     - ["Adrian Espinosa", "http://www.adrianespinosa.com"]
+    - ["Jesse Johnson, "https://github.com/holocronweaver"]
 lang: es-es
-
-
 ---
 
-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.
+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
+en día, y tiene características que ayudan con la programación a gran
+escala.
 
-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 en día, y tiene características que ayudan con la programación a gran escala.
 Go viene con una librería estándar muy buena y una comunidad entusiasta.
 
 ```go
@@ -28,15 +32,17 @@ Go viene con una librería estándar muy buena y una comunidad entusiasta.
 // Main es un nombre especial que declara un ejecutable en vez de una librería.
 package main
 
-// La declaración Import declara los paquetes de librerías referenciados en este archivo.
+// La declaración Import declara los paquetes de librerías
+// referenciados en este archivo.
 import (
-    "fmt"      // Un paquete en la librería estándar de Go
+    "fmt"      // Un paquete en la librería estándar de Go.
     "net/http" // Sí, un servidor web!
-    "strconv"  // Conversiones de cadenas
+    "strconv"  // Conversiones de cadenas.
+    m "math"   // Librería matemáticas con alias local m.
 )
 
-// Definición de una función. Main es especial. Es el punto de entrada para el ejecutable.
-// Te guste o no, Go utiliza llaves.
+// 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.
@@ -49,19 +55,19 @@ func main() {
 // Las funciones llevan parámetros entre paréntesis.
 // Si no hay parámetros, los paréntesis siguen siendo obligatorios.
 func beyondHello() {
-    var x int // Declaración de una variable. Las variables se deben declarar antes de 
-    // utilizarlas.
+    var x int // Declaración de una variable.
+              // Las variables se deben declarar antes de utilizarlas.
     x = 3     // Asignación de variables.
     // Declaración "corta" con := para inferir el tipo, declarar y asignar.
     y := 4
-    sum, prod := learnMultiple(x, y)        // función devuelve dos valores
-    fmt.Println("sum:", sum, "prod:", prod) // simple salida
+    sum, prod := learnMultiple(x, y)        // Función devuelve dos valores.
+    fmt.Println("sum:", sum, "prod:", prod) // Simple salida.
     learnTypes()                            // < y minutes, learn more!
 }
 
 // Las funciones pueden tener parámetros y (múltiples!) valores de retorno.
 func learnMultiple(x, y int) (sum, prod int) {
-    return x + y, x * y // devolver dos valores
+    return x + y, x * y // Devolver dos valores.
 }
 
 // Algunos tipos incorporados y literales.
@@ -73,32 +79,33 @@ 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.
-    f := 3.14195 // float64, el estándar IEEE-754 de coma flotante 64-bit
-    c := 3 + 4i  // complex128, representado internamente por dos float64
+    g := 'Σ' // Tipo rune, un alias de uint32, 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.
-    var u uint = 7 // sin signo, pero la implementación depende del tamaño como en int
+    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 de uint8
+    n := byte('\n') // byte es un alias de uint8.
 
     // Los Arrays tienen un tamaño fijo a la hora de compilar.
-    var a4 [4]int           // un array de 4 ints, inicializados a 0
-    a3 := [...]int{3, 1, 5} // un array de 3 ints, inicializados como se indica
+    var a4 [4]int           // Un array de 4 ints, inicializados a 0.
+    a3 := [...]int{3, 1, 5} // Un array de 3 ints, inicializados como se indica.
 
     // Los Slices tienen tamaño dinámico. Los arrays y slices tienen sus ventajas
     // y desventajas pero los casos de uso para los slices son más comunes.
-    s3 := []int{4, 5, 9}    // Comparar con a3. No hay puntos suspensivos
-    s4 := make([]int, 4)    // Asigna slices de 4 ints, inicializados a 0
-    var d2 [][]float64      // solo declaración, sin asignación
-    bs := []byte("a slice") // sintaxis de conversión de tipo
+    s3 := []int{4, 5, 9}    // Comparar con a3. No hay puntos suspensivos.
+    s4 := make([]int, 4)    // Asigna slices de 4 ints, inicializados a 0.
+    var d2 [][]float64      // Solo declaración, sin asignación.
+    bs := []byte("a slice") // Sintaxis de conversión de tipo.
 
-    p, q := learnMemory() // declara p, q para ser un tipo puntero a int.
+    p, q := learnMemory() // Declara p, q para ser un tipo puntero a int.
     fmt.Println(*p, *q)   // * sigue un puntero. Esto imprime dos ints.
 
-    // Los Maps son arrays asociativos dinámicos, como los hash o diccionarios
-    // de otros lenguajes
+    // Los Maps son arrays asociativos dinámicos, como los hash o
+    // diccionarios de otros lenguajes.
     m := map[string]int{"three": 3, "four": 4}
     m["one"] = 1
 
@@ -108,23 +115,24 @@ saltos de línea.` // mismo tipo cadena
     // Esto cuenta como utilización de variables.
     fmt.Println(s, c, a4, s3, d2, m)
 
-    learnFlowControl() // vuelta al flujo
+    learnFlowControl() // Vuelta al flujo.
 }
 
-// Go posee recolector de basura. Tiene puntero pero no aritmética de punteros.
-// Puedes cometer un errores con un puntero nil, pero no incrementando un puntero.
+// Go posee recolector de basura. Tiene puntero pero no aritmética de
+// punteros.  Puedes cometer un errores con un puntero nil, pero no
+// incrementando un puntero.
 func learnMemory() (p, q *int) {
     // q y p tienen un tipo puntero a int.
-    p = new(int) // función incorporada que asigna memoria.
+    p = new(int) // Función incorporada que asigna memoria.
     // La asignación de int se inicializa a 0, p ya no es nil.
-    s := make([]int, 20) // asigna 20 ints a un solo bloque de memoria.
-    s[3] = 7             // asignar uno de ellos
-    r := -2              // declarar otra variable local
+    s := make([]int, 20) // Asigna 20 ints a un solo bloque de memoria.
+    s[3] = 7             // Asignar uno de ellos.
+    r := -2              // Declarar otra variable local.
     return &s[3], &r     // & toma la dirección de un objeto.
 }
 
-func expensiveComputation() int {
-    return 1e6
+func expensiveComputation() float64 {
+    return m.Exp(10)
 }
 
 func learnFlowControl() {
@@ -134,29 +142,31 @@ func learnFlowControl() {
     }
     // El formato está estandarizado por el comando "go fmt."
     if false {
-        // pout
+        // Pout.
     } else {
-        // gloat
+        // Gloat.
     }
     // Utiliza switch preferiblemente para if encadenados.
-    x := 1
+    x := 42.0
     switch x {
     case 0:
     case 1:
-        // los cases no se mezclan, no requieren de "break"
-    case 2:
-        // no llega
+    case 42:
+        // Los cases no se mezclan, no requieren de "break".
+    case 43:
+        // No llega.
     }
     // Como if, for no utiliza paréntesis tampoco.
-    for x := 0; x < 3; x++ { // ++ es una sentencia
+    // Variables declaradas en for y if son locales de su ámbito local.
+    for x := 0; x < 3; x++ { // ++ es una sentencia.
         fmt.Println("iteration", x)
     }
-    // x == 1 aqui.
+    // x == 42 aqui.
 
     // For es la única sentencia de bucle en Go, pero tiene formas alternativas.
-    for { // bucle infinito
-        break    // solo bromeaba!
-        continue // no llega
+    for { // Bucle infinito.
+        break    // Solo bromeaba!
+        continue // No llega.
     }
     // Como en for, := en una sentencia if significa declarar y asignar primero,
     // luego comprobar y > x.
@@ -165,11 +175,11 @@ func learnFlowControl() {
     }
     // Los literales de funciones son "closures".
     xBig := func() bool {
-        return x > 100 // referencia a x declarada encima de la sentencia switch.
+        return x > 100 // Referencia a x declarada encima de la sentencia switch.
     }
-    fmt.Println("xBig:", xBig()) // verdadero (la última vez asignamos 1e6 a x)
-    x /= 1e5                     // esto lo hace  == 10
-    fmt.Println("xBig:", xBig()) // ahora es falso
+    fmt.Println("xBig:", xBig()) // verdadero (la última vez asignamos 1e6 a x).
+    x /= m.Exp(9)                // Esto lo hace x == e.
+    fmt.Println("xBig:", xBig()) // Ahora es falso.
 
     // Cuando lo necesites, te encantará.
     goto love
@@ -199,16 +209,29 @@ func learnInterfaces() {
     // La sintaxis de llaves es un "literal struct". Evalúa a un struct
     // inicializado.  La sintaxis := declara e inicializa p a este struct.
     p := pair{3, 4}
-    fmt.Println(p.String()) // llamar al método String de p, de tipo pair.
-    var i Stringer          // declarar i como interfaz tipo Stringer.
-    i = p                   // válido porque pair implementa Stringer
-    // Llamar al metodo String de i, de tipo Stringer. Misma salida que arriba
+    fmt.Println(p.String()) // Llamar al método String de p, de tipo pair.
+    var i Stringer          // Declarar i como interfaz tipo Stringer.
+    i = p                   // Válido porque pair implementa Stringer.
+    // Llamar 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 preguntar a un objeto
-    // por una versió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.
+    // Las funciones en el paquete fmt llaman al método String para
+    // preguntar a un objeto por una versió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.
+
+    learnVariadicParams("great", "learning", "here!")
+}
+
+// Las funciones pueden tener número variable de argumentos.
+func learnVariadicParams(myStrings ...interface{}) {
+    // Iterar cada valor de la variadic.
+    for _, param := range myStrings {
+        fmt.Println("param:", param)
+    }
+    
+    // Pasar valor variadic como parámetro variadic.
+    fmt.Println("params:", fmt.Sprintln(myStrings...))
 
     learnErrorHandling()
 }
@@ -223,7 +246,7 @@ func learnErrorHandling() {
     }
     // Un valor de error comunica más información sobre el problema aparte de "ok".
     if _, err := strconv.Atoi("non-int"); err != nil { // _ descarta el valor
-        // imprime "strconv.ParseInt: parsing "non-int": invalid syntax"
+        // Imprime "strconv.ParseInt: parsing "non-int": invalid syntax".
         fmt.Println(err)
     }
     // Revisarmeos las interfaces más tarde. Mientras tanto,
@@ -248,25 +271,28 @@ func learnConcurrency() {
     go inc(-805, c)
     // Leer los tres resultados del channel e imprimirlos.
     // No se puede saber en que orden llegarán los resultados!
-    fmt.Println(<-c, <-c, <-c) // channel a la derecha, <- es el operador "recibir".
-
-    cs := make(chan string)       // otro channel, este gestiona cadenas.
-    cc := make(chan chan string)  // un channel de cadenas de channels.
-    go func() { c <- 84 }()       // iniciar una nueva goroutine solo para enviar un valor.
-    go func() { cs <- "wordy" }() // otra vez, para cs en esta ocasión
-    // Select tiene una sintáxis parecida a la sentencia switch pero cada caso involucra
-    // una operacion de channels. Selecciona un caso de forma aleatoria de los casos
-    // que están listos para comunicarse.
+    fmt.Println(<-c, <-c, <-c) // Channel a la derecha, <- es el operador "recibir".
+
+    cs := make(chan string)       // Otro channel, este gestiona cadenas.
+    ccs := make(chan chan string) // Un channel de cadenas de channels.
+    go func() { c <- 84 }()       // Iniciar una nueva goroutine solo para
+                                  // enviar un valor.
+    go func() { cs <- "wordy" }() // Otra vez, para cs en esta ocasión.
+    // Select tiene una sintáxis parecida a la sentencia switch pero
+    // cada caso involucra una operacion de channels. Selecciona un caso
+    // de forma aleatoria de los casos que están listos para comunicarse.
     select {
-    case i := <-c: // el valor recibido puede ser asignado a una variable
+    case i := <-c: // El valor recibido puede ser asignado a una variable,
         fmt.Printf("it's a %T", i)
-    case <-cs: // o el valor puede ser descartado
+    case <-cs:     // o el valor puede ser descartado.
         fmt.Println("it's a string")
-    case <-cc: // channel vacío, no está listo para la comunicación.
+    case <-ccs:    // Channel vacío, no está listo para la comunicación.
         fmt.Println("didn't happen.")
     }
+
     // En este punto un valor fue devuelvto de c o cs. Uno de las dos
-    // goroutines que se iniciaron se ha completado, la otrá permancerá bloqueada.
+    // goroutines que se iniciaron se ha completado, la otrá permancerá
+    // bloqueada.
 
     learnWebProgramming() // Go lo hace. Tu también quieres hacerlo.
 }
@@ -281,7 +307,7 @@ func learnWebProgramming() {
 
 // Haz pair un http.Handler implementando su único método, ServeHTTP.
 func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-    // Servir datos con un método de http.ResponseWriter
+    // Servir datos con un método de http.ResponseWriter.
     w.Write([]byte("You learned Go in Y minutes!"))
 }
 ```
@@ -291,11 +317,12 @@ func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 La raíz de todas las cosas de Go es la [web oficial de Go](http://golang.org/).
 Ahí puedes seguir el tutorial, jugar interactivamente y leer mucho.
 
-La propia definición del lenguaje también está altamente recomendada. Es fácil de leer
-e increíblemente corta (como otras definiciones de lenguajes hoy en día)
+La propia definición del lenguaje también está altamente
+recomendada. Es fácil de leer e increíblemente corta (como otras
+definiciones de lenguajes hoy en día)
 
-En la lista de lectura de estudiantes de Go está el código fuente de la
-librería estándar. Muy bien documentada, demuestra lo mejor de Go leíble, comprendible,
-estilo Go y formas Go. Pincha en el nombre de una función en la documentación
-y te aparecerá el código fuente!
+En la lista de lectura de estudiantes de Go está el código fuente de
+la librería estándar. Muy bien documentada, demuestra lo mejor de Go
+leíble, comprendible, estilo Go y formas Go. Pincha en el nombre de
+una función en la documentación y te aparecerá el código fuente!
 
-- 
cgit v1.2.3


From 8d82b5594749c52b5b8fa3b988ae65098a47ab1c Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Sat, 1 Feb 2014 17:00:04 -0800
Subject: Fix GO yaml to not break in es

---
 es-es/go-es.html.markdown | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

(limited to 'es-es')

diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
index a7166dc1..e788e810 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -1,14 +1,12 @@
 ---
-name: Go
-category: language
 language: Go
+lang: es-es
 filename: learngo-es.go
 contributors:
     - ["Sonia Keys", "https://github.com/soniakeys"]
 translators:
     - ["Adrian Espinosa", "http://www.adrianespinosa.com"]
-    - ["Jesse Johnson, "https://github.com/holocronweaver"]
-lang: es-es
+    - ["Jesse Johnson", "https://github.com/holocronweaver"]
 ---
 
 Go fue creado por la necesidad de hacer el trabajo rápidamente.  No es
-- 
cgit v1.2.3


From 64f4d444cca52197db8dd728d073144663e1f00a Mon Sep 17 00:00:00 2001
From: Guillermo Garza <ggarza23@gmail.com>
Date: Tue, 18 Mar 2014 23:51:32 -0500
Subject: Add file for spanish translation of julia

---
 es-es/julia-es.html.markdown | 747 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 747 insertions(+)
 create mode 100644 es-es/julia-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
new file mode 100644
index 00000000..36c57b2a
--- /dev/null
+++ b/es-es/julia-es.html.markdown
@@ -0,0 +1,747 @@
+---
+language: julia
+contributors:
+    - ["Leah Hanson", "http://leahhanson.us"]
+filename: learnjulia.jl
+---
+
+Julia is a new homoiconic functional language focused on technical computing.
+While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python.
+
+This is based on the current development version of Julia, as of October 18th, 2013.
+
+```ruby
+
+# Single line comments start with a hash.
+#= Multiline comments can be written
+   by putting '#=' before the text  and '=#' 
+   after the text. They can also be nested.
+=#
+
+####################################################
+## 1. Primitive Datatypes and Operators
+####################################################
+
+# Everything in Julia is a expression.
+
+# There are several basic types of numbers.
+3 # => 3 (Int64)
+3.2 # => 3.2 (Float64)
+2 + 1im # => 2 + 1im (Complex{Int64})
+2//3 # => 2//3 (Rational{Int64})
+
+# All of the normal infix operators are available.
+1 + 1 # => 2
+8 - 1 # => 7
+10 * 2 # => 20
+35 / 5 # => 7.0
+5 / 2 # => 2.5 # dividing an Int by an Int always results in a Float
+div(5, 2) # => 2 # for a truncated result, use div
+5 \ 35 # => 7.0
+2 ^ 2 # => 4 # power, not bitwise xor
+12 % 10 # => 2
+
+# Enforce precedence with parentheses
+(1 + 3) * 2 # => 8
+
+# Bitwise Operators
+~2 # => -3   # bitwise not
+3 & 5 # => 1 # bitwise and
+2 | 4 # => 6 # bitwise or
+2 $ 4 # => 6 # bitwise xor
+2 >>> 1 # => 1 # logical shift right
+2 >> 1  # => 1 # arithmetic shift right
+2 << 1  # => 4 # logical/arithmetic shift left
+
+# You can use the bits function to see the binary representation of a number.
+bits(12345)
+# => "0000000000000000000000000000000000000000000000000011000000111001"
+bits(12345.0)
+# => "0100000011001000000111001000000000000000000000000000000000000000"
+
+# Boolean values are primitives
+true
+false
+
+# Boolean operators
+!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
+# Comparisons can be chained
+1 < 2 < 3 # => true
+2 < 3 < 2 # => false
+
+# Strings are created with "
+"This is a string."
+
+# Character literals are written with '
+'a'
+
+# A string can be indexed like an array of characters
+"This is a string"[1] # => 'T' # Julia indexes from 1
+# However, this is will not work well for UTF8 strings,
+# so iterating over strings is recommended (map, for loops, etc).
+
+# $ can be used for string interpolation:
+"2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
+# You can put any Julia expression inside the parenthesis.
+
+# Another way to format strings is the printf macro.
+@printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000
+
+# Printing is easy
+println("I'm Julia. Nice to meet you!")
+
+####################################################
+## 2. Variables and Collections
+####################################################
+
+# You don't declare variables before assigning to them.
+some_var = 5 # => 5
+some_var # => 5
+
+# Accessing a previously unassigned variable is an error
+try
+    some_other_var # => ERROR: some_other_var not defined
+catch e
+    println(e)
+end
+
+# Variable names start with a letter.
+# After that, you can use letters, digits, underscores, and exclamation points.
+SomeOtherVar123! = 6 # => 6
+
+# You can also use unicode characters
+☃ = 8 # => 8
+# These are especially handy for mathematical notation
+2 * π # => 6.283185307179586
+
+# A note on naming conventions in Julia:
+#
+# * Names of variables are in lower case, with word separation indicated by
+#   underscores ('\_').
+#
+# * Names of Types begin with a capital letter and word separation is shown
+#   with CamelCase instead of underscores.
+#
+# * Names of functions and macros are in lower case, without underscores.
+#
+# * Functions that modify their inputs have names that end in !. These
+#   functions are sometimes called mutating functions or in-place functions.
+
+# Arrays store a sequence of values indexed by integers 1 through n:
+a = Int64[] # => 0-element Int64 Array
+
+# 1-dimensional array literals can be written with comma-separated values.
+b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6]
+b[1] # => 4
+b[end] # => 6
+
+# 2-dimentional arrays use space-separated values and semicolon-separated rows.
+matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
+
+# Add stuff to the end of a list with push! and 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]
+
+# Remove from the end with pop
+pop!(b)        # => 6 and b is now [4,5]
+
+# Let's put it back
+push!(b,6)   # b is now [4,5,6] again.
+
+a[1] # => 1 # remember that Julia indexes from 1, not 0!
+
+# end is a shorthand for the last index. It can be used in any
+# indexing expression
+a[end] # => 6
+
+# we also have shift and unshift
+shift!(a) # => 1 and a is now [2,4,3,4,5,6]
+unshift!(a,7) # => [7,2,4,3,4,5,6]
+
+# Function names that end in exclamations points indicate that they modify
+# their argument.
+arr = [5,4,6] # => 3-element Int64 Array: [5,4,6]
+sort(arr) # => [4,5,6]; arr is still [5,4,6]
+sort!(arr) # => [4,5,6]; arr is now [4,5,6]
+
+# Looking out of bounds is a 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)
+end
+
+# Errors list the line and file they came from, even if it's in the standard
+# library. If you built Julia from source, you can look in the folder base
+# inside the julia folder to find these files.
+
+# You can initialize arrays from ranges
+a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5]
+
+# You can look at ranges with slice syntax.
+a[1:3] # => [1, 2, 3]
+a[2:] # => [2, 3, 4, 5]
+a[2:end] # => [2, 3, 4, 5]
+
+# Remove elements from an array by index with splice!
+arr = [3,4,5]
+splice!(arr,2) # => 4 ; arr is now [3,5]
+
+# Concatenate lists with append!
+b = [1,2,3]
+append!(a,b) # Now a is [1, 2, 3, 4, 5, 1, 2, 3]
+
+# Check for existence in a list with in
+in(1, a) # => true
+
+# Examine the length with length
+length(a) # => 8
+
+# Tuples are immutable.
+tup = (1, 2, 3) # => (1,2,3) # an (Int64,Int64,Int64) tuple.
+tup[1] # => 1
+try:
+    tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
+catch e
+    println(e)
+end
+
+# Many list functions also work on tuples
+length(tup) # => 3
+tup[1:2] # => (1,2)
+in(2, tup) # => true
+
+# You can unpack tuples into variables
+a, b, c = (1, 2, 3) # => (1,2,3)  # a is now 1, b is now 2 and c is now 3
+
+# Tuples are created even if you leave out the parentheses
+d, e, f = 4, 5, 6 # => (4,5,6)
+
+# A 1-element tuple is distinct from the value it contains
+(1,) == 1 # => false
+(1) == 1 # => true
+
+# Look how easy it is to swap two values
+e, d = d, e  # => (5,4) # d is now 5 and e is now 4
+
+
+# Dictionaries store mappings
+empty_dict = Dict() # => Dict{Any,Any}()
+
+# You can create a dictionary using a literal
+filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3]
+# => Dict{ASCIIString,Int64}
+
+# Look up values with []
+filled_dict["one"] # => 1
+
+# Get all keys
+keys(filled_dict)
+# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# Note - dictionary keys are not sorted or in the order you inserted them.
+
+# Get all values
+values(filled_dict)
+# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
+# Note - Same as above regarding key ordering.
+
+# Check for existence of keys in a dictionary with in, haskey
+in(("one", 1), filled_dict) # => true
+in(("two", 3), filled_dict) # => false
+haskey(filled_dict, "one") # => true
+haskey(filled_dict, 1) # => false
+
+# Trying to look up a non-existant key will raise an error
+try
+    filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489
+catch e
+    println(e)
+end
+
+# Use the get method to avoid that error by providing a default value
+# get(dictionary,key,default_value)
+get(filled_dict,"one",4) # => 1
+get(filled_dict,"four",4) # => 4
+
+# Use Sets to represent collections of unordered, unique values
+empty_set = Set() # => Set{Any}()
+# Initialize a set with values
+filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
+
+# Add more values to a set
+push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)
+
+# Check if the values are in the set
+in(2, filled_set) # => true
+in(10, filled_set) # => false
+
+# There are functions for set intersection, union, and difference.
+other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
+intersect(filled_set, other_set) # => Set{Int64}(3,4,5)
+union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6)
+setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4)
+
+
+####################################################
+## 3. Control Flow
+####################################################
+
+# Let's make a variable
+some_var = 5
+
+# Here is an if statement. Indentation is not meaningful in Julia.
+if some_var > 10
+    println("some_var is totally bigger than 10.")
+elseif some_var < 10    # This elseif clause is optional.
+    println("some_var is smaller than 10.")
+else                    # The else clause is optional too.
+    println("some_var is indeed 10.")
+end
+# => prints "some var is smaller than 10"
+
+
+# For loops iterate over iterables.
+# Iterable types include Range, Array, Set, Dict, and String.
+for animal=["dog", "cat", "mouse"]
+    println("$animal is a mammal")
+    # You can use $ to interpolate variables or expression into strings
+end
+# prints:
+#    dog is a mammal
+#    cat is a mammal
+#    mouse is a mammal
+
+# You can use 'in' instead of '='.
+for animal in ["dog", "cat", "mouse"]
+    println("$animal is a mammal")
+end
+# prints:
+#    dog is a mammal
+#    cat is a mammal
+#    mouse is a mammal
+
+for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+    println("$(a[1]) is a $(a[2])")
+end
+# prints:
+#    dog is a mammal
+#    cat is a mammal
+#    mouse is a mammal
+
+for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
+    println("$k is a $v")
+end
+# prints:
+#    dog is a mammal
+#    cat is a mammal
+#    mouse is a mammal
+
+# While loops loop while a condition is true
+x = 0
+while x < 4
+    println(x)
+    x += 1  # Shorthand for x = x + 1
+end
+# prints:
+#   0
+#   1
+#   2
+#   3
+
+# Handle exceptions with a try/catch block
+try
+   error("help")
+catch e
+   println("caught it $e")
+end
+# => caught it ErrorException("help")
+
+
+####################################################
+## 4. Functions
+####################################################
+
+# The keyword 'function' creates new functions
+#function name(arglist)
+#  body...
+#end
+function add(x, y)
+    println("x is $x and y is $y")
+
+    # Functions return the value of their last statement
+    x + y
+end
+
+add(5, 6) # => 11 after printing out "x is 5 and y is 6"
+
+# You can define functions that take a variable number of
+# positional arguments
+function varargs(args...)
+    return args
+    # use the keyword return to return anywhere in the function
+end
+# => varargs (generic function with 1 method)
+
+varargs(1,2,3) # => (1,2,3)
+
+# The ... is called a splat.
+# We just used it in a function definition.
+# It can also be used in a fuction call,
+# where it will splat an Array or Tuple's contents into the argument list.
+Set([1,2,3])    # => Set{Array{Int64,1}}([1,2,3]) # produces a Set of Arrays
+Set([1,2,3]...) # => Set{Int64}(1,2,3) # this is equivalent to Set(1,2,3)
+
+x = (1,2,3)     # => (1,2,3)
+Set(x)          # => Set{(Int64,Int64,Int64)}((1,2,3)) # a Set of Tuples
+Set(x...)       # => Set{Int64}(2,3,1)
+
+
+# You can define functions with optional positional arguments
+function defaults(a,b,x=5,y=6)
+    return "$a $b and $x $y"
+end
+
+defaults('h','g') # => "h g and 5 6"
+defaults('h','g','j') # => "h g and j 6"
+defaults('h','g','j','k') # => "h g and j k"
+try
+    defaults('h') # => ERROR: no method defaults(Char,)
+    defaults() # => ERROR: no methods defaults()
+catch e
+    println(e)
+end
+
+# You can define functions that take keyword arguments
+function keyword_args(;k1=4,name2="hello") # note the ;
+    return ["k1"=>k1,"name2"=>name2]
+end
+
+keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]
+keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"]
+keyword_args() # => ["name2"=>"hello","k1"=>4]
+
+# You can combine all kinds of arguments in the same function
+function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo")
+    println("normal arg: $normal_arg")
+    println("optional arg: $optional_positional_arg")
+    println("keyword arg: $keyword_arg")
+end
+
+all_the_args(1, 3, keyword_arg=4)
+# prints:
+#   normal arg: 1
+#   optional arg: 3
+#   keyword arg: 4
+
+# Julia has first class functions
+function create_adder(x)
+    adder = function (y)
+        return x + y
+    end
+    return adder
+end
+
+# This is "stabby lambda syntax" for creating anonymous functions
+(x -> x > 2)(3) # => true
+
+# This function is identical to create_adder implementation above.
+function create_adder(x)
+    y -> x + y
+end
+
+# You can also name the internal function, if you want
+function create_adder(x)
+    function adder(y)
+        x + y
+    end
+    adder
+end
+
+add_10 = create_adder(10)
+add_10(3) # => 13
+
+
+# There are built-in higher order functions
+map(add_10, [1,2,3]) # => [11, 12, 13]
+filter(x -> x > 5, [3, 4, 5, 6, 7]) # => [6, 7]
+
+# We can use list comprehensions for nicer maps
+[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
+[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+
+####################################################
+## 5. Types
+####################################################
+
+# Julia has a type system.
+# Every value has a type; variables do not have types themselves.
+# You can use the `typeof` function to get the type of a value.
+typeof(5) # => Int64
+
+# Types are first-class values
+typeof(Int64) # => DataType
+typeof(DataType) # => DataType
+# DataType is the type that represents types, including itself.
+
+# Types are used for documentation, optimizations, and dispatch.
+# They are not statically checked.
+
+# Users can define types
+# They are like records or structs in other languages.
+# New types are defined used the `type` keyword.
+
+# type Name
+#   field::OptionalType
+#   ...
+# end
+type Tiger
+  taillength::Float64
+  coatcolor # not including a type annotation is the same as `::Any`
+end
+
+# The default constructor's arguments are the properties
+# of the type, in the order they are listed in the definition
+tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange")
+
+# The type doubles as the constructor function for values of that type
+sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire")
+
+# These struct-style types are called concrete types
+# They can be instantiated, but cannot have subtypes.
+# The other kind of types is abstract types.
+
+# abstract Name
+abstract Cat # just a name and point in the type hierarchy
+
+# Abstract types cannot be instantiated, but can have subtypes.
+# For example, Number is an abstract type
+subtypes(Number) # => 6-element Array{Any,1}:
+                 #     Complex{Float16}
+                 #     Complex{Float32}
+                 #     Complex{Float64}
+                 #     Complex{T<:Real}
+                 #     ImaginaryUnit
+                 #     Real
+subtypes(Cat) # => 0-element Array{Any,1}
+
+# Every type has a super type; use the `super` function to get it.
+typeof(5) # => Int64
+super(Int64) # => Signed
+super(Signed) # => Real
+super(Real) # => Number
+super(Number) # => Any
+super(super(Signed)) # => Number
+super(Any) # => Any
+# All of these type, except for Int64, are abstract.
+
+# <: is the subtyping operator
+type Lion <: Cat # Lion is a subtype of Cat
+  mane_color
+  roar::String
+end
+
+# You can define more constructors for your type
+# Just define a function of the same name as the type
+# and call an existing constructor to get a value of the correct type
+Lion(roar::String) = Lion("green",roar)
+# This is an outer constructor because it's outside the type definition
+
+type Panther <: Cat # Panther is also a subtype of Cat
+  eye_color
+  Panther() = new("green")
+  # Panthers will only have this constructor, and no default constructor.
+end
+# Using inner constructors, like Panther does, gives you control
+# over how values of the type can be created.
+# When possible, you should use outer constructors rather than inner ones.
+
+####################################################
+## 6. Multiple-Dispatch
+####################################################
+
+# In Julia, all named functions are generic functions
+# This means that they are built up from many small methods
+# Each constructor for Lion is a method of the generic function Lion.
+
+# For a non-constructor example, let's make a function meow:
+
+# Definitions for Lion, Panther, Tiger
+function meow(animal::Lion)
+  animal.roar # access type properties using dot notation
+end
+
+function meow(animal::Panther)
+  "grrr"
+end
+
+function meow(animal::Tiger)
+  "rawwwr"
+end
+
+# Testing the meow function
+meow(tigger) # => "rawwr"
+meow(Lion("brown","ROAAR")) # => "ROAAR"
+meow(Panther()) # => "grrr"
+
+# Review the local type hierarchy
+issubtype(Tiger,Cat) # => false
+issubtype(Lion,Cat) # => true
+issubtype(Panther,Cat) # => true
+
+# Defining a function that takes Cats
+function pet_cat(cat::Cat)
+  println("The cat says $(meow(cat))")
+end
+
+pet_cat(Lion("42")) # => prints "The cat says 42"
+try
+    pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,)
+catch e
+    println(e)
+end
+
+# In OO languages, single dispatch is common;
+# this means that the method is picked based on the type of the first argument.
+# In Julia, all of the argument types contribute to selecting the best method.
+
+# Let's define a function with more arguments, so we can see the difference
+function fight(t::Tiger,c::Cat)
+  println("The $(t.coatcolor) tiger wins!")
+end
+# => fight (generic function with 1 method)
+
+fight(tigger,Panther()) # => prints The orange tiger wins!
+fight(tigger,Lion("ROAR")) # => prints The orange tiger wins!
+
+# Let's change the behavior when the Cat is specifically a Lion
+fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!")
+# => fight (generic function with 2 methods)
+
+fight(tigger,Panther()) # => prints The orange tiger wins!
+fight(tigger,Lion("ROAR")) # => prints The green-maned lion wins!
+
+# We don't need a Tiger in order to fight
+fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))")
+# => fight (generic function with 3 methods)
+
+fight(Lion("balooga!"),Panther()) # => prints The victorious cat says grrr
+try
+  fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion)
+catch
+end
+
+# Also let the cat go first
+fight(c::Cat,l::Lion) = println("The cat beats the Lion")
+# => Warning: New definition
+#    fight(Cat,Lion) at none:1
+# is ambiguous with
+#    fight(Lion,Cat) at none:2.
+# Make sure
+#    fight(Lion,Lion)
+# is defined first.
+#fight (generic function with 4 methods)
+
+# This warning is because it's unclear which fight will be called in:
+fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr
+# The result may be different in other versions of Julia
+
+fight(l::Lion,l2::Lion) = println("The lions come to a tie")
+fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The lions come to a tie
+
+
+# Under the hood
+# You can take a look at the llvm  and the assembly code generated.
+
+square_area(l) = l * l      # square_area (generic function with 1 method)
+
+square_area(5) #25
+
+# What happens when we feed square_area an integer?
+code_native(square_area, (Int32,))  
+	#	    .section    __TEXT,__text,regular,pure_instructions
+	#	Filename: none
+	#	Source line: 1              # Prologue
+	#	    push    RBP
+	#	    mov RBP, RSP
+	#	Source line: 1
+	#	    movsxd  RAX, EDI        # Fetch l from memory?
+	#	    imul    RAX, RAX        # Square l and store the result in RAX
+	#	    pop RBP                 # Restore old base pointer
+	#	    ret                     # Result will still be in RAX
+
+code_native(square_area, (Float32,))
+	#	    .section    __TEXT,__text,regular,pure_instructions
+	#	Filename: none
+	#	Source line: 1
+	#	    push    RBP
+	#	    mov RBP, RSP
+	#	Source line: 1
+	#	    vmulss  XMM0, XMM0, XMM0  # Scalar single precision multiply (AVX)
+	#	    pop RBP
+	#	    ret
+
+code_native(square_area, (Float64,))
+	#	    .section    __TEXT,__text,regular,pure_instructions
+	#	Filename: none
+	#	Source line: 1
+	#	    push    RBP
+	#	    mov RBP, RSP
+	#	Source line: 1
+	#	    vmulsd  XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX)
+	#	    pop RBP
+	#	    ret
+	#	
+# Note that julia will use floating point instructions if any of the
+# arguements are floats.
+# Let's calculate the area of a circle 
+circle_area(r) = pi * r * r     # circle_area (generic function with 1 method)
+circle_area(5)                  # 78.53981633974483
+
+code_native(circle_area, (Int32,))
+	#	    .section    __TEXT,__text,regular,pure_instructions
+	#	Filename: none
+	#	Source line: 1
+	#	    push    RBP
+	#	    mov RBP, RSP
+	#	Source line: 1
+	#	    vcvtsi2sd   XMM0, XMM0, EDI          # Load integer (r) from memory
+	#	    movabs  RAX, 4593140240              # Load pi
+	#	    vmulsd  XMM1, XMM0, QWORD PTR [RAX]  # pi * r
+	#	    vmulsd  XMM0, XMM0, XMM1             # (pi * r) * r
+	#	    pop RBP
+	#	    ret
+	#
+
+code_native(circle_area, (Float64,))
+	#	    .section    __TEXT,__text,regular,pure_instructions
+	#	Filename: none
+	#	Source line: 1
+	#	    push    RBP
+	#	    mov RBP, RSP
+	#	    movabs  RAX, 4593140496
+	#	Source line: 1
+	#	    vmulsd  XMM1, XMM0, QWORD PTR [RAX]
+	#	    vmulsd  XMM0, XMM1, XMM0
+	#	    pop RBP
+	#	    ret
+	#	
+```
+
+## Further Reading
+
+You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/manual/)
+
+The best place to get help with Julia is the (very friendly) [mailing list](https://groups.google.com/forum/#!forum/julia-users).
-- 
cgit v1.2.3


From 38f55957ac1773098ce17bf59dba2b1f704e9245 Mon Sep 17 00:00:00 2001
From: Guillermo Garza <ggarza23@gmail.com>
Date: Wed, 19 Mar 2014 00:08:07 -0500
Subject: Translate Julia to Spanish

This is based partly on the Python translation.
---
 es-es/julia-es.html.markdown | 700 ++++++++++++++++++++++---------------------
 1 file changed, 351 insertions(+), 349 deletions(-)

(limited to 'es-es')

diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 36c57b2a..6c5a6428 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -12,39 +12,39 @@ This is based on the current development version of Julia, as of October 18th, 2
 
 ```ruby
 
-# Single line comments start with a hash.
-#= Multiline comments can be written
-   by putting '#=' before the text  and '=#' 
-   after the text. They can also be nested.
+# Comentarios de una línea comienzan con una almohadilla (o signo gato)
+#= Commentarios multilinea pueden escribirse
+   usando '#=' antes de que el texto  and '=#' 
+  después del texto. También se pueden anidar.
 =#
 
 ####################################################
-## 1. Primitive Datatypes and Operators
+## 1. Tipos de datos primitivos y operadores.
 ####################################################
 
-# Everything in Julia is a expression.
+# Todo en Julia es una expresión.
 
-# There are several basic types of numbers.
+# 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})
 
-# All of the normal infix operators are available.
+# Todos los operadores infijos normales están disponibles.
 1 + 1 # => 2
 8 - 1 # => 7
 10 * 2 # => 20
 35 / 5 # => 7.0
-5 / 2 # => 2.5 # dividing an Int by an Int always results in a Float
-div(5, 2) # => 2 # for a truncated result, use div
+5/2 # => 2.5 # dividir un Int por un Int siempre resulta en un Fload
+div (5, 2) # => 2 # para un resultado truncado, usa div
 5 \ 35 # => 7.0
-2 ^ 2 # => 4 # power, not bitwise xor
+2 ^ 2 # => 4 # exponente, no exclusivo bit a bit
 12 % 10 # => 2
 
-# Enforce precedence with parentheses
+# Refuerza la precedencia con paréntesis
 (1 + 3) * 2 # => 8
 
-# Bitwise Operators
+# Operadores a nivel de bit
 ~2 # => -3   # bitwise not
 3 & 5 # => 1 # bitwise and
 2 | 4 # => 6 # bitwise or
@@ -53,17 +53,17 @@ div(5, 2) # => 2 # for a truncated result, use div
 2 >> 1  # => 1 # arithmetic shift right
 2 << 1  # => 4 # logical/arithmetic shift left
 
-# You can use the bits function to see the binary representation of a number.
+# Se puede utilizar la función bits para ver la representación binaria de un número.
 bits(12345)
 # => "0000000000000000000000000000000000000000000000000011000000111001"
 bits(12345.0)
 # => "0100000011001000000111001000000000000000000000000000000000000000"
 
-# Boolean values are primitives
+# Valores 'boolean' (booleanos) son primitivos
 true
 false
 
-# Boolean operators
+# Operadores Boolean (booleanos)
 !true # => false
 !false # => true
 1 == 1 # => true
@@ -74,109 +74,112 @@ false
 1 > 10 # => false
 2 <= 2 # => true
 2 >= 2 # => true
-# Comparisons can be chained
+# ¡Las comparaciones pueden ser concatenadas!
 1 < 2 < 3 # => true
 2 < 3 < 2 # => false
 
-# Strings are created with "
-"This is a string."
+# Strings se crean con " 
+"Esto es un string."
 
-# Character literals are written with '
+# Literales de caracteres se escriben con '
 'a'
 
-# A string can be indexed like an array of characters
-"This is a string"[1] # => 'T' # Julia indexes from 1
+# Una string puede ser indexado como una array de caracteres
+"Esto es un string."[1] # => 'E' # Julia indexes from 1
 # However, this is will not work well for UTF8 strings,
 # so iterating over strings is recommended (map, for loops, etc).
+# Sin embargo, esto no va a funcionar bien para strings UTF8, 
+# Lo que se recomienda es la iteración (map, for, etc).
 
-# $ can be used for string interpolation:
+# Puede ser utilizado para la interpolación de strings:
 "2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
-# You can put any Julia expression inside the parenthesis.
+# Se puede poner cualquier expresión de Julia dentro los paréntesis.
 
-# Another way to format strings is the printf macro.
-@printf "%d is less than %f" 4.5 5.3 # 5 is less than 5.300000
+# Otro forma de formatear strings es el printf macro
+@printf "%d es menor de %f" 4.5 5.3 # 5 es menor de 5.300000
 
-# Printing is easy
-println("I'm Julia. Nice to meet you!")
+# Imprimir es muy fácil
+println("Soy Julia. ¡Encantado de conocerte!")
 
 ####################################################
-## 2. Variables and Collections
+## 2. Variables y Colecciones
 ####################################################
 
-# You don't declare variables before assigning to them.
-some_var = 5 # => 5
-some_var # => 5
+# No hay necesidad de declarar las variables antes de asignarlas.
+una_variable = 5 # => 5
+una_variable # => 5
 
-# Accessing a previously unassigned variable is an error
+# Acceder a variables no asignadas previamente es una excepción.
 try
-    some_other_var # => ERROR: some_other_var not defined
+    otra_variable # => ERROR: some_other_var not defined
 catch e
     println(e)
 end
 
-# Variable names start with a letter.
-# After that, you can use letters, digits, underscores, and exclamation points.
-SomeOtherVar123! = 6 # => 6
+# Los nombres de variables comienzan con una letra.
+# Después de eso, usted puede utilizar letras, dígitos, guiones y signos de exclamación.
+OtraVariable123! = 6 # => 6
 
-# You can also use unicode characters
+# También puede utilizar caracteres unicode
 ☃ = 8 # => 8
-# These are especially handy for mathematical notation
+# Estos son especialmente útiles para la notación matemática
 2 * π # => 6.283185307179586
 
-# A note on naming conventions in Julia:
+# Una nota sobre las convenciones de nomenclatura de Julia:
 #
-# * Names of variables are in lower case, with word separation indicated by
-#   underscores ('\_').
+# * Los nombres de las variables aparecen en minúsculas, con separación de 
+#   palabra indicado por underscore ('\ _'). 
 #
-# * Names of Types begin with a capital letter and word separation is shown
-#   with CamelCase instead of underscores.
+# * Los nombres de los tipos comienzan con una letra mayúscula y separación de
+#   palabras se muestra Con CamelCase en vez de underscore.
 #
-# * Names of functions and macros are in lower case, without underscores.
+# * Los nombres de las funciones y las macros están en minúsculas, sin
+#   underscore.
 #
-# * Functions that modify their inputs have names that end in !. These
-#   functions are sometimes called mutating functions or in-place functions.
+# * Funciones que modifican sus inputs tienen nombres que terminan en!. Estos 
+#   funciones a veces se llaman mutating functions or in-place functions.
 
-# Arrays store a sequence of values indexed by integers 1 through n:
+# Los Arrays almacenan una secuencia de valores indexados entre 1 hasta n
 a = Int64[] # => 0-element Int64 Array
 
-# 1-dimensional array literals can be written with comma-separated values.
+# Literales de arrays 1-dimensionales se pueden escribir con valores separados por comas.
 b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6]
 b[1] # => 4
 b[end] # => 6
 
-# 2-dimentional arrays use space-separated values and semicolon-separated rows.
+# Los arrays 2-dimensionales usan valores separados por espacios y filas separados por punto y coma.
 matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
 
-# Add stuff to the end of a list with push! and append!
+# Añadir cosas a la final de una lista 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]
 
-# Remove from the end with pop
-pop!(b)        # => 6 and b is now [4,5]
+# Eliminar de la final con pop
+pop!(b)        # => 6 y b ahora es [4,5]
 
-# Let's put it back
-push!(b,6)   # b is now [4,5,6] again.
+# Vamos a ponerlo de nuevo 
+push!(b, 6)   # b es ahora [4,5,6] de nuevo.
 
-a[1] # => 1 # remember that Julia indexes from 1, not 0!
+a[1] # => 1 # recuerdan que los índices de Julia empiezan desde 1, no desde 0!
 
-# end is a shorthand for the last index. It can be used in any
-# indexing expression
+# end es una abreviatura para el último índice. Se puede utilizar en cualquier 
+# expresión  de indexación
 a[end] # => 6
 
-# we also have shift and unshift
-shift!(a) # => 1 and a is now [2,4,3,4,5,6]
+# tambien hay shift and unshift
+shift!(a) # => 1 y a es ahora [2,4,3,4,5,6]
 unshift!(a,7) # => [7,2,4,3,4,5,6]
 
-# Function names that end in exclamations points indicate that they modify
-# their argument.
+# Nombres de función que terminan en exclamaciones indican que modifican 
+# su argumento.
 arr = [5,4,6] # => 3-element Int64 Array: [5,4,6]
-sort(arr) # => [4,5,6]; arr is still [5,4,6]
-sort!(arr) # => [4,5,6]; arr is now [4,5,6]
+sort(arr) # => [4,5,6]; arr es todavía [5,4,6]
+sort!(arr) # => [4,5,6]; arr  es ahora [4,5,6]
 
-# Looking out of bounds is a BoundsError
+# 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
@@ -184,34 +187,33 @@ catch e
     println(e)
 end
 
-# Errors list the line and file they came from, even if it's in the standard
-# library. If you built Julia from source, you can look in the folder base
-# inside the julia folder to find these files.
+# Errors dan la línea y el archivo de su procedencia, aunque sea en el standard
+# library. Si construyes Julia de source, puedes buscar en la source para
+# encontrar estos archivos.
 
-# You can initialize arrays from ranges
+# Se puede inicializar arrays de un range
 a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5]
 
-# You can look at ranges with slice syntax.
+# Usted puede mirar en ranges con sintaxis slice.
 a[1:3] # => [1, 2, 3]
-a[2:] # => [2, 3, 4, 5]
 a[2:end] # => [2, 3, 4, 5]
 
-# Remove elements from an array by index with splice!
+# Eliminar elementos de una array por índice con splice!
 arr = [3,4,5]
-splice!(arr,2) # => 4 ; arr is now [3,5]
+splice!(arr,2) # => 4 ; arr es ahora [3,5]
 
-# Concatenate lists with append!
+# Concatenar listas con append!
 b = [1,2,3]
-append!(a,b) # Now a is [1, 2, 3, 4, 5, 1, 2, 3]
+append!(a,b) # ahroa a es [1, 2, 3, 4, 5, 1, 2, 3]
 
-# Check for existence in a list with in
+# Salida por la existencia de una lista con in
 in(1, a) # => true
 
-# Examine the length with length
+# Examinar la longitud con length
 length(a) # => 8
 
-# Tuples are immutable.
-tup = (1, 2, 3) # => (1,2,3) # an (Int64,Int64,Int64) tuple.
+# Tuples son immutable.
+tup = (1, 2, 3) # => (1,2,3) # un (Int64,Int64,Int64) tuple.
 tup[1] # => 1
 try:
     tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
@@ -219,204 +221,197 @@ catch e
     println(e)
 end
 
-# Many list functions also work on tuples
+# Muchas funciones de lista también trabajan en las tuples
 length(tup) # => 3
 tup[1:2] # => (1,2)
 in(2, tup) # => true
 
-# You can unpack tuples into variables
+# Se puede desempaquetar tuples en variables
 a, b, c = (1, 2, 3) # => (1,2,3)  # a is now 1, b is now 2 and c is now 3
 
-# Tuples are created even if you leave out the parentheses
+# Los tuples se crean, incluso si se omite el paréntesis
 d, e, f = 4, 5, 6 # => (4,5,6)
 
-# A 1-element tuple is distinct from the value it contains
+# Un tuple 1-elemento es distinto del valor que contiene
 (1,) == 1 # => false
 (1) == 1 # => true
 
-# Look how easy it is to swap two values
+# Mira que fácil es cambiar dos valores
 e, d = d, e  # => (5,4) # d is now 5 and e is now 4
 
 
-# Dictionaries store mappings
-empty_dict = Dict() # => Dict{Any,Any}()
+# Dictionaries almanecan mapeos
+dict_vacio = Dict() # => Dict{Any,Any}()
 
-# You can create a dictionary using a literal
-filled_dict = ["one"=> 1, "two"=> 2, "three"=> 3]
+# Se puede crear un dictionary usando un literal
+dict_lleno = ["one"=> 1, "two"=> 2, "three"=> 3]
 # => Dict{ASCIIString,Int64}
 
-# Look up values with []
-filled_dict["one"] # => 1
+# Busca valores con []
+dict_lleno["one"] # => 1
 
-# Get all keys
-keys(filled_dict)
+# Obtén todas las claves
+keys(dict_lleno)
 # => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
-# Note - dictionary keys are not sorted or in the order you inserted them.
+# Nota - claves del dictionary no están ordenados ni en el orden en que se insertan.
 
-# Get all values
-values(filled_dict)
+# Obtén todas las claves
+values(dict_lleno)
 # => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
-# Note - Same as above regarding key ordering.
+# Nota - Igual que el anterior en cuanto a ordenamiento de claves.
 
-# Check for existence of keys in a dictionary with in, haskey
-in(("one", 1), filled_dict) # => true
-in(("two", 3), filled_dict) # => false
-haskey(filled_dict, "one") # => true
-haskey(filled_dict, 1) # => false
+# Compruebe si hay existencia de claves en un dictionary con in y haskey
+in(("one", 1), dict_lleno) # => true
+in(("two", 3), dict_lleno) # => false
+haskey(dict_lleno, "one") # => true
+haskey(dict_lleno, 1) # => false
 
-# Trying to look up a non-existant key will raise an error
+# Tratando de buscar una clave inexistente producirá un error
 try
-    filled_dict["four"] # => ERROR: key not found: four in getindex at dict.jl:489
+    dict_lleno["four"] # => ERROR: key not found: four in getindex at dict.jl:489
 catch e
     println(e)
 end
 
-# Use the get method to avoid that error by providing a default value
+# Utilice el método get para evitar ese error proporcionando un valor predeterminado
 # get(dictionary,key,default_value)
-get(filled_dict,"one",4) # => 1
-get(filled_dict,"four",4) # => 4
-
-# Use Sets to represent collections of unordered, unique values
-empty_set = Set() # => Set{Any}()
-# Initialize a set with values
-filled_set = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
-
-# Add more values to a set
-push!(filled_set,5) # => Set{Int64}(5,4,2,3,1)
-
-# Check if the values are in the set
-in(2, filled_set) # => true
-in(10, filled_set) # => false
-
-# There are functions for set intersection, union, and difference.
-other_set = Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
-intersect(filled_set, other_set) # => Set{Int64}(3,4,5)
-union(filled_set, other_set) # => Set{Int64}(1,2,3,4,5,6)
+get(dict_lleno,"one",4) # => 1
+get(dict_lleno,"four",4) # => 4
+
+# Usa Sets para representar colecciones (conjuntos) de valores únicos, no ordenadas
+conjunto_vacio = Set() # => Set{Any}()
+# Iniciar una set de valores
+conjunto_lleno = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
+
+# Añadir más valores a un conjunto
+push!(conjunto_lleno,5) # => Set{Int64}(5,4,2,3,1)
+push!(conjunto_lleno,5) # => Set{Int64}(5,4,2,3,1)
+
+# Compruebe si los valores están en el conjunto
+in(2, conjunto_lleno) # => true
+in(10, conjunto_lleno) # => false
+
+# Hay funciones de intersección de conjuntos, la unión, y la diferencia.
+conjunto_otro= Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
+intersect(conjunto_lleno, conjunto_otro) # => Set{Int64}(3,4,5)
+union(conjunto_lleno, conjunto_otro) # => Set{Int64}(1,2,3,4,5,6)
 setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4)
 
 
 ####################################################
-## 3. Control Flow
+## 3. Control de Flujo
 ####################################################
 
-# Let's make a variable
-some_var = 5
-
-# Here is an if statement. Indentation is not meaningful in Julia.
-if some_var > 10
-    println("some_var is totally bigger than 10.")
-elseif some_var < 10    # This elseif clause is optional.
-    println("some_var is smaller than 10.")
-else                    # The else clause is optional too.
-    println("some_var is indeed 10.")
+# Hagamos una variable
+una_variable = 5
+
+# Aquí está una declaración de un 'if'. La indentación no es significativa en
+# Julia
+if una_variable > 10
+    println("una_variable es completamente mas grande que 10.")
+elseif una_variable < 10    # Este condición 'elseif' es opcional.
+    println("una_variable es mas chica que 10.")
+else                    # Esto también es opcional.
+    println("una_variable es de hecho 10.")
 end
-# => prints "some var is smaller than 10"
+# => imprime "una_variable es mas chica que 10."
 
-
-# For loops iterate over iterables.
-# Iterable types include Range, Array, Set, Dict, and String.
-for animal=["dog", "cat", "mouse"]
-    println("$animal is a mammal")
-    # You can use $ to interpolate variables or expression into strings
-end
-# prints:
-#    dog is a mammal
-#    cat is a mammal
-#    mouse is a mammal
-
-# You can use 'in' instead of '='.
-for animal in ["dog", "cat", "mouse"]
-    println("$animal is a mammal")
+# For itera sobre tipos iterables
+# Tipos iterables incluyen Range, Array, Set, Dict, y String.
+for animal=["perro", "gato", "raton"]
+    println("$animal es un mamifero")
+    # Se puede usar $ para interpolar variables o expresiónes en strings
 end
-# prints:
-#    dog is a mammal
-#    cat is a mammal
-#    mouse is a mammal
+# imprime:
+#    perro es un mamifero
+#    gato es un mamifero
+#    raton es un mamifero
 
-for a in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
-    println("$(a[1]) is a $(a[2])")
+for a in ["perro"=>"mamifero","gato"=>"mamifero","raton"=>"mamifero"]
+    println("$(a[1]) es un $(a[2])")
 end
-# prints:
-#    dog is a mammal
-#    cat is a mammal
-#    mouse is a mammal
+# imprime:
+#    perro es un mamifero
+#    gato es un mamifero
+#    raton es un mamifero
 
-for (k,v) in ["dog"=>"mammal","cat"=>"mammal","mouse"=>"mammal"]
-    println("$k is a $v")
+for (k,v) in ["perro"=>"mamifero","gato"=>"mamifero","raton"=>"mamifero"]
+    println("$k es un $v")
 end
-# prints:
-#    dog is a mammal
-#    cat is a mammal
-#    mouse is a mammal
+# imprime:
+#    perro es un mamifero
+#    gato es un mamifero
+#    raton es un mamifero
 
-# While loops loop while a condition is true
+# While itera hasta que una condición no se cumple.
 x = 0
 while x < 4
     println(x)
-    x += 1  # Shorthand for x = x + 1
+    x += 1  # versión corta de x = x + 1
 end
-# prints:
+# imprime:
 #   0
 #   1
 #   2
 #   3
 
-# Handle exceptions with a try/catch block
+# Maneja excepciones con un bloque try/except
 try
-   error("help")
+   error("ayuda")
 catch e
-   println("caught it $e")
+   println("capturando $e")
 end
-# => caught it ErrorException("help")
+# => capturando ErrorException("ayuda")
 
 
 ####################################################
-## 4. Functions
+## 4. Funciones
 ####################################################
 
-# The keyword 'function' creates new functions
-#function name(arglist)
-#  body...
+# Usa 'function' para crear nuevas funciones
+
+#function nombre(arglist)
+#  cuerpo...
 #end
-function add(x, y)
-    println("x is $x and y is $y")
+function suma(x, y)
+    println("x es $x e y es $y")
 
-    # Functions return the value of their last statement
+    # Las funciones devuelven el valor de su última declaración
     x + y
 end
 
-add(5, 6) # => 11 after printing out "x is 5 and y is 6"
+suma(5, 6) # => 11 # después de imprimir "x es 5 e y es de 6"
 
-# You can define functions that take a variable number of
-# positional arguments
+# Puedes definir funciones que toman un número variable de
+# argumentos posicionales
 function varargs(args...)
     return args
-    # use the keyword return to return anywhere in the function
+    # Usa la palabra clave return para devolver en cualquier lugar de la función
 end
 # => varargs (generic function with 1 method)
 
 varargs(1,2,3) # => (1,2,3)
 
-# The ... is called a splat.
-# We just used it in a function definition.
-# It can also be used in a fuction call,
-# where it will splat an Array or Tuple's contents into the argument list.
-Set([1,2,3])    # => Set{Array{Int64,1}}([1,2,3]) # produces a Set of Arrays
-Set([1,2,3]...) # => Set{Int64}(1,2,3) # this is equivalent to Set(1,2,3)
+# El ... se llama un splat.
+# Acabamos de utilizar lo en una definición de función.
+# También se puede utilizar en una llamada de función,
+# donde va splat un Array o el contenido de un Tuple en la lista de argumentos.
+Set([1,2,3])    # => Set{Array{Int64,1}}([1,2,3]) # Produce un Set de Arrays
+Set([1,2,3]...) # => Set{Int64}(1,2,3) # esto es equivalente a Set(1,2,3)
 
 x = (1,2,3)     # => (1,2,3)
-Set(x)          # => Set{(Int64,Int64,Int64)}((1,2,3)) # a Set of Tuples
+Set(x)          # => Set{(Int64,Int64,Int64)}((1,2,3)) # un Set de Tuples
 Set(x...)       # => Set{Int64}(2,3,1)
 
 
-# You can define functions with optional positional arguments
+# Puede definir funciones con argumentos posicionales opcionales
 function defaults(a,b,x=5,y=6)
-    return "$a $b and $x $y"
+    return "$a $b y $x $y"
 end
 
-defaults('h','g') # => "h g and 5 6"
-defaults('h','g','j') # => "h g and j 6"
-defaults('h','g','j','k') # => "h g and j k"
+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: no method defaults(Char,)
     defaults() # => ERROR: no methods defaults()
@@ -424,120 +419,122 @@ catch e
     println(e)
 end
 
-# You can define functions that take keyword arguments
-function keyword_args(;k1=4,name2="hello") # note the ;
-    return ["k1"=>k1,"name2"=>name2]
+# Puede definir funciones que toman argumentos de palabra clave
+function args_clave(;k1=4,nombre2="hola") # note the ;
+    return ["k1"=>k1,"nombre2"=>nombre2]
 end
 
-keyword_args(name2="ness") # => ["name2"=>"ness","k1"=>4]
-keyword_args(k1="mine") # => ["k1"=>"mine","name2"=>"hello"]
-keyword_args() # => ["name2"=>"hello","k1"=>4]
+args_clave(nombre2="ness") # => ["nombre2"=>"ness","k1"=>4]
+args_clave(k1="mine") # => ["k1"=>"mine","nombre2"=>"hola"]
+args_clave() # => ["nombre2"=>"hola","k1"=>4]
 
-# You can combine all kinds of arguments in the same function
-function all_the_args(normal_arg, optional_positional_arg=2; keyword_arg="foo")
-    println("normal arg: $normal_arg")
-    println("optional arg: $optional_positional_arg")
-    println("keyword arg: $keyword_arg")
+# Se puede combinar todo tipo de argumentos en la misma función
+function todos_los_args(arg_normal, arg_posicional_opcional=2; arg_clave="foo")
+    println("argumento normal: $arg_normal")
+    println("argumento optional: $arg_posicional_opcional")
+    println("argumento de clave: $arg_clave")
 end
 
-all_the_args(1, 3, keyword_arg=4)
-# prints:
-#   normal arg: 1
-#   optional arg: 3
-#   keyword arg: 4
+# todos_los_args(1, 3, arg_clave=4)
+# imprime:
+#   argumento normal: 1
+#   argumento optional: 3
+#   argumento de clave: 4
 
-# Julia has first class functions
-function create_adder(x)
-    adder = function (y)
+# Julia tiene funciones de primera clase
+function crear_suma(x)
+    suma = function (y)
         return x + y
     end
-    return adder
+    return suma
 end
 
-# This is "stabby lambda syntax" for creating anonymous functions
+# Esta es el sintaxis "stabby lambda" para crear funciones anónimas
 (x -> x > 2)(3) # => true
 
-# This function is identical to create_adder implementation above.
-function create_adder(x)
+# Esta función es idéntica a la crear_suma implementación anterior.
+function crear_suma(x)
     y -> x + y
 end
 
-# You can also name the internal function, if you want
-function create_adder(x)
-    function adder(y)
+# También se puede nombrar la función interna, si quieres
+function crear_suma(x)
+    function suma(y)
         x + y
     end
-    adder
+    suma
 end
 
-add_10 = create_adder(10)
-add_10(3) # => 13
+suma_10 = crear_suma(10)
+suma_10(3) # => 13
 
 
-# There are built-in higher order functions
-map(add_10, [1,2,3]) # => [11, 12, 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]
 
-# We can use list comprehensions for nicer maps
-[add_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
-[add_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+# Podemos usar listas por comprensión para mapeos
+[suma_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
+[suma_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
 
 ####################################################
-## 5. Types
+## 5. Tipos
 ####################################################
 
-# Julia has a type system.
-# Every value has a type; variables do not have types themselves.
-# You can use the `typeof` function to get the type of a value.
+# Julia tiene sistema de 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
 
-# Types are first-class values
+# Los tipos son valores de primera clase
 typeof(Int64) # => DataType
 typeof(DataType) # => DataType
-# DataType is the type that represents types, including itself.
+# DataType es el tipo que representa los tipos, incluyéndose a sí mismo.
 
-# Types are used for documentation, optimizations, and dispatch.
-# They are not statically checked.
+# Los tipos se usan para la documentación, optimizaciones, y envio.
+# No están comprobados estáticamente.
 
-# Users can define types
-# They are like records or structs in other languages.
-# New types are defined used the `type` keyword.
+# Los usuarios pueden definir tipos 
+# Son como registros o estructuras en otros idiomas. 
+# Nuevos tipos se definen utilizado la palabra clave `type`.
 
-# type Name
+# type Nombre
 #   field::OptionalType
 #   ...
 # end
-type Tiger
-  taillength::Float64
-  coatcolor # not including a type annotation is the same as `::Any`
+type Tigre
+  longituddecola::Float64
+  colordelpelaje # no incluyendo una anotación de tipo es el mismo que `::Any`
 end
 
-# The default constructor's arguments are the properties
-# of the type, in the order they are listed in the definition
-tigger = Tiger(3.5,"orange") # => Tiger(3.5,"orange")
+# Los argumentos del constructor por default son las propiedades 
+# del tipo, en el orden en que están listados en la definición
+tigger = Tigre(3.5,"anaranjado") # => Tiger(3.5,"anaranjado")
 
-# The type doubles as the constructor function for values of that type
-sherekhan = typeof(tigger)(5.6,"fire") # => Tiger(5.6,"fire")
+# El tipo funciona como la función constructora de valores de ese tipo
+sherekhan = typeof(tigger)(5.6,"fuego") # => Tiger(5.6,"fuego")
 
 # These struct-style types are called concrete types
 # They can be instantiated, but cannot have subtypes.
 # The other kind of types is abstract types.
+# Este estilo de tipos son llamados tipos concrete 
+# Se pueden crear instancias, pero no pueden tener subtipos. 
+# La otra clase de tipos es tipos abstractos (abstract types).
 
-# abstract Name
-abstract Cat # just a name and point in the type hierarchy
+# abstract Nombre
+abstract Gato # sólo un nombre y un punto en la jerarquía de tipos
 
-# Abstract types cannot be instantiated, but can have subtypes.
-# For example, Number is an abstract type
+# De los tipos Abstract no se pueden crear instancias, pero pueden tener
+# subtipos.  Por ejemplo, Number es un tipo abstracto.
 subtypes(Number) # => 6-element Array{Any,1}:
                  #     Complex{Float16}
                  #     Complex{Float32}
                  #     Complex{Float64}
                  #     Complex{T<:Real}
-                 #     ImaginaryUnit
                  #     Real
-subtypes(Cat) # => 0-element Array{Any,1}
+subtypes(Gato) # => 0-element Array{Any,1}
 
-# Every type has a super type; use the `super` function to get it.
+# Cada tipo tiene un supertipo, utilice la función `súper` para conseguirlo.
 typeof(5) # => Int64
 super(Int64) # => Signed
 super(Signed) # => Real
@@ -545,132 +542,136 @@ super(Real) # => Number
 super(Number) # => Any
 super(super(Signed)) # => Number
 super(Any) # => Any
-# All of these type, except for Int64, are abstract.
+# Todo de estos tipos, a excepción de Int64, son abstractos.
 
-# <: is the subtyping operator
-type Lion <: Cat # Lion is a subtype of Cat
-  mane_color
-  roar::String
+# <: es el operador de subtipos
+type Leon <: Gato # Leon es un subtipo de Gato
+  color_de_crin
+  rugido::String
 end
 
-# You can define more constructors for your type
-# Just define a function of the same name as the type
-# and call an existing constructor to get a value of the correct type
-Lion(roar::String) = Lion("green",roar)
-# This is an outer constructor because it's outside the type definition
-
-type Panther <: Cat # Panther is also a subtype of Cat
-  eye_color
-  Panther() = new("green")
-  # Panthers will only have this constructor, and no default constructor.
+# Se puede definir más constructores para su tipo.
+# Sólo defina una función del mismo nombre que el tipo
+# y llame a un constructor existente para obtener un valor del tipo correcto
+Leon(rugido::String) = Leon("verde",rugido)
+# Este es un constructor externo porque es fuera de la definición del tipo
+
+type Pantera <: Gato # Pantera tambien es un a subtipo de Cat
+  color_de_ojos
+  Pantera() = new("verde")
+    # Panteras sólo tendrán este constructor, y ningún constructor
+    # predeterminado.
 end
-# Using inner constructors, like Panther does, gives you control
-# over how values of the type can be created.
-# When possible, you should use outer constructors rather than inner ones.
+# Utilizar constructores internos, como Panther hace, le da control sobre cómo
+# se pueden crear valores del tipo.  Cuando sea posible, debe utilizar
+# constructores exteriores en lugar de los internos.
 
 ####################################################
-## 6. Multiple-Dispatch
+## 6.  Envio múltiple
 ####################################################
 
-# In Julia, all named functions are generic functions
-# This means that they are built up from many small methods
-# Each constructor for Lion is a method of the generic function Lion.
+# En Julia, todas las funciones nombradas son funciones genéricas.
+# Esto significa que se construyen a partir de muchos métodos pequeños 
+# Cada constructor de León es un método de la función genérica León.
 
-# For a non-constructor example, let's make a function meow:
+# Por ejemplo no constructor, vamos a hacer un maullar función:
 
-# Definitions for Lion, Panther, Tiger
-function meow(animal::Lion)
-  animal.roar # access type properties using dot notation
+# Definiciones para Leon, Pantera, y Tigre
+function maullar(animal::Leon)
+  animal.rugido # acceso utilizando notación de puntos
 end
 
-function meow(animal::Panther)
+function maullar(animal::Pantera)
   "grrr"
 end
 
-function meow(animal::Tiger)
+function maullar(animal::Tigre)
   "rawwwr"
 end
 
-# Testing the meow function
-meow(tigger) # => "rawwr"
-meow(Lion("brown","ROAAR")) # => "ROAAR"
-meow(Panther()) # => "grrr"
+# Prueba de la función maullar
+maullar(tigger) # => "rawwr"
+maullar(Leon("cafe","ROAAR")) # => "ROAAR"
+maullar(Pantera()) # => "grrr"
 
-# Review the local type hierarchy
-issubtype(Tiger,Cat) # => false
-issubtype(Lion,Cat) # => true
-issubtype(Panther,Cat) # => true
+# Revisar la jerarquía de tipos locales
+issubtype(Tigre,Gato) # => false
+issubtype(Leon,Gato) # => true
+issubtype(Pantera,Gato) # => true
 
-# Defining a function that takes Cats
-function pet_cat(cat::Cat)
-  println("The cat says $(meow(cat))")
+# Definición de una función que toma Gatos
+function mascota(gato::Gato)
+  println("El gato dice $(maullar(gato))")
 end
 
-pet_cat(Lion("42")) # => prints "The cat says 42"
+mascota(Leon("42")) # => imprime "El gato dice 42"
 try
-    pet_cat(tigger) # => ERROR: no method pet_cat(Tiger,)
+    mascota(tigger) # => ERROR: no method mascota(Tigre))
 catch e
     println(e)
 end
 
-# In OO languages, single dispatch is common;
-# this means that the method is picked based on the type of the first argument.
-# In Julia, all of the argument types contribute to selecting the best method.
+# En los lenguajes orientados a objetos, expedición única es común. Esto
+# significa que el método se recogió basándose en el tipo del primer argumento.
+# En Julia, todos los tipos de argumentos contribuyen a seleccionar el mejor
+# método.
 
-# Let's define a function with more arguments, so we can see the difference
-function fight(t::Tiger,c::Cat)
-  println("The $(t.coatcolor) tiger wins!")
+# Vamos a definir una función con más argumentos, para que podamos ver la
+# diferencia
+function pelear(t::Tigre,c::Gato)
+  println("¡El tigre $(t.colordelpelaje) gana!")
 end
-# => fight (generic function with 1 method)
+# => pelear (generic function with 1 method)
 
-fight(tigger,Panther()) # => prints The orange tiger wins!
-fight(tigger,Lion("ROAR")) # => prints The orange tiger wins!
+pelear(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana!
+pelear(tigger,Leon("ROAR")) # => ¡El tigre anaranjado gana!
 
-# Let's change the behavior when the Cat is specifically a Lion
-fight(t::Tiger,l::Lion) = println("The $(l.mane_color)-maned lion wins!")
-# => fight (generic function with 2 methods)
+# Vamos a cambiar el comportamiento cuando el Gato es específicamente un Leon
+pelear(t::Tigre,l::Leon) = println("!El león con melena $(l.color_de_crin) gana!")
+# => pelear (generic function with 2 methods)
 
-fight(tigger,Panther()) # => prints The orange tiger wins!
-fight(tigger,Lion("ROAR")) # => prints The green-maned lion wins!
+pelear(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana!
+pelear(tigger,Leon("ROAR")) # => imprime ¡El león con melena verde gana!
 
-# We don't need a Tiger in order to fight
-fight(l::Lion,c::Cat) = println("The victorious cat says $(meow(c))")
+# No necesitamos un tigre para poder luchar
+pelear(l::Leon,c::Gato) = println("El gato victorioso dice $(maullar(c))")
 # => fight (generic function with 3 methods)
 
-fight(Lion("balooga!"),Panther()) # => prints The victorious cat says grrr
+pelear(Leon("balooga!"),Pantera()) # => imprime El gato victorioso dice grrr
 try
-  fight(Panther(),Lion("RAWR")) # => ERROR: no method fight(Panther,Lion)
+  pelear(Pantera(),Leon("RAWR")) # => ERROR: no method pelear(Pantera, Leon))
 catch
 end
 
-# Also let the cat go first
-fight(c::Cat,l::Lion) = println("The cat beats the Lion")
-# => Warning: New definition
-#    fight(Cat,Lion) at none:1
-# is ambiguous with
-#    fight(Lion,Cat) at none:2.
-# Make sure
-#    fight(Lion,Lion)
-# is defined first.
-#fight (generic function with 4 methods)
+# Permítanos dejar que el gato vaya 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)
 
-# This warning is because it's unclear which fight will be called in:
-fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The victorious cat says rarrr
-# The result may be different in other versions of Julia
+# Esta advertencia se debe a que no está claro que metodo de pelear será llamado
+# en:
+pelear(Leon("RAR"),Leon("brown","rarrr")) # => imprime El gato victorioso dice rarrr
+# El resultado puede ser diferente en otras versiones de Julia
 
-fight(l::Lion,l2::Lion) = println("The lions come to a tie")
-fight(Lion("RAR"),Lion("brown","rarrr")) # => prints The lions come to a tie
+pelear(l::Leon,l2::Leon) = println("Los leones llegan a un empate")
+pelear(Leon("RAR"),Leon("brown","rarrr")) # => imprime Los leones llegan a un empate
 
 
-# Under the hood
-# You can take a look at the llvm  and the assembly code generated.
+# Bajo el capó
+# Se puede echar un vistazo a la LLVM y el código ensamblador generado.
 
-square_area(l) = l * l      # square_area (generic function with 1 method)
+area_cuadrada(l) = l * l      # area_cuadrada (generic function with 1 method)
 
-square_area(5) #25
+area_cuadrada(5) #25
 
-# What happens when we feed square_area an integer?
-code_native(square_area, (Int32,))  
+# ¿Qué sucede cuando damos square_area diferentes argumentos?
+code_native(area_cuadrada, (Int32,))  
 	#	    .section    __TEXT,__text,regular,pure_instructions
 	#	Filename: none
 	#	Source line: 1              # Prologue
@@ -682,7 +683,7 @@ code_native(square_area, (Int32,))
 	#	    pop RBP                 # Restore old base pointer
 	#	    ret                     # Result will still be in RAX
 
-code_native(square_area, (Float32,))
+code_native(area_cuadrada, (Float32,))
 	#	    .section    __TEXT,__text,regular,pure_instructions
 	#	Filename: none
 	#	Source line: 1
@@ -693,7 +694,7 @@ code_native(square_area, (Float32,))
 	#	    pop RBP
 	#	    ret
 
-code_native(square_area, (Float64,))
+code_native(area_cuadrada, (Float64,))
 	#	    .section    __TEXT,__text,regular,pure_instructions
 	#	Filename: none
 	#	Source line: 1
@@ -704,13 +705,13 @@ code_native(square_area, (Float64,))
 	#	    pop RBP
 	#	    ret
 	#	
-# Note that julia will use floating point instructions if any of the
-# arguements are floats.
-# Let's calculate the area of a circle 
-circle_area(r) = pi * r * r     # circle_area (generic function with 1 method)
-circle_area(5)                  # 78.53981633974483
+# Tenga en cuenta que Julia usará instrucciones de "floating point" si alguno de
+# los argumentos son "floats"
+# Vamos a calcular el área de un círculo
+area_circulo(r) = pi * r * r     # circle_area (generic function with 1 method)
+area_circulo(5)                  # 78.53981633974483
 
-code_native(circle_area, (Int32,))
+code_native(area_circulo, (Int32,))
 	#	    .section    __TEXT,__text,regular,pure_instructions
 	#	Filename: none
 	#	Source line: 1
@@ -725,7 +726,7 @@ code_native(circle_area, (Int32,))
 	#	    ret
 	#
 
-code_native(circle_area, (Float64,))
+code_native(area_circulo, (Float64,))
 	#	    .section    __TEXT,__text,regular,pure_instructions
 	#	Filename: none
 	#	Source line: 1
@@ -740,8 +741,9 @@ code_native(circle_area, (Float64,))
 	#	
 ```
 
-## Further Reading
+# # Lectura adicional
+
+Puedes obtener muchos más detalles en [The Julia Manual](http://docs.julialang.org/en/latest/manual/)
 
-You can get a lot more detail from [The Julia Manual](http://docs.julialang.org/en/latest/manual/)
+El mejor lugar para obtener ayuda con Julia es el (muy amable) [lista de correos](https://groups.google.com/forum/#!forum/julia-users).
 
-The best place to get help with Julia is the (very friendly) [mailing list](https://groups.google.com/forum/#!forum/julia-users).
-- 
cgit v1.2.3


From 21bed16bba39002432403874bb0779c865d6aebd Mon Sep 17 00:00:00 2001
From: Guillermo Garza <ggarza23@gmail.com>
Date: Wed, 19 Mar 2014 00:30:25 -0500
Subject: Translate introduction, too.

---
 es-es/julia-es.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'es-es')

diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 6c5a6428..3d131773 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -5,13 +5,13 @@ contributors:
 filename: learnjulia.jl
 ---
 
-Julia is a new homoiconic functional language focused on technical computing.
-While having the full power of homoiconic macros, first-class functions, and low-level control, Julia is as easy to learn and use as Python.
+Julia es un nuevo lenguaje funcional homoiconic enfocado en computación técnica.
+Mientras que tiene todo el poder de macros homoiconic, funciones de primera clase, y control de bajo nivel, Julia es tan fácil de aprender y utilizar como Python.
 
-This is based on the current development version of Julia, as of October 18th, 2013.
+Esto se basa en la versión de desarrollo actual de Julia, del 18 de octubre de 2013.
 
 ```ruby
-
+j
 # Comentarios de una línea comienzan con una almohadilla (o signo gato)
 #= Commentarios multilinea pueden escribirse
    usando '#=' antes de que el texto  and '=#' 
-- 
cgit v1.2.3


From 0b05a9db124988f37c82115837d1014703574edc Mon Sep 17 00:00:00 2001
From: Guillermo Garza <ggarza23@gmail.com>
Date: Wed, 19 Mar 2014 00:39:44 -0500
Subject: Trim lines to 80 characters

---
 es-es/julia-es.html.markdown | 42 ++++++++++++++++++++++++++----------------
 1 file changed, 26 insertions(+), 16 deletions(-)

(limited to 'es-es')

diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 3d131773..3897efff 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -6,9 +6,12 @@ filename: learnjulia.jl
 ---
 
 Julia es un nuevo lenguaje funcional homoiconic enfocado en computación técnica.
-Mientras que tiene todo el poder de macros homoiconic, funciones de primera clase, y control de bajo nivel, Julia es tan fácil de aprender y utilizar como Python.
+Mientras que tiene todo el poder de macros homoiconic, funciones de primera
+clase, y control de bajo nivel, Julia es tan fácil de aprender y utilizar como
+Python.
 
-Esto se basa en la versión de desarrollo actual de Julia, del 18 de octubre de 2013.
+Esto se basa en la versión de desarrollo actual de Julia, del 18 de octubre de
+2013.
 
 ```ruby
 j
@@ -53,7 +56,8 @@ div (5, 2) # => 2 # para un resultado truncado, usa div
 2 >> 1  # => 1 # arithmetic shift right
 2 << 1  # => 4 # logical/arithmetic shift left
 
-# Se puede utilizar la función bits para ver la representación binaria de un número.
+# Se puede utilizar la función bits para ver la representación binaria de un
+# número.
 bits(12345)
 # => "0000000000000000000000000000000000000000000000000011000000111001"
 bits(12345.0)
@@ -117,7 +121,8 @@ catch e
 end
 
 # Los nombres de variables comienzan con una letra.
-# Después de eso, usted puede utilizar letras, dígitos, guiones y signos de exclamación.
+# Después de eso, usted puede utilizar letras, dígitos, guiones y signos de
+# exclamación.
 OtraVariable123! = 6 # => 6
 
 # También puede utilizar caracteres unicode
@@ -142,12 +147,14 @@ OtraVariable123! = 6 # => 6
 # Los Arrays almacenan una secuencia de valores indexados entre 1 hasta n
 a = Int64[] # => 0-element Int64 Array
 
-# Literales de arrays 1-dimensionales se pueden escribir con valores separados por comas.
+# Literales de arrays 1-dimensionales se pueden escribir con valores separados
+# por comas.
 b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6]
 b[1] # => 4
 b[end] # => 6
 
-# Los arrays 2-dimensionales usan valores separados por espacios y filas separados por punto y coma.
+# Los arrays 2-dimensionales usan valores separados por espacios y filas
+# separados por punto y coma.
 matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
 
 # Añadir cosas a la final de una lista con push! y append!
@@ -253,7 +260,8 @@ dict_lleno["one"] # => 1
 # Obtén todas las claves
 keys(dict_lleno)
 # => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
-# Nota - claves del dictionary no están ordenados ni en el orden en que se insertan.
+# Nota - claves del dictionary no están ordenados ni en el orden en que se
+# insertan.
 
 # Obtén todas las claves
 values(dict_lleno)
@@ -261,24 +269,26 @@ values(dict_lleno)
 # Nota - Igual que el anterior en cuanto a ordenamiento de claves.
 
 # Compruebe si hay existencia de claves en un dictionary con in y haskey
-in(("one", 1), dict_lleno) # => true
-in(("two", 3), dict_lleno) # => false
+in(("uno", 1), dict_lleno) # => true
+in(("tres", 3), dict_lleno) # => false
 haskey(dict_lleno, "one") # => true
 haskey(dict_lleno, 1) # => false
 
 # Tratando de buscar una clave inexistente producirá un error
 try
-    dict_lleno["four"] # => ERROR: key not found: four in getindex at dict.jl:489
+    dict_lleno["dos"] # => ERROR: key not found: dos in getindex at dict.jl:489
 catch e
     println(e)
 end
 
-# Utilice el método get para evitar ese error proporcionando un valor predeterminado
+# Utilice el método get para evitar ese error proporcionando un valor
+# predeterminado
 # get(dictionary,key,default_value)
 get(dict_lleno,"one",4) # => 1
 get(dict_lleno,"four",4) # => 4
 
-# Usa Sets para representar colecciones (conjuntos) de valores únicos, no ordenadas
+# Usa Sets para representar colecciones (conjuntos) de valores únicos, no
+# ordenadas
 conjunto_vacio = Set() # => Set{Any}()
 # Iniciar una set de valores
 conjunto_lleno = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
@@ -627,11 +637,11 @@ pelear(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana!
 pelear(tigger,Leon("ROAR")) # => ¡El tigre anaranjado gana!
 
 # Vamos a cambiar el comportamiento cuando el Gato es específicamente un Leon
-pelear(t::Tigre,l::Leon) = println("!El león con melena $(l.color_de_crin) gana!")
+pelear(t::Tigre,l::Leon) = println("El león con melena $(l.color_de_crin) gana")
 # => pelear (generic function with 2 methods)
 
 pelear(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana!
-pelear(tigger,Leon("ROAR")) # => imprime ¡El león con melena verde gana!
+pelear(tigger,Leon("ROAR")) # => imprime 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))")
@@ -656,11 +666,11 @@ pelear(c::Gato,l::Leon) = println("El gato le gana al León")
 
 # Esta advertencia se debe a que no está claro que metodo de pelear será llamado
 # en:
-pelear(Leon("RAR"),Leon("brown","rarrr")) # => imprime El gato victorioso dice rarrr
+pelear(Leon("RAR"),Leon("cafe","rar")) # => imprime 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("RAR"),Leon("brown","rarrr")) # => imprime Los leones llegan a un empate
+pelear(Leon("GR"),Leon("cafe","rar")) # => imprime Los leones llegan a un empate
 
 
 # Bajo el capó
-- 
cgit v1.2.3


From 82ac7779819b7117638b5d41d1adee8e9c4ab20d Mon Sep 17 00:00:00 2001
From: Guillermo Garza <ggarza23@gmail.com>
Date: Wed, 19 Mar 2014 00:43:21 -0500
Subject: Fix header at beginning of file.

---
 es-es/julia-es.html.markdown | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 3897efff..2dcc915e 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -2,7 +2,9 @@
 language: julia
 contributors:
     - ["Leah Hanson", "http://leahhanson.us"]
-filename: learnjulia.jl
+    - ["Guillermo Garza" ]
+filename: learnjulia-es.jl
+lang: es-es
 ---
 
 Julia es un nuevo lenguaje funcional homoiconic enfocado en computación técnica.
-- 
cgit v1.2.3


From e5d15eec06f7708e2ff423ac78f3effbd29f051b Mon Sep 17 00:00:00 2001
From: Guillermo Garza <ggarza23@gmail.com>
Date: Fri, 21 Mar 2014 14:29:30 -0500
Subject: Fix typos in Spanish Julia

---
 es-es/julia-es.html.markdown | 90 ++++++++++++++++++++++----------------------
 1 file changed, 44 insertions(+), 46 deletions(-)

(limited to 'es-es')

diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 2dcc915e..4b79674d 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -8,19 +8,20 @@ lang: es-es
 ---
 
 Julia es un nuevo lenguaje funcional homoiconic enfocado en computación técnica.
-Mientras que tiene todo el poder de macros homoiconic, funciones de primera
+Aunque que tiene todo el poder de macros homoiconic, funciones de primera
 clase, y control de bajo nivel, Julia es tan fácil de aprender y utilizar como
 Python.
 
 Esto se basa en la versión de desarrollo actual de Julia, del 18 de octubre de
 2013.
 
-```ruby
-j
+```julia
+
 # Comentarios de una línea comienzan con una almohadilla (o signo gato)
+
 #= Commentarios multilinea pueden escribirse
-   usando '#=' antes de que el texto  and '=#' 
-  después del texto. También se pueden anidar.
+   usando '#=' antes de el texto  y '=#' 
+   después del texto. También se pueden anidar.
 =#
 
 ####################################################
@@ -40,10 +41,10 @@ j
 8 - 1 # => 7
 10 * 2 # => 20
 35 / 5 # => 7.0
-5/2 # => 2.5 # dividir un Int por un Int siempre resulta en un Fload
+5/2 # => 2.5 # dividir un Int por un Int siempre resulta en un Float
 div (5, 2) # => 2 # para un resultado truncado, usa div
 5 \ 35 # => 7.0
-2 ^ 2 # => 4 # exponente, no exclusivo bit a bit
+2 ^ 2 # => 4 # exponente, no es xor
 12 % 10 # => 2
 
 # Refuerza la precedencia con paréntesis
@@ -91,17 +92,15 @@ false
 'a'
 
 # Una string puede ser indexado como una array de caracteres
-"Esto es un string."[1] # => 'E' # Julia indexes from 1
-# However, this is will not work well for UTF8 strings,
-# so iterating over strings is recommended (map, for loops, etc).
+"Esto es un string."[1] # => 'E' # �ndices en Julia empiezen del 1
 # Sin embargo, esto no va a funcionar bien para strings UTF8, 
 # Lo que se recomienda es la iteración (map, for, etc).
 
-# Puede ser utilizado para la interpolación de strings:
+# $ puede ser utilizado para la interpolación de strings:
 "2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
 # Se puede poner cualquier expresión de Julia dentro los paréntesis.
 
-# Otro forma de formatear strings es el printf macro
+# Otro forma de formatear strings es el macro printf
 @printf "%d es menor de %f" 4.5 5.3 # 5 es menor de 5.300000
 
 # Imprimir es muy fácil
@@ -123,7 +122,7 @@ catch e
 end
 
 # Los nombres de variables comienzan con una letra.
-# Después de eso, usted puede utilizar letras, dígitos, guiones y signos de
+# Después de eso, puedes utilizar letras, dígitos, guiones y signos de
 # exclamación.
 OtraVariable123! = 6 # => 6
 
@@ -138,13 +137,13 @@ OtraVariable123! = 6 # => 6
 #   palabra indicado por underscore ('\ _'). 
 #
 # * Los nombres de los tipos comienzan con una letra mayúscula y separación de
-#   palabras se muestra Con CamelCase en vez de underscore.
+#   palabras se muestra con CamelCase en vez de underscore.
 #
-# * Los nombres de las funciones y las macros están en minúsculas, sin
+# * Los nombres de las funciones y los macros están en minúsculas, sin
 #   underscore.
 #
 # * Funciones que modifican sus inputs tienen nombres que terminan en!. Estos 
-#   funciones a veces se llaman mutating functions or in-place functions.
+#   funciones a veces se llaman mutating functions o in-place functions.
 
 # Los Arrays almacenan una secuencia de valores indexados entre 1 hasta n
 a = Int64[] # => 0-element Int64 Array
@@ -159,7 +158,7 @@ b[end] # => 6
 # separados por punto y coma.
 matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
 
-# Añadir cosas a la final de una lista con push! y append!
+# Añadir cosas al final de una lista con push! y append!
 push!(a,1)     # => [1]
 push!(a,2)     # => [1,2]
 push!(a,4)     # => [1,2,4]
@@ -178,11 +177,11 @@ a[1] # => 1 # recuerdan que los índices de Julia empiezan desde 1, no desde 0!
 # expresión  de indexación
 a[end] # => 6
 
-# tambien hay shift and unshift
+# tambien 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]
 
-# Nombres de función que terminan en exclamaciones indican que modifican 
+# Nombres de funciónes que terminan en exclamaciones indican que modifican 
 # su argumento.
 arr = [5,4,6] # => 3-element Int64 Array: [5,4,6]
 sort(arr) # => [4,5,6]; arr es todavía [5,4,6]
@@ -197,13 +196,13 @@ catch e
 end
 
 # Errors dan la línea y el archivo de su procedencia, aunque sea en el standard
-# library. Si construyes Julia de source, puedes buscar en la source para
+# library. Si construyes Julia de source, puedes buscar en el source para
 # encontrar estos archivos.
 
 # Se puede inicializar arrays de un range
 a = [1:5] # => 5-element Int64 Array: [1,2,3,4,5]
 
-# Usted puede mirar en ranges con sintaxis slice.
+# Puedes mirar en ranges con sintaxis slice.
 a[1:3] # => [1, 2, 3]
 a[2:end] # => [2, 3, 4, 5]
 
@@ -215,10 +214,10 @@ splice!(arr,2) # => 4 ; arr es ahora [3,5]
 b = [1,2,3]
 append!(a,b) # ahroa a es [1, 2, 3, 4, 5, 1, 2, 3]
 
-# Salida por la existencia de una lista con in
+# Comprobamos la existencia en una lista con in
 in(1, a) # => true
 
-# Examinar la longitud con length
+# Examina la longitud con length
 length(a) # => 8
 
 # Tuples son immutable.
@@ -235,7 +234,7 @@ length(tup) # => 3
 tup[1:2] # => (1,2)
 in(2, tup) # => true
 
-# Se puede desempaquetar tuples en variables
+# Se puede desempacar tuples en variables
 a, b, c = (1, 2, 3) # => (1,2,3)  # a is now 1, b is now 2 and c is now 3
 
 # Los tuples se crean, incluso si se omite el paréntesis
@@ -259,13 +258,13 @@ dict_lleno = ["one"=> 1, "two"=> 2, "three"=> 3]
 # Busca valores con []
 dict_lleno["one"] # => 1
 
-# Obtén todas las claves
+# Obtén todas las claves 
 keys(dict_lleno)
 # => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
 # Nota - claves del dictionary no están ordenados ni en el orden en que se
 # insertan.
 
-# Obtén todas las claves
+# Obtén todos los valores
 values(dict_lleno)
 # => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
 # Nota - Igual que el anterior en cuanto a ordenamiento de claves.
@@ -276,7 +275,7 @@ in(("tres", 3), dict_lleno) # => false
 haskey(dict_lleno, "one") # => true
 haskey(dict_lleno, 1) # => false
 
-# Tratando de buscar una clave inexistente producirá un error
+# Tratando de buscar una clave que no existe producirá un error
 try
     dict_lleno["dos"] # => ERROR: key not found: dos in getindex at dict.jl:489
 catch e
@@ -347,7 +346,7 @@ end
 #    gato es un mamifero
 #    raton es un mamifero
 
-for (k,v) in ["perro"=>"mamifero","gato"=>"mamifero","raton"=>"mamifero"]
+for (k,v) in ["perro"=>"mamifero", "gato"=>"mamifero", "raton"=>"mamifero"]
     println("$k es un $v")
 end
 # imprime:
@@ -367,7 +366,7 @@ end
 #   2
 #   3
 
-# Maneja excepciones con un bloque try/except
+# Maneja excepciones con un bloque try/catch
 try
    error("ayuda")
 catch e
@@ -431,7 +430,7 @@ catch e
     println(e)
 end
 
-# Puede definir funciones que toman argumentos de palabra clave
+# Puedes definir funciones que toman argumentos de palabra clave
 function args_clave(;k1=4,nombre2="hola") # note the ;
     return ["k1"=>k1,"nombre2"=>nombre2]
 end
@@ -440,14 +439,14 @@ args_clave(nombre2="ness") # => ["nombre2"=>"ness","k1"=>4]
 args_clave(k1="mine") # => ["k1"=>"mine","nombre2"=>"hola"]
 args_clave() # => ["nombre2"=>"hola","k1"=>4]
 
-# Se puede combinar todo tipo de argumentos en la misma función
+# Puedes combinar todo tipo de argumentos en la misma función
 function todos_los_args(arg_normal, arg_posicional_opcional=2; arg_clave="foo")
     println("argumento normal: $arg_normal")
     println("argumento optional: $arg_posicional_opcional")
     println("argumento de clave: $arg_clave")
 end
 
-# todos_los_args(1, 3, arg_clave=4)
+todos_los_args(1, 3, arg_clave=4)
 # imprime:
 #   argumento normal: 1
 #   argumento optional: 3
@@ -469,7 +468,7 @@ function crear_suma(x)
     y -> x + y
 end
 
-# También se puede nombrar la función interna, si quieres
+# También puedes nombrar la función interna, si quieres
 function crear_suma(x)
     function suma(y)
         x + y
@@ -526,9 +525,7 @@ tigger = Tigre(3.5,"anaranjado") # => Tiger(3.5,"anaranjado")
 # El tipo funciona como la función constructora de valores de ese tipo
 sherekhan = typeof(tigger)(5.6,"fuego") # => Tiger(5.6,"fuego")
 
-# These struct-style types are called concrete types
-# They can be instantiated, but cannot have subtypes.
-# The other kind of types is abstract types.
+
 # Este estilo de tipos son llamados tipos concrete 
 # Se pueden crear instancias, pero no pueden tener subtipos. 
 # La otra clase de tipos es tipos abstractos (abstract types).
@@ -574,8 +571,8 @@ type Pantera <: Gato # Pantera tambien es un a subtipo de Cat
     # Panteras sólo tendrán este constructor, y ningún constructor
     # predeterminado.
 end
-# Utilizar constructores internos, como Panther hace, le da control sobre cómo
-# se pueden crear valores del tipo.  Cuando sea posible, debe utilizar
+# Utilizar constructores internos, como Panther hace, te da control sobre cómo
+# se pueden crear valores del tipo.  Cuando sea posible, debes utilizar
 # constructores exteriores en lugar de los internos.
 
 ####################################################
@@ -584,9 +581,9 @@ end
 
 # En Julia, todas las funciones nombradas son funciones genéricas.
 # Esto significa que se construyen a partir de muchos métodos pequeños 
-# Cada constructor de León es un método de la función genérica León.
+# Cada constructor de Leon es un método de la función genérica Leon.
 
-# Por ejemplo no constructor, vamos a hacer un maullar función:
+# Por ejemplo, vamos a hacer un maullar función:
 
 # Definiciones para Leon, Pantera, y Tigre
 function maullar(animal::Leon)
@@ -655,7 +652,7 @@ try
 catch
 end
 
-# Permítanos dejar que el gato vaya primero
+# Un metodo con el gato primero
 pelear(c::Gato,l::Leon) = println("El gato le gana al León")
 # Warning: New definition
 #     pelear(Gato,Leon) at none:1
@@ -675,14 +672,14 @@ pelear(l::Leon,l2::Leon) = println("Los leones llegan a un empate")
 pelear(Leon("GR"),Leon("cafe","rar")) # => imprime Los leones llegan a un empate
 
 
-# Bajo el capó
+# Un vistazo al nivel bajo
 # Se puede echar un vistazo a la LLVM y el código ensamblador generado.
 
 area_cuadrada(l) = l * l      # area_cuadrada (generic function with 1 method)
 
-area_cuadrada(5) #25
+area_cuadrada(5) # => 25
 
-# ¿Qué sucede cuando damos square_area diferentes argumentos?
+# ¿Qué sucede cuando damos area_cuadrada diferentes argumentos?
 code_native(area_cuadrada, (Int32,))  
 	#	    .section    __TEXT,__text,regular,pure_instructions
 	#	Filename: none
@@ -717,7 +714,8 @@ code_native(area_cuadrada, (Float64,))
 	#	    pop RBP
 	#	    ret
 	#	
-# Tenga en cuenta que Julia usará instrucciones de "floating point" si alguno de
+
+# Ten en cuenta que Julia usará instrucciones de "floating point" si alguno de
 # los argumentos son "floats"
 # Vamos a calcular el área de un círculo
 area_circulo(r) = pi * r * r     # circle_area (generic function with 1 method)
@@ -753,7 +751,7 @@ code_native(area_circulo, (Float64,))
 	#	
 ```
 
-# # Lectura adicional
+## ¿Listo para más?
 
 Puedes obtener muchos más detalles en [The Julia Manual](http://docs.julialang.org/en/latest/manual/)
 
-- 
cgit v1.2.3


From 4e85becf286cafe347d3e36e6b2c5e4f31a56819 Mon Sep 17 00:00:00 2001
From: Guillermo Garza <ggarza23@gmail.com>
Date: Fri, 21 Mar 2014 14:45:13 -0500
Subject: Change lang declaration back to ruby from julia

---
 es-es/julia-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 4b79674d..7303bb40 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -15,7 +15,7 @@ Python.
 Esto se basa en la versión de desarrollo actual de Julia, del 18 de octubre de
 2013.
 
-```julia
+```ruby
 
 # Comentarios de una línea comienzan con una almohadilla (o signo gato)
 
-- 
cgit v1.2.3


From 764f5967da3d0b8ca0c0af2183abc1a05c6973f6 Mon Sep 17 00:00:00 2001
From: Guillermo Garza <ggarza23@gmail.com>
Date: Wed, 2 Apr 2014 22:41:12 -0500
Subject: More fixes to Spanish Julia.

---
 es-es/julia-es.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'es-es')

diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 7303bb40..41a7c68b 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -158,7 +158,7 @@ b[end] # => 6
 # separados por punto y coma.
 matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
 
-# Añadir cosas al final de una lista con push! y append!
+# Añadir cosas a la final de una lista con push! y append!
 push!(a,1)     # => [1]
 push!(a,2)     # => [1,2]
 push!(a,4)     # => [1,2,4]
@@ -214,7 +214,7 @@ splice!(arr,2) # => 4 ; arr es ahora [3,5]
 b = [1,2,3]
 append!(a,b) # ahroa a es [1, 2, 3, 4, 5, 1, 2, 3]
 
-# Comprobamos la existencia en una lista con in
+# Comprueba la existencia en una lista con in
 in(1, a) # => true
 
 # Examina la longitud con length
-- 
cgit v1.2.3


From 7487e48d0357b7b383ae999d1b01e426dd6d6959 Mon Sep 17 00:00:00 2001
From: hirohope <hiro.hope@gmail.com>
Date: Sun, 18 May 2014 22:58:35 -0400
Subject: typo fixes and version in docs

---
 es-es/python-es.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'es-es')

diff --git a/es-es/python-es.html.markdown b/es-es/python-es.html.markdown
index f92f5cde..f7a0ec02 100644
--- a/es-es/python-es.html.markdown
+++ b/es-es/python-es.html.markdown
@@ -130,7 +130,7 @@ otra_variable  # Levanta un error de nombre
 # 'if' puede ser usado como una expresión
 "yahoo!" if 3 > 2 else 2 #=> "yahoo!"
 
-# Listas sobre secuencias
+# Listas almacenan secuencias
 lista = []
 # Puedes empezar con una lista prellenada
 otra_lista = [4, 5, 6]
@@ -254,7 +254,7 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
 # Haz diferencia de conjuntos con -
 {1,2,3,4} - {2,3,5} #=> {1, 4}
 
-# CHequea la existencia en un conjunto con 'in'
+# Chequea la existencia en un conjunto con 'in'
 2 in conjunto_lleno #=> True
 10 in conjunto_lleno #=> False
 
-- 
cgit v1.2.3


From 6b915b73938dd5db5922173239f9bfd08ab76709 Mon Sep 17 00:00:00 2001
From: hirohope <hiro.hope@gmail.com>
Date: Sun, 18 May 2014 22:59:05 -0400
Subject: added python3 in spanish

---
 es-es/python3-es.html.markdown | 570 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 570 insertions(+)
 create mode 100644 es-es/python3-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/python3-es.html.markdown b/es-es/python3-es.html.markdown
new file mode 100644
index 00000000..71c38670
--- /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.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)
+
-- 
cgit v1.2.3


From 5f3a6c01b8b0890efaa3ba73a0a5a515bcbfdf52 Mon Sep 17 00:00:00 2001
From: hirohope <hiro.hope@gmail.com>
Date: Mon, 19 May 2014 09:21:17 -0400
Subject: fixed file name with es suffix

---
 es-es/python3-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/python3-es.html.markdown b/es-es/python3-es.html.markdown
index 71c38670..1c69481a 100644
--- a/es-es/python3-es.html.markdown
+++ b/es-es/python3-es.html.markdown
@@ -5,7 +5,7 @@ contributors:
 translators:
     - ["Camilo Garrido", "http://twitter.com/hirohope"]
 lang: es-es
-filename: learnpython3.py
+filename: learnpython3-es.py
 ---
 
 Python fue creado por Guido Van Rossum en el principio de los 90'. Ahora es uno
-- 
cgit v1.2.3


From c27993c85a9daec2b7152da9de5ee1593a3d3b64 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Wed, 23 Jul 2014 13:27:53 -0500
Subject: [json/es] Spanish translation for JSON

---
 es-es/json-es.html.markdown | 59 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 es-es/json-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/json-es.html.markdown b/es-es/json-es.html.markdown
new file mode 100644
index 00000000..c3294636
--- /dev/null
+++ b/es-es/json-es.html.markdown
@@ -0,0 +1,59 @@
+---
+language: json
+filename: learnjson.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."
+}
+```
-- 
cgit v1.2.3


From 29858f6845a5b1982b1ba746d0cad4d41240bfa4 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Wed, 23 Jul 2014 13:28:55 -0500
Subject: Update json-es.html.markdown

---
 es-es/json-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/json-es.html.markdown b/es-es/json-es.html.markdown
index c3294636..de52f76d 100644
--- a/es-es/json-es.html.markdown
+++ b/es-es/json-es.html.markdown
@@ -5,7 +5,7 @@ contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
 translators:
-  -["Daniel Zendejas","https://github.com/DanielZendejas"]
+  - ["Daniel Zendejas","https://github.com/DanielZendejas"]
 lang: es-es
 ---
 
-- 
cgit v1.2.3


From 19a5676798f2315778d07e9271fd5e9d750bb5ef Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Wed, 23 Jul 2014 19:07:48 -0500
Subject: Update json-es.html.markdown

---
 es-es/json-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/json-es.html.markdown b/es-es/json-es.html.markdown
index de52f76d..fff678eb 100644
--- a/es-es/json-es.html.markdown
+++ b/es-es/json-es.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: json
-filename: learnjson.json
+filename: learnjson-es.json
 contributors:
   - ["Anna Harren", "https://github.com/iirelu"]
   - ["Marco Scannadinari", "https://github.com/marcoms"]
-- 
cgit v1.2.3


From 2c511db07ac4cc4d4fa8f438a200d4fb98a80884 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Wed, 23 Jul 2014 20:19:10 -0500
Subject: Create markdown-es.html.markdown

---
 es-es/markdown-es.html.markdown | 234 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 234 insertions(+)
 create mode 100644 es-es/markdown-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/markdown-es.html.markdown b/es-es/markdown-es.html.markdown
new file mode 100644
index 00000000..c7d408b5
--- /dev/null
+++ b/es-es/markdown-es.html.markdown
@@ -0,0 +1,234 @@
+<!-- Markdown is a superset of HTML, so any HTML file is valid Markdown, that
+means we can use HTML elements in Markdown, such as the comment element, and
+they won't be affected by a markdown parser. However, if you create an HTML
+element in your markdown file, you cannot use markdown syntax within that
+element's contents. -->
+
+<!-- Markdown está basado en HTML, así que cualquier archivo HTML es Markdown
+válido, eso significa que 
+
+-->
+
+<!-- Markdown also varies in implementation from one parser to a next. This
+guide will attempt to clarify when features are universal or when they are
+specific to a certain parser. -->
+
+<!-- Headers -->
+<!-- You can create HTML elements <h1> through <h6> easily by prepending the
+text you want to be in that element by a number of hashes (#) -->
+# This is an <h1>
+## This is an <h2>
+### This is an <h3>
+#### This is an <h4>
+##### This is an <h5>
+###### This is an <h6>
+
+<!-- Markdown also provides us with two alternative ways of indicating h1 and h2 -->
+This is an h1
+=============
+
+This is an h2
+-------------
+
+<!-- Simple text styles -->
+<!-- Text can be easily styled as italic, bold, or strikethrough using markdown -->
+
+*This text is in italics.*
+_And so is this text._
+
+**This text is in bold.**
+__And so is this text.__
+
+***This text is in both.***
+**_As is this!_**
+*__And this!__*
+
+<!-- In Github Flavored Markdown, which is used to render markdown files on
+Github, we also have: -->
+
+~~This text is rendered with strikethrough.~~
+
+<!-- Paragraphs are a one or multiple adjacent lines of text separated by one or
+multiple blank lines. -->
+
+This is a paragraph. I'm typing in a paragraph isn't this fun?
+
+Now I'm in paragraph 2.
+I'm still in paragraph 2 too!
+
+
+I'm in paragraph three!
+
+<!-- Should you ever want to insert an HTML <br /> tag, you can end a paragraph
+with two or more spaces and then begin a new paragraph. -->
+
+I end with two spaces (highlight me to see them).  
+
+There's a <br /> above me!
+
+<!-- Block quotes are easy and done with the > character. -->
+
+> This is a block quote. You can either
+> manually wrap your lines and put a `>` before every line or you can let your lines get really long and wrap on their own.
+> It doesn't make a difference so long as they start with a `>`.
+
+> You can also use more than one level
+>> of indentation?
+> How neat is that?
+
+<!-- Lists -->
+<!-- Unordered lists can be made using asterisks, pluses, or hyphens -->
+
+* Item
+* Item
+* Another item
+
+or
+
++ Item
++ Item
++ One more item
+
+or 
+
+- Item
+- Item
+- One last item
+
+<!-- Ordered lists are done with a number followed by a period -->
+
+1. Item one
+2. Item two
+3. Item three
+
+<!-- You don't even have to label the items correctly and markdown will still
+render the numbers in order, but this may not be a good idea -->
+
+1. Item one
+1. Item two
+1. Item three
+<!-- (This renders the same as the above example) -->
+
+<!-- You can also use sublists -->
+
+1. Item one
+2. Item two
+3. Item three
+    * Sub-item
+    * Sub-item
+4. Item four
+
+<!-- Code blocks -->
+<!-- You can indicate a code block (which uses the <code> element) by indenting
+a line with four spaces or a tab -->
+
+    This is code
+    So is this
+
+<!-- You can also re-tab (or add an additional four spaces) for indentation
+inside your code -->
+
+    my_array.each do |item|
+        puts item
+    end
+
+<!-- Inline code can be created using the backtick character ` -->
+
+John didn't even know what the `go_to()` function did!
+
+<!-- In Github Flavored Markdown, you can use a special syntax for code -->
+
+\`\`\`ruby <!-- except remove those backslashes when you do this, just ```ruby ! -->
+def foobar
+    puts "Hello world!"
+end
+\`\`\` <!-- here too, no backslashes, just ``` -->
+
+<-- The above text doesn't require indenting, plus Github will use syntax
+highlighting of the language you specify after the ``` -->
+
+<!-- Horizontal rule (<hr />) -->
+<!-- Horizontal rules are easily added with three or more asterisks or hyphens,
+with or without spaces. -->
+
+***
+---
+- - - 
+****************
+
+<!-- Links -->
+<!-- One of the best things about markdown is how easy it is to make links. Put
+the text to display in hard brackets [] followed by the url in parentheses () -->
+
+[Click me!](http://test.com/)
+
+<!-- You can also add a link title using quotes inside the parentheses -->
+
+[Click me!](http://test.com/ "Link to Test.com")
+
+<!-- Relative paths work too. -->
+
+[Go to music](/music/).
+
+<!-- Markdown also supports reference style links -->
+
+[Click this link][link1] for more info about it!
+[Also check out this link][foobar] if you want to.
+
+
+
+
+<!-- The title can also be in single quotes or in parentheses, or omitted
+entirely. The references can be anywhere in your document and the reference IDs
+can be anything so long as they are unique. -->
+
+<!-- There is also "implicit naming" which lets you use the link text as the id -->
+
+[This][] is a link.
+
+
+
+<!-- But it's not that commonly used. -->
+
+<!-- Images -->
+<!-- Images are done the same way as links but with an exclamation point in front! -->
+
+![This is hover-text (alt text) for my image](http://imgur.com/myimage.jpg "An optional title")
+
+<!-- And reference style works as expected -->
+
+![This is the hover-text.][myimage]
+
+
+
+<!-- Miscellany -->
+<!-- Auto-links -->
+
+<http://testwebsite.com/> is equivalent to
+[http://testwebsite.com/](http://testwebsite.com/)
+
+<!-- Auto-links for emails -->
+
+<foo@bar.com>
+
+<!-- Escaping characters -->
+
+I want to type *this text surrounded by asterisks* but I don't want it to be
+in italics, so I do this: \*this text surrounded by asterisks\*.
+
+<!-- Tables -->
+<!-- Tables are only available in Github Flavored Markdown and are slightly
+cumbersome, but if you really want it: -->
+
+| Col1         | Col2     | Col3          |
+| :----------- | :------: | ------------: |
+| Left-aligned | Centered | Right-aligned |
+| blah         | blah     | blah          |
+
+<!-- or, for the same results -->
+
+Col 1 | Col2 | Col3
+:-- | :-: | --:
+Ugh this is so ugly | make it | stop
+
+<!-- The end! -->
-- 
cgit v1.2.3


From 4bf1ed2fedcb916b26f92a744d2a20c6bc9f6652 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Wed, 23 Jul 2014 21:48:35 -0500
Subject: Completed translation

---
 es-es/markdown-es.html.markdown | 255 ++++++++++++++++++++--------------------
 1 file changed, 126 insertions(+), 129 deletions(-)

(limited to 'es-es')

diff --git a/es-es/markdown-es.html.markdown b/es-es/markdown-es.html.markdown
index c7d408b5..ae7b201b 100644
--- a/es-es/markdown-es.html.markdown
+++ b/es-es/markdown-es.html.markdown
@@ -1,234 +1,231 @@
-<!-- Markdown is a superset of HTML, so any HTML file is valid Markdown, that
-means we can use HTML elements in Markdown, such as the comment element, and
-they won't be affected by a markdown parser. However, if you create an HTML
-element in your markdown file, you cannot use markdown syntax within that
-element's contents. -->
-
 <!-- Markdown está basado en HTML, así que cualquier archivo HTML es Markdown
-válido, eso significa que 
-
--->
+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. -->
 
-<!-- Markdown also varies in implementation from one parser to a next. This
-guide will attempt to clarify when features are universal or when they are
-specific to a certain parser. -->
+<!-- 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 -->
-<!-- You can create HTML elements <h1> through <h6> easily by prepending the
-text you want to be in that element by a number of hashes (#) -->
-# This is an <h1>
-## This is an <h2>
-### This is an <h3>
-#### This is an <h4>
-##### This is an <h5>
-###### This is an <h6>
-
-<!-- Markdown also provides us with two alternative ways of indicating h1 and h2 -->
-This is an h1
+<!-- 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
 =============
 
-This is an h2
+Esto es un h2
 -------------
 
-<!-- Simple text styles -->
-<!-- Text can be easily styled as italic, bold, or strikethrough using markdown -->
-
-*This text is in italics.*
-_And so is this text._
+<!-- Estilos para texto plano -->
+<!-- El texto puede ser fácilmente estilizaedo con italicas, negritas o tachado 
+usando markdown -->
 
-**This text is in bold.**
-__And so is this text.__
+*Este texto está en itálicas.*
+_Al igual que este texto._
 
-***This text is in both.***
-**_As is this!_**
-*__And this!__*
+**Este texto está en negritas.**
+__Al igual que este texto.__
 
-<!-- In Github Flavored Markdown, which is used to render markdown files on
-Github, we also have: -->
+***Este texto tiene ambos estilos.***
+**_Al igual que este!_**
+*__¡Y este!__*
 
-~~This text is rendered with strikethrough.~~
+<!-- En Github Flavored Markdown, el cual es usado para mostrar archivos 
+Markdown en Github, también tenemos: -->
 
-<!-- Paragraphs are a one or multiple adjacent lines of text separated by one or
-multiple blank lines. -->
+~~Este texto está tachado.~~
 
-This is a paragraph. I'm typing in a paragraph isn't this fun?
+<!-- Los párrafos son una o múltuples líneas de texto adyacentes separadas por 
+una o múltiples líneas en blanco-->
 
-Now I'm in paragraph 2.
-I'm still in paragraph 2 too!
+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!
 
-I'm in paragraph three!
+¡Estoy en el párrafo tres!
 
-<!-- Should you ever want to insert an HTML <br /> tag, you can end a paragraph
-with two or more spaces and then begin a new paragraph. -->
+<!-- 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-->
 
-I end with two spaces (highlight me to see them).  
+Termino con dos espacios (selecciona esta línea completa para que los veas).  
 
-There's a <br /> above me!
+¡Hay un <br /> arriba de mí!
 
-<!-- Block quotes are easy and done with the > character. -->
+<!-- Las citas de bloque son fáciles y se pueden hacer con el caracter >. -->
 
-> This is a block quote. You can either
-> manually wrap your lines and put a `>` before every line or you can let your lines get really long and wrap on their own.
-> It doesn't make a difference so long as they start with a `>`.
+> 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 `>`.
 
-> You can also use more than one level
->> of indentation?
-> How neat is that?
+> ¿También puedes usar más de un nivel
+>> de indentación?
+> Esto es muy útil ¿No?
 
-<!-- Lists -->
-<!-- Unordered lists can be made using asterisks, pluses, or hyphens -->
+<!-- Listas -->
+<!-- Las listas desordenadas se hacen usando asteriscos, símbolos de más,
+ o guiones -->
 
 * Item
 * Item
-* Another item
+* Otro item
 
-or
+o
 
 + Item
 + Item
-+ One more item
++ Un item más
 
-or 
+o
 
 - Item
 - Item
-- One last item
+- El último item
 
-<!-- Ordered lists are done with a number followed by a period -->
+<!-- Las listas ordenadas se logran con un número seguido de un punto -->
 
-1. Item one
-2. Item two
-3. Item three
+1. Item uno
+2. Item dos
+3. Item tres
 
-<!-- You don't even have to label the items correctly and markdown will still
-render the numbers in order, but this may not be a good idea -->
+<!-- Aunque Markdown mostrará los items correctamente en orden, esto no
+es una buena idea -->
 
-1. Item one
-1. Item two
-1. Item three
-<!-- (This renders the same as the above example) -->
+1. Item uno
+1. Item dos
+1. Item tres
+<!-- (Esto muestra lo mismo que el ejemplo de arriba) -->
 
-<!-- You can also use sublists -->
+<!-- También puedes usar sub-listas -->
 
-1. Item one
-2. Item two
-3. Item three
+1. Item uno
+2. Item dos
+3. Item tres
     * Sub-item
     * Sub-item
-4. Item four
+4. Item cuatro
 
-<!-- Code blocks -->
-<!-- You can indicate a code block (which uses the <code> element) by indenting
-a line with four spaces or a tab -->
+<!-- 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-->
 
-    This is code
-    So is this
+    Esto es código
+    Esto también
 
-<!-- You can also re-tab (or add an additional four spaces) for indentation
-inside your code -->
+<!-- También puedes insertar dos tabs (o cuatro espacios adicionales)
+para indentar dentro del código -->
 
     my_array.each do |item|
         puts item
     end
 
-<!-- Inline code can be created using the backtick character ` -->
+<!-- Código dentro de la línea puede ser escrito usando la comilla ` -->
 
-John didn't even know what the `go_to()` function did!
+¡John no sabía lo que la función `go_to()` hacía!
 
-<!-- In Github Flavored Markdown, you can use a special syntax for code -->
+<!-- Con Github Flavored Markdown, puedes usar una sintaxis especial para código -->
 
-\`\`\`ruby <!-- except remove those backslashes when you do this, just ```ruby ! -->
+\`\`\`ruby <!-- quita esas comillas cuando lo hagas, deja sólo ```ruby ! -->
 def foobar
     puts "Hello world!"
 end
-\`\`\` <!-- here too, no backslashes, just ``` -->
+\`\`\` <!-- aquí también, sin comillas, sólo ``` -->
 
-<-- The above text doesn't require indenting, plus Github will use syntax
-highlighting of the language you specify after the ``` -->
+<!-- El texto de arriba no necesita indentación, aparte Github usará
+resaltará la sintaxis del lenguaje que especifiques después de ``` -->
 
-<!-- Horizontal rule (<hr />) -->
-<!-- Horizontal rules are easily added with three or more asterisks or hyphens,
-with or without spaces. -->
+<!-- Regla horizontal (<hr />) -->
+<!-- Las reglas horizontales se agregan fácilmente con tres o más asteriscos o guiones,
+con o sin espacios. -->
 
 ***
 ---
 - - - 
 ****************
 
-<!-- Links -->
-<!-- One of the best things about markdown is how easy it is to make links. Put
-the text to display in hard brackets [] followed by the url in parentheses () -->
+<!-- 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 () -->
 
-[Click me!](http://test.com/)
+[¡Haz click!](http://test.com/)
 
-<!-- You can also add a link title using quotes inside the parentheses -->
+<!-- También puedes agregar el titulo de la liga usando comillas dentro de los paréntesis -->
 
-[Click me!](http://test.com/ "Link to Test.com")
+[¡Haz click!](http://test.com/ "Liga al test.com")
 
-<!-- Relative paths work too. -->
+<!-- También funcionan las rutas relativas. -->
 
-[Go to music](/music/).
+[Ir a la música](/music/).
 
-<!-- Markdown also supports reference style links -->
+<!-- Markdown también soporta ligas con estilo de referencia -->
 
-[Click this link][link1] for more info about it!
-[Also check out this link][foobar] if you want to.
+¡[Has click a esta liga][liga1] para más información!
+[También mira esta liag][foobar] si quieres.
 
 
 
 
-<!-- The title can also be in single quotes or in parentheses, or omitted
-entirely. The references can be anywhere in your document and the reference IDs
-can be anything so long as they are unique. -->
+<!-- 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. -->
 
-<!-- There is also "implicit naming" which lets you use the link text as the id -->
+<!-- También hay "nombramiento implicito" el cual te permite usar el texto de la liga como id -->
 
-[This][] is a link.
+[Esta][] es una liga.
 
 
 
-<!-- But it's not that commonly used. -->
+<!-- Pero no se usa comúnmente. -->
 
-<!-- Images -->
-<!-- Images are done the same way as links but with an exclamation point in front! -->
+<!-- Imagenes -->
+<!-- Las imagenes se hacen de la misma forma que las ligas pero con un símbolo de exclamaciónal frente! -->
 
-![This is hover-text (alt text) for my image](http://imgur.com/myimage.jpg "An optional title")
+![Esta es una etiqueta (texto alternativo) para mi imagen](http://imgur.com/myimage.jpg "Un titulo opcional")
 
-<!-- And reference style works as expected -->
+<!-- Y el estilo de referencia funciona como se espera -->
 
-![This is the hover-text.][myimage]
+![Esta es una etiqueta.][myimage]
 
 
 
-<!-- Miscellany -->
-<!-- Auto-links -->
+<!-- Misceláneos -->
+<!-- Auto-ligas -->
 
-<http://testwebsite.com/> is equivalent to
+<http://testwebsite.com/> equivale a
 [http://testwebsite.com/](http://testwebsite.com/)
 
-<!-- Auto-links for emails -->
+<!-- Auto-ligas para correos electrónicos -->
 
 <foo@bar.com>
 
-<!-- Escaping characters -->
+<!-- Escapando caracteres -->
 
-I want to type *this text surrounded by asterisks* but I don't want it to be
-in italics, so I do this: \*this text surrounded by asterisks\*.
+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\*.
 
-<!-- Tables -->
-<!-- Tables are only available in Github Flavored Markdown and are slightly
-cumbersome, but if you really want it: -->
+<!-- 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          |
 | :----------- | :------: | ------------: |
-| Left-aligned | Centered | Right-aligned |
+| Izquierda | Centrado | Derecha |
 | blah         | blah     | blah          |
 
-<!-- or, for the same results -->
+<!-- o, para los mismos resultados -->
 
 Col 1 | Col2 | Col3
 :-- | :-: | --:
-Ugh this is so ugly | make it | stop
+Ugh esto es feo | has que | pare.
 
-<!-- The end! -->
+<!-- ¡El fin! -->
-- 
cgit v1.2.3


From a5ca7174262e9fe73d4f9ed9aafafab4c9ae91a9 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Wed, 23 Jul 2014 21:51:26 -0500
Subject: Added translation and format

---
 es-es/markdown-es.html.markdown | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

(limited to 'es-es')

diff --git a/es-es/markdown-es.html.markdown b/es-es/markdown-es.html.markdown
index ae7b201b..fd901cf4 100644
--- a/es-es/markdown-es.html.markdown
+++ b/es-es/markdown-es.html.markdown
@@ -1,3 +1,18 @@
+---
+language: markdown
+contributors:
+    - ["Dan Turkel", "http://danturkel.com/"]
+translators:
+    - ["Daniel Zendejas", "https://github.com/DanielZendejas"]
+-filename: es-markdown.md
+---
+
+Markdown was created by John Gruber in 2004. It's meant to be an easy to read and write syntax which converts easily to HTML (and now many other formats as well).
+
+Give me as much feedback as you want! / Feel free to fork and pull request!
+
+
+```
 <!-- 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 
@@ -229,3 +244,7 @@ Col 1 | Col2 | Col3
 Ugh esto es feo | has que | pare.
 
 <!-- ¡El fin! -->
+
+```
+
+For more info, check out John Gruber's official post of syntax [here](http://daringfireball.net/projects/markdown/syntax) and Adam Pritchard's great cheatsheet [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
-- 
cgit v1.2.3


From 248ab5a182718be2c63a0b83f7e55ce42afe349c Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Wed, 23 Jul 2014 21:52:43 -0500
Subject: Added lang

---
 es-es/markdown-es.html.markdown | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/markdown-es.html.markdown b/es-es/markdown-es.html.markdown
index fd901cf4..1ffe148e 100644
--- a/es-es/markdown-es.html.markdown
+++ b/es-es/markdown-es.html.markdown
@@ -1,10 +1,11 @@
 ---
 language: markdown
+filename: markdown-es.md
 contributors:
     - ["Dan Turkel", "http://danturkel.com/"]
 translators:
     - ["Daniel Zendejas", "https://github.com/DanielZendejas"]
--filename: es-markdown.md
+lang: es-es
 ---
 
 Markdown was created by John Gruber in 2004. It's meant to be an easy to read and write syntax which converts easily to HTML (and now many other formats as well).
-- 
cgit v1.2.3


From 49c2fb948dd77413fe3cedc961ad4ed428b6c9ef Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Wed, 23 Jul 2014 21:56:21 -0500
Subject: Update markdown-es.html.markdown

---
 es-es/markdown-es.html.markdown | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

(limited to 'es-es')

diff --git a/es-es/markdown-es.html.markdown b/es-es/markdown-es.html.markdown
index 1ffe148e..228e0a18 100644
--- a/es-es/markdown-es.html.markdown
+++ b/es-es/markdown-es.html.markdown
@@ -10,7 +10,10 @@ lang: es-es
 
 Markdown was created by John Gruber in 2004. It's meant to be an easy to read and write syntax which converts easily to HTML (and now many other formats as well).
 
-Give me as much feedback as you want! / Feel free to fork and pull request!
+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!
 
 
 ```
@@ -248,4 +251,4 @@ Ugh esto es feo | has que | pare.
 
 ```
 
-For more info, check out John Gruber's official post of syntax [here](http://daringfireball.net/projects/markdown/syntax) and Adam Pritchard's great cheatsheet [here](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet).
+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).
-- 
cgit v1.2.3


From 41406fdce69c5a7dece0938f522a3c3a8b5c6c6f Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Wed, 23 Jul 2014 21:56:46 -0500
Subject: finalizado

---
 es-es/markdown-es.html.markdown | 2 --
 1 file changed, 2 deletions(-)

(limited to 'es-es')

diff --git a/es-es/markdown-es.html.markdown b/es-es/markdown-es.html.markdown
index 228e0a18..3865126c 100644
--- a/es-es/markdown-es.html.markdown
+++ b/es-es/markdown-es.html.markdown
@@ -8,8 +8,6 @@ translators:
 lang: es-es
 ---
 
-Markdown was created by John Gruber in 2004. It's meant to be an easy to read and write syntax which converts easily to HTML (and now many other formats as well).
-
 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).
 
-- 
cgit v1.2.3


From 540dd89202d03735ee1bff8b4f2806030a5541ca Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Fri, 25 Jul 2014 11:04:49 -0500
Subject: [css/es] created

---
 es-es/css-es.html.markdown | 243 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 243 insertions(+)
 create mode 100644 es-es/css-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/css-es.html.markdown b/es-es/css-es.html.markdown
new file mode 100644
index 00000000..2ac192c5
--- /dev/null
+++ b/es-es/css-es.html.markdown
@@ -0,0 +1,243 @@
+---
+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"]
+---
+
+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 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/). El principal enfoque de este artículo es 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...*/ }
+
+/* El selector es usado para apuntar a un elemento en la página.
+
+¡Puedes apuntar a todos los elementos en la página! */
+* { color:red; }
+
+/*
+Dado un elemento como este en la página:
+
+<div class='una-clase clase2' id='unaId' attr='valor' />
+*/
+
+/* puedes seleccionarlo 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; }
+
+/*y, más importante, puedes combinar estos criterios de búsqueda entre sí.
+No debe existir ningún espacio entre estas partes porque hace que tenga otro
+significado.*/
+div.una-clase[attr$='or'] { }
+
+/* También puedes seleccionar un elemento HTML basado 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 padres en un árbol*/
+/* Lo siguiente básicamente significa que cualquier elemento que tenga una clase
+"nombre-clase" y es 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)
+
-- 
cgit v1.2.3


From de1d175eb69a6f8239ab9078eb8915a25a35c691 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Fri, 25 Jul 2014 11:05:49 -0500
Subject: Added lang:es-es

---
 es-es/css-es.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'es-es')

diff --git a/es-es/css-es.html.markdown b/es-es/css-es.html.markdown
index 2ac192c5..e298af91 100644
--- a/es-es/css-es.html.markdown
+++ b/es-es/css-es.html.markdown
@@ -6,6 +6,7 @@ contributors:
     - ["Marco Scannadinari", "https://github.com/marcoms"]
 translators:
     - ["Daniel Zendejas","https://github.com/DanielZendejas"]
+lang: es-es
 ---
 
 Tutorial de CSS en español
-- 
cgit v1.2.3


From e2a19c0969eb97990fb90f8ca18382bbd8e8c040 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Fri, 25 Jul 2014 11:29:05 -0500
Subject: Little orthography fixes.

---
 es-es/css-es.html.markdown | 31 +++++++++++++++----------------
 1 file changed, 15 insertions(+), 16 deletions(-)

(limited to 'es-es')

diff --git a/es-es/css-es.html.markdown b/es-es/css-es.html.markdown
index e298af91..1450b12e 100644
--- a/es-es/css-es.html.markdown
+++ b/es-es/css-es.html.markdown
@@ -6,7 +6,6 @@ contributors:
     - ["Marco Scannadinari", "https://github.com/marcoms"]
 translators:
     - ["Daniel Zendejas","https://github.com/DanielZendejas"]
-lang: es-es
 ---
 
 Tutorial de CSS en español
@@ -20,12 +19,12 @@ CSS es el lenguaje estándar que existe para separar el contenido
 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 más reciente pero sí la más soportada y compatible.
+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/). El principal enfoque de este artículo es en
+[dabblet](http://dabblet.com/). Este artículo se enfoca, principalmente, en
 la sintaxis y consejos generales.
 
 ```css
@@ -35,12 +34,12 @@ la sintaxis y consejos generales.
    ## SELECTORES
    ####################*/
 
-/* Generalmente, la sentencia principal en CSS es muy simple */
-selector { propiedad: valor; /* más propiedades...*/ }
+/* 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 un elemento en la página.
+/* El selector es usado para apuntar a (seleccionar) un elemento en la página.
 
-¡Puedes apuntar a todos los elementos en la página! */
+¡Puedes apuntar a todos los elementos en la página con el asterisco! */
 * { color:red; }
 
 /*
@@ -49,7 +48,7 @@ Dado un elemento como este en la página:
 <div class='una-clase clase2' id='unaId' attr='valor' />
 */
 
-/* puedes seleccionarlo por el nombre de su clase */
+/* puedes seleccionar el <div> por el nombre de su clase */
 .una-clase { }
 
 /*¡O por sus dos clases! */
@@ -76,21 +75,21 @@ div { }
 /* O incluso contiene un valor ('lo' en este caso) */
 [attr~='lo'] { font-size:smaller; }
 
-/*y, más importante, puedes combinar estos criterios de búsqueda entre sí.
-No debe existir ningún espacio entre estas partes porque hace que tenga otro
-significado.*/
+/*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 basado en sus padres*/
+/* 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 padres en un árbol*/
-/* Lo siguiente básicamente significa que cualquier elemento que tenga una clase
-"nombre-clase" y es hijo de un div con clase "un-padre" EN CUALQUIER PROFUNDIDAD*/
+/* 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
-- 
cgit v1.2.3


From e1440b1678b8af250531f9464e00988a28aae5df Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Fri, 25 Jul 2014 16:36:18 -0500
Subject: Added lang:es-es

---
 es-es/css-es.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'es-es')

diff --git a/es-es/css-es.html.markdown b/es-es/css-es.html.markdown
index 1450b12e..31000785 100644
--- a/es-es/css-es.html.markdown
+++ b/es-es/css-es.html.markdown
@@ -6,6 +6,7 @@ contributors:
     - ["Marco Scannadinari", "https://github.com/marcoms"]
 translators:
     - ["Daniel Zendejas","https://github.com/DanielZendejas"]
+lang: es-es
 ---
 
 Tutorial de CSS en español
-- 
cgit v1.2.3


From 2b1762fdd86e17b99581f17df47ab9fee8233108 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Mon, 28 Jul 2014 11:48:25 -0500
Subject: Create livescript-es.html.markdown

---
 es-es/livescript-es.html.markdown | 338 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 338 insertions(+)
 create mode 100644 es-es/livescript-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/livescript-es.html.markdown b/es-es/livescript-es.html.markdown
new file mode 100644
index 00000000..538c0a2a
--- /dev/null
+++ b/es-es/livescript-es.html.markdown
@@ -0,0 +1,338 @@
+---
+language: LiveScript
+filename: learnLivescript-es.ls
+contributors:
+    - ["Christina Whyte", "http://github.com/kurisuwhyte/"]
+translators:
+    - ["Daniel Zendejas", "http://github.com/DanielZendejas/"]
+---
+
+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.
-- 
cgit v1.2.3


From ac8b79daf422ad71d3cda34e9dd7810530c1d620 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Mon, 28 Jul 2014 12:16:02 -0500
Subject: Added lang:es-es

---
 es-es/livescript-es.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'es-es')

diff --git a/es-es/livescript-es.html.markdown b/es-es/livescript-es.html.markdown
index 538c0a2a..103a3142 100644
--- a/es-es/livescript-es.html.markdown
+++ b/es-es/livescript-es.html.markdown
@@ -5,6 +5,7 @@ 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
-- 
cgit v1.2.3


From 739ab0c7cfc741849910f76b3230792db084092e Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Tue, 29 Jul 2014 11:05:24 -0500
Subject: [javascript/es] created

---
 es-es/javascript-es.html.markdown | 530 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 530 insertions(+)
 create mode 100644 es-es/javascript-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
new file mode 100644
index 00000000..6f7f7c7f
--- /dev/null
+++ b/es-es/javascript-es.html.markdown
@@ -0,0 +1,530 @@
+---
+language: javascript
+contributors:
+    - ["Adam Brenecki", "http://adam.brenecki.id.au"]
+    - ["Ariel Krakowski", "http://www.learneroo.com"]
+translators:
+	-["Daniel Zendejas","https://github.com/DanielZendejas"]
+filename: javascript-es.js
+lang: es-es
+---
+Tutorial de JavaScript en español.
+
+JavaScript fue creado por Brendan Eich en 1995 mientras trabajaba en Netscape. 
+Su intención original era crear un lenguaje simple para sitios web, complementándolo
+con Java para aplicaciones más complejas. Debido a su integracion estrecha con sitios
+web y soporte por defecto de los navegadores modernos se ha vuelto mucho más común 
+para front-end que Java.
+
+JavaScript no sólo se limita a los navegadores web:
+* Node.js: Un proyecto que provee con un ambiente para el motor V8 de Google Chrome.
+
+¡La retroalimentación es bienvenida! Puedes encontrarme en: 
+[@adambrenecki](https://twitter.com/adambrenecki), o
+[adam@brenecki.id.au](mailto:adam@brenecki.id.au).
+
+```js
+// Los comentarios son como en C. Los comentarios de una sola línea comienzan con //,
+/* y los comentarios multilínea comienzan
+   y terminan con */
+
+// Cada sentencia puede ser terminada con punto y coma ;
+hazAlgo();
+
+// ... aunque no es necesario, ya que el punto y coma se agrega automaticamente
+// cada que se detecta una nueva línea, a excepción de algunos casos.
+hazAlgo()
+
+// Dado que esta práctica puede llevar a resultados inesperados, seguiremos agregando
+// punto y coma en esta guía.
+
+///////////////////////////////////
+// 1. Números, Strings y Operadores
+
+// JavaScript tiene un solo tipo de número (doble de 64-bit IEEE 754).
+// Así como con Lua, no te espantes por la falta de enteros: los dobles tienen 52 bits
+// de mantisa, lo cual es suficiente para guardar enteros de hasta 9✕10¹�.
+3; // = 3
+1.5; // = 1.5
+
+// Toda la aritmética básica funciona como uno esperaría.
+1 + 1; // = 2
+8 - 1; // = 7
+10 * 2; // = 20
+35 / 5; // = 7
+
+// Incluyendo divisiones con resultados no enteros.
+5 / 2; // = 2.5
+
+// Las operaciones con bits también funcionan; cuando ejecutas una operación con bits
+// el número flotante se convierte a entero con signo *hasta* 32 bits.
+1 << 2; // = 4
+
+// La jerarquía de las operaciones se aplica con paréntesis.
+(1 + 3) * 2; // = 8
+
+// Hay tres casos especiales de valores con los números:
+Infinity; // por ejemplo: 1/0
+-Infinity; // por ejemplo: -1/0
+NaN; // por ejemplo: 0/0
+
+// También hay booleanos:
+true;
+false;
+
+// Los Strings se pueden crear con ' o ".
+'abc';
+"Hola, mundo";
+
+// La negación se aplica con la expresión ! 
+!true; // = false
+!false; // = true
+
+// Para comprobar una igualdad se usa ==
+1 == 1; // = true
+2 == 1; // = false
+
+// Para comprobar una desigualdad se usa !=
+1 != 1; // = false
+2 != 1; // = true
+
+// Más comparaciones
+1 < 10; // = true
+1 > 10; // = false
+2 <= 2; // = true
+2 >= 2; // = true
+
+// Los Strings se concatenan con +
+"¡Hola " + "mundo!"; // = "¡Hola mundo!"
+
+// y se comparan con < y con >
+"a" < "b"; // = true
+
+// Los tipos no importan con el operador ==...
+"5" == 5; // = true
+
+// ...a menos que uses ===
+"5" === 5; // = false
+
+// Los Strings funcionan como arreglos de caracteres
+// Puedes accesar a cada caracter con la función charAt()
+"Este es un String".charAt(0);  // = 'E'
+
+// ...o puedes usar la función substring() para acceder a pedazos más grandes
+"Hola Mundo".substring(0, 4); // = "Hola"
+
+// length es una propiedad, así que no uses ()
+"Hola".length; // = 4
+
+// También hay null y undefined
+null; // usado para indicar una falta de valor deliberada
+undefined; // usado para indicar que un valor no está presente actualmente
+           // (aunque undefined es un valor en sí mismo)
+
+// false, null, undefined, NaN, 0 y "" es false; todo lo demás es true.
+// Note que 0 is false y "0" es true, a pesar de que 0 == "0".
+// Aunque 0 === "0" sí es false.
+
+///////////////////////////////////
+// 2. Variables, Arreglos y Objetos
+
+// Las variables se declaran con la palabra var. JavaScript cuenta con tipado dinámico,
+// así que no se necesitan aplicar tipos. La asignación se logra con el operador =.
+var miPrimeraVariable = 5;
+
+// si no escribes la palabra var no se marcará ningún error...
+miSegundaVariable = 10;
+
+// ...pero tu variable se declarará en el ámbito global, no en el ámbito
+// en el que se definió.
+
+// Las variables que no están aún asignadas tienen el valor undefined.
+var miTerceraVariable; // = undefined
+
+// Existen atajos para realizar operaciones aritméticas:
+miPrimeraVariable += 5; // equivalente a miPrimeraVariable = miPrimeraVariable + 5;
+						// miPrimeraVariable ahora es 10
+miPrimeraVariable *= 10; // ahora miPrimeraVariable es 100
+
+// Y atajos aún más cortos para sumar y restar 1
+miPrimeraVariable++; // ahora miPrimeraVariable es 101
+miPrimeraVariable--; // de vuelta a 100
+
+// Los arreglos son listas ordenadas de valores, de cualquier tipo.
+var miArreglo = ["Hola", 45, true];
+
+// Los miembros de un arreglo pueden ser accesados con la sintaxis 
+// de indices dentro de corchetes [].
+// Los índices empiezan en cero.
+miArreglo[1]; // = 45
+
+// Los arreglos son mutables y pueden cambiar de longitud.
+miArreglo.push("Mundo");
+miArreglo.length; // = 4
+
+// Agregar/Modificar en un determinado índice
+miArreglo[3] = "Hola";
+
+// Los objetos en JavaScript son equivalentes a los 'diccionarios' o 'mapas' en otros
+// lenguajes: una colección de pares llave/valor desordenada.
+var miObjeto = {llave1: "Hola", llave2: "Mundo"};
+
+// Las llaves son strings, pero no se necesitan las comillas si son un identificador
+// válido de JavaScript. Los valores pueden ser de cualquier tipo.
+var miObjeto = {miLlave: "miValor", "mi otra llave": 4};
+
+// Los atributos de los objetos también pueden ser accesadas usando
+//  la sintaxis de corchetes,
+miObjeto["mi otra llave"]; // = 4
+
+// ... o usando la sintaxis de punto, dado que la llave es un identificador válido.
+miObjeto.miLlave; // = "miValor"
+
+// Los objetos son mutables; los valores pueden ser cambiados y se pueden
+// agregar nuevas llaves.
+miObjeto.miTerceraLlave = true;
+
+// Si intentas accesar con una llave que aún no está asignada tendrás undefined.
+miObjeto.miCuartaLlave; // = undefined
+
+///////////////////////////////////
+// 3. Lógica y estructura de control
+
+// La sintaxis de esta sección es casi idéntica a la de Java. 
+
+// La estructura if funciona de la misma forma.
+var contador = 1;
+if (contador == 3){
+    // evaluar si contador es igual a 3
+} else if (contador == 4){
+    // evaluar si contador es igual a 4
+} else {
+    // evaluar si contador no es igual a 3 ni a 4
+}
+
+// De la misma forma la estructura while.
+while (true){
+    // ¡Loop infinito!
+}
+
+// La estructura Do-while es igual al while, excepto que se ejecuta al menos una vez.
+var input
+do {
+    input = conseguirInput();
+} while (!esValido(input))
+
+// la esctructura for es la misma que la de C y Java:
+// inicialización; condición; iteración.
+for (var i = 0; i < 5; i++){
+    // correrá cinco veces
+}
+
+// && es un "y" lógico, || es un "o" lógico
+var casa = {tamano:"grande",casa:"color"};
+if (casa.tamano == "grande" && casa.color == "azul"){
+    casa.contiene = "oso";
+}
+if (color == "rojo" || color == "azul"){
+    // el color es rojo o azul
+}
+
+// && y || "corto circuito", lo cual es útil para establecer valores por defecto.
+var nombre = otroNombre || "default";
+
+
+// la estructura switch usa === para sus comparaciones
+// usa 'break' para terminar cada caso 
+// o los casos después del caso correcto serán ejecutados también. 
+calificacion = 'B';
+switch (calificacion) {
+  case 'A':
+    console.log("Excelente trabajo");
+    break;
+  case 'B':
+    console.log("Buen trabajo");
+    break;
+  case 'C':
+    console.log("Puedes hacerlo mejor");
+    break;
+  default:
+    console.log("Muy mal");
+    break;
+}
+
+
+///////////////////////////////////
+// 4. Funciones, ámbitos y closures
+
+// Las funciones en JavaScript son declaradas con la palabra clave "function".
+function miFuncion(miArgumentoString){
+    return miArgumentoString.toUpperCase(); //la funcion toUpperCase() vuelve todo
+    // el String a mayúsculas
+}
+miFuncion("foo"); // = "FOO"
+
+// Note que el valor a ser regresado debe estar en la misma línea que la
+// palabra clave 'return', de otra forma la función siempre regresará 'undefined' 
+// debido a la inserción automática de punto y coma.
+function miFuncion()
+{
+    return // <- punto y coma insertado aquí automáticamente
+    {
+        estaEsUna: 'propiedad'
+    }
+}
+miFuncion(); // = undefined al mandar a llamar la función
+
+// Las funciones en JavaScript son de primera clase, así que pueden ser asignadas
+// a variables y pasadas a otras funciones como argumentos - por ejemplo:
+function miFuncion(){
+    // este código será llamado cada cinco segundos
+}
+setTimeout(miFuncion, 5000);
+// Note: setTimeout no es parte de JS, pero lo puedes obtener de los browsers
+// y Node.js.
+
+// Es posible declarar funciones sin nombre - se llaman funciones anónimas
+// y se definen como argumentos de otras funciones.
+setTimeout(function(){
+    // este código se ejecuta cada cinco segundos
+}, 5000);
+
+// JavaScript tiene ámbitos de funciones; las funciones tienen su propio ámbito pero
+// otros bloques no.
+if (true){
+    var i = 5;
+}
+i; // = 5 - en un lenguaje que da ámbitos por bloque esto sería undefined, pero no aquí.
+
+// Este conlleva a un patrón de diseño común llamado "ejecutar funciones anónimas 
+//inmediatamente", que preveé variables temporales de fugarse al ámbito global
+(function(){
+    var temporal = 5;
+    // Podemos accesar al ámbito global asignando al 'objeto global', el cual
+    // en un navegador siempre es 'window'. El objeto global puede tener
+    // un nombre diferente en ambientes distintos, por ejemplo Node.js .
+    window.permanente = 10;
+})();
+temporal; // da ReferenceError
+permanente; // = 10
+
+// Una de las características más útiles de JavaScript son los closures.
+// Si una función es definida dentro de otra función, la función interna tiene acceso
+// a todas las variables de la función externa, incluso aunque la función 
+// externa ya haya terminado.
+function decirHolaCadaCincoSegundos(nombre){
+    var texto = "¡Hola, " + nombre + "!";
+    // Las funciones internas son puestas en el ámbito local por defecto
+    // como si fueran declaradas con 'var'.
+    function interna(){
+        alert(texto);
+    }
+    setTimeout(interna, 5000);
+    // setTimeout es asíncrono, así que la funcion decirHolaCadaCincoSegundos 
+    // terminará inmediatamente, y setTimeout llamará a interna() a los cinco segundos
+    // Como interna está "cerrada dentro de" decirHolaCadaCindoSegundos, interna todavía tiene
+    // acceso a la variable 'texto' cuando es llamada.
+}
+decirHolaCadaCincoSegundos("Adam"); // mostrará una alerta con "¡Hola, Adam!" en 5s
+
+///////////////////////////////////
+// 5. Más sobre objetos; constructores y prototipos
+
+// Los objetos pueden contener funciones.
+var miObjeto = {
+    miFuncion: function(){
+        return "¡Hola Mundo!";
+    }
+};
+miObjeto.miFuncion(); // = "¡Hola Mundo!"
+
+// Cuando las funciones de un objeto son llamadas, pueden accesar a las variables 
+// del objeto con la palabra clave 'this'.
+miObjeto = {
+    miString: "¡Hola Mundo!",
+    miFuncion: function(){
+        return this.miString;
+    }
+};
+miObjeto.miFuncion(); // = "¡Hola Mundo!"
+
+// Las funciones de un objeto deben ser llamadas dentro del contexto de ese objeto.
+var miFuncion = myObj.miFuncion;
+miFuncion(); // = undefined
+
+// Una función puede ser asignada al objeto y ganar acceso a él gracias a esto,
+// incluso si no estaba dentro del objeto cuando este se definió.
+var miOtraFuncion = function(){
+    return this.miString.toUpperCase();
+}
+miObjeto.miOtraFuncion = myOtherFunc;
+miObjeto.miOtraFuncion(); // = "¡HOLA MUNDO!"
+
+// Podemos especificar el contexto en el que una función será llamada con los comandos
+// 'call' o 'apply'.
+
+var otraFuncion = function(otroString){
+    return this.miString + otroString;
+}
+otraFuncion.call(miObjeto, " y hola Luna!"); // = "¡Hola Mundo! y hola Luna!"
+
+// 'apply' es casi idéntico, pero recibe un arreglo como argumento.
+
+otraFuncion.apply(miObjeto, [" y hola Sol!"]); // = "¡Hola Mundo! y hola Sol!"
+
+// Esto es útil cuando estás trabajando con una función que acepta una secuencia de 
+// argumentos y quieres pasar un arreglo.
+
+Math.min(42, 6, 27); // = 6
+Math.min([42, 6, 27]); // = NaN (uh-oh!)
+Math.min.apply(Math, [42, 6, 27]); // = 6
+
+// Pero 'call' y 'apply' sólo son temporales. Cuando queremos que se quede, usamos bind.
+
+var funcionUnida = otraFuncion.bind(miObjeto);
+funcionUnida(" y hola Saturno!"); // = "¡Hola Mundo! y hola Saturno!"
+
+// Bind también puede ser usada para aplicar parcialmente (curry) una función.
+
+var producto = function(a, b){ return a * b; }
+var porDos = producto.bind(this, 2);
+porDos(8); // = 16
+
+// Cuando llamas a una función con la palabra clave 'new' un nuevo objeto es creado.
+// Se hace disponible a la función. Las funciones diseñadas para ser usadas así se
+// llaman constructores.
+
+var MiConstructor = function(){
+    this.miNumero = 5;
+}
+miNuevoObjeto = new MiConstructor(); // = {miNumero: 5}
+miNuevoObjeto.miNumero; // = 5
+
+// Todos los objetos JavaScript tienen un 'prototipo'. Cuando vas a accesar a una
+// propiedad en un objeto que no existe en el objeto el intérprete buscará en
+// el prototipo.
+
+// Algunas implementaciones de JavaScript te permiten accesar al prototipo de 
+// un objeto con la propiedad __proto__. Mientras que esto es útil para explicar
+// prototipos, no es parte del estándar; veremos formas estándar de usar prototipos
+// más adelante.
+
+var miObjeto = {
+    miString: "¡Hola Mundo!"
+};
+var miPrototipo = {
+    sentidoDeLaVida: 42,
+    miFuncion: function(){
+        return this.miString.toLowerCase()
+    }
+};
+
+miObjeto.__proto__ = miPrototipo;
+miObjeto.sentidoDeLaVida; // = 42
+
+// Esto funcionan también para funciones.
+miObjeto.miFuncion(); // = "hello world!"
+
+// Por supuesto, si la propiedad que buscas no está en el prototipo, 
+// se buscará en el prototipo del prototipo.
+miPrototipo.__proto__ = {
+    miBoolean: true
+};
+miObjeto.miBoolean; // = true
+
+// Esto no involucra ningún copiado, cada objeto guarda una referencia a su 
+// prototipo. Esto significa que podemos alterar el prototipo y nuestros
+// cambios serán reflejados en todos lados.
+miPrototipo.sentidoDeLaVida = 43;
+miObjeto.sentidoDeLaVida; // = 43
+
+// Mencionabamos anteriormente que __proto__ no está estandarizado, y que no 
+// existe una forma estándar de accesar al prototipo de un objeto. De todas formas.
+// hay dos formas de crear un nuevo objeto con un prototipo dado.
+
+// El primer método es Object.create, el cual es una adición reciente a JavaScript,
+// y por lo tanto, no disponible para todas las implementaciones aún.
+var miObjeto = Object.create(miPrototipo);
+miObjeto.sentidoDeLaVida; // = 43
+
+// El segundo método, el cual trabaja en todos lados, tiene que ver con los 
+// constructores. Los constructores tienen una propiedad llamada prototype.
+// Este NO ES el prototipo de la función constructor; es el prototipo que
+// se le da a los nuevos objetos cuando son creados con la palabra clave
+// new.
+
+MiConstructor.prototype = {
+    miNumero: 5,
+    getMiNumero: function(){
+        return this.miNumero;
+    }
+};
+var miNuevoObjeto2 = new MiConstructor();
+miNuevoObjeto2.getMiNumero(); // = 5
+miNuevoObjeto2.miNumero = 6
+miNuevoObjeto2.getMiNumero(); // = 6
+
+// Los tipos que vienen por defecto en JavaScript (como Strings y números)
+// también tienen constructores que crean objetos equivalentes.
+var miNumero = 12;
+var miNumeroObjeto = new Number(12);
+miNumero == miNumeroObjeto; // = true
+
+// No son exactamente iguales.
+typeof(miNumero); // = 'number'
+typeof(miNumeroObjeto); // = 'object'
+miNumero === miNumeroObjeyo; // = false
+if (0){
+    // Este código no se ejecutara porque 0 es false.
+}
+if (Number(0)){
+    // Este código sí se ejecutara, puesto que Number(0) es true.
+}
+
+// Aún así, los objetos que envuelven y los prototipos por defecto comparten
+// un prototipo. así que puedes agregar funcionalidades a un string de la 
+// siguiente forma:
+String.prototype.primerCaracter = function(){
+    return this.charAt(0);
+}
+"abc".primerCaracter(); // = "a"
+
+// Este hecho se usa normalmente en "polyfilling", lo cual es implementar
+// nuevas funciones a JavaScript en un JavaScript más viejo, así que pueda ser
+// compatible con ambintes más viejos de JavaScript (por ejemplo, navegadores viejos).
+
+// Por ejemplo, mencionabamos que Object.create no está aún disponible en todas
+// las implementaciones, pero podemos hacerlo con polyfill:
+if (Object.create === undefined){ // esta validación sirve para no sobreescribir
+    Object.create = function(proto){
+    	// hace un constructor temporal con el prototipo correcto
+        var Constructor = function(){};
+        Constructor.prototype = proto;
+        // y luego lo usamos para hacer un objeto con el prototipo
+        // correcto.
+        return new Constructor();
+    }
+}
+```
+
+## Fuentes y Referencias
+
+La [Red para Desarroladores de Mozilla](https://developer.mozilla.org/en-US/docs/Web/JavaScript) 
+proveé excelente documentación para JavaScript para navegadores. Además, está en formato de wiki,
+por lo que mientras vayas aprendiendo podrás ayudar a los demás con tu experiencia.
+
+MDN [Una re-introducción a JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript)
+cubre muchos de los conceptos que vimos aquí pero a mayor detalle. Esta guía cubre, más que nada, 
+el lenguaje JavaScript solo. Si quieres aprender a cómo usarlo en un ambiente web empieza aprendiendo
+sobre el [DOM](https://developer.mozilla.org/en-US/docs/Using_the_W3C_DOM_Level_1_Core)
+
+[Aprende JavaScript con ejemplos y retos](http://www.learneroo.com/modules/64/nodes/350) es una 
+variante de esta guía pero con retos.
+
+[Jardín JavaScript](http://bonsaiden.github.io/JavaScript-Garden/) es una guía para todas las
+funciones y características contra-intuitivas del lenguaje.
+
+[JavaScript: La guía definitiva](http://www.amazon.com/gp/product/0596805527/) es una guía clásica / libro de referencia. 
+
+Aparte de las contribuciones directas para este artículo, algo del contenido se adaptó
+del tutorial de Python por Louie Dinh en este sitio. y el [Tutorial JS](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) en la Red de Desarrolladores de Mozilla.
-- 
cgit v1.2.3


From 3a2d6d2f67f012af162231dc1bdab571f12a3add Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Tue, 29 Jul 2014 14:35:15 -0500
Subject: Markdown syntax error corrected

---
 es-es/javascript-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
index 6f7f7c7f..9b412f6e 100644
--- a/es-es/javascript-es.html.markdown
+++ b/es-es/javascript-es.html.markdown
@@ -4,7 +4,7 @@ contributors:
     - ["Adam Brenecki", "http://adam.brenecki.id.au"]
     - ["Ariel Krakowski", "http://www.learneroo.com"]
 translators:
-	-["Daniel Zendejas","https://github.com/DanielZendejas"]
+    - ["Daniel Zendejas","https://github.com/DanielZendejas"]
 filename: javascript-es.js
 lang: es-es
 ---
-- 
cgit v1.2.3


From fe228e44e61f09f570dbb91635c46bbae8d382a0 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Wed, 30 Jul 2014 10:33:33 -0500
Subject: [xml/es] created

---
 es-es/xml-es.html.markdown | 131 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 131 insertions(+)
 create mode 100644 es-es/xml-es.html.markdown

(limited to 'es-es')

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>
+```
-- 
cgit v1.2.3


From 9680347c90bfc36f44a95176eab153793d34d838 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Wed, 30 Jul 2014 12:09:18 -0500
Subject: [yaml/es] created

---
 es-es/yaml-es.html.markdown | 150 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 150 insertions(+)
 create mode 100644 es-es/yaml-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/yaml-es.html.markdown b/es-es/yaml-es.html.markdown
new file mode 100644
index 00000000..0423261a
--- /dev/null
+++ b/es-es/yaml-es.html.markdown
@@ -0,0 +1,150 @@
+---
+language: yaml
+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
+```
-- 
cgit v1.2.3


From e6df8f849a2572f809167743a45b8633c5e4580e Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Thu, 7 Aug 2014 16:52:47 -0500
Subject: [brainfuck/es] created

---
 es-es/brainfuck-es.html.markdown | 87 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 87 insertions(+)
 create mode 100644 es-es/brainfuck-es.html.markdown

(limited to 'es-es')

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.
-- 
cgit v1.2.3


From 7cf0bcb8283a0be92f77b40568355f02ac1811af Mon Sep 17 00:00:00 2001
From: m90 <frederik.ring@gmail.com>
Date: Sat, 9 Aug 2014 21:41:12 +0200
Subject: [javascript/*] typeof is an operand and not a function/method - fix
 usage / remove parens

---
 es-es/javascript-es.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'es-es')

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.
-- 
cgit v1.2.3


From 949215560586fb051b8ddf733c763cbbb67705c9 Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Mon, 11 Aug 2014 17:13:46 +0200
Subject: Update yaml-es.html.markdown

---
 es-es/yaml-es.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'es-es')

diff --git a/es-es/yaml-es.html.markdown b/es-es/yaml-es.html.markdown
index 0423261a..a5157b5d 100644
--- a/es-es/yaml-es.html.markdown
+++ b/es-es/yaml-es.html.markdown
@@ -1,5 +1,6 @@
 ---
 language: yaml
+lang: es-es
 filename: learnyaml-es.yaml
 contributors:
   - ["Adam Brenecki", "https://github.com/adambrenecki"]
-- 
cgit v1.2.3


From 6e9dc12151d9ed9eea98e1aa36a00861c330ec18 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Tue, 12 Aug 2014 20:27:40 -0500
Subject: [whip/es] created.

---
 es-es/whip-es.html.markdown | 255 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 255 insertions(+)
 create mode 100644 es-es/whip-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/whip-es.html.markdown b/es-es/whip-es.html.markdown
new file mode 100644
index 00000000..db929504
--- /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 [repo](http://github.com/L8D/whip)
-- 
cgit v1.2.3


From fbca22daeeb1cf81ed2de2e2a0b78d20a8dc06f9 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Tue, 12 Aug 2014 20:28:35 -0500
Subject: Sintax check

---
 es-es/whip-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/whip-es.html.markdown b/es-es/whip-es.html.markdown
index db929504..7c2f4bd2 100644
--- a/es-es/whip-es.html.markdown
+++ b/es-es/whip-es.html.markdown
@@ -252,4 +252,4 @@ undefined; usado para indicar un valor que aún no está definido.
 (succ 20) ; => 21
 ```
 
-Para más información, revisa [repo](http://github.com/L8D/whip)
+Para más información, revisa el [repositorio](http://github.com/L8D/whip)
-- 
cgit v1.2.3


From 17fe88764d8283f4d3676acde0b33c2680a15509 Mon Sep 17 00:00:00 2001
From: Daniel Zendejas <daniel8647@hotmail.com>
Date: Wed, 13 Aug 2014 09:12:50 -0500
Subject: [bash/es] created

---
 es-es/bash-es.html.markdown | 195 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 195 insertions(+)
 create mode 100644 es-es/bash-es.html.markdown

(limited to 'es-es')

diff --git a/es-es/bash-es.html.markdown b/es-es/bash-es.html.markdown
new file mode 100644
index 00000000..489fd39e
--- /dev/null
+++ b/es-es/bash-es.html.markdown
@@ -0,0 +1,195 @@
+---
+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
+---
+
+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
+```
-- 
cgit v1.2.3


From 4b5cbc91eb40d678c12d5bbb1d9fdbda9d22923d Mon Sep 17 00:00:00 2001
From: James Baxter <jebaxter@hotmail.co.uk>
Date: Tue, 19 Aug 2014 12:56:27 +0100
Subject: Fixed the statement that rune is an alias for uint32 in the
 translations

---
 es-es/go-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

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.
-- 
cgit v1.2.3


From 53696bd547736eafd3233e9626838610b696a1d3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Joaqu=C3=ADn=20Ferrero?= <explorer@joaquinferrero.com>
Date: Sun, 24 Aug 2014 22:42:11 +0200
Subject: Update perl-es.html.markdown

Typos, passive form eliminated
---
 es-es/perl-es.html.markdown | 106 ++++++++++++++++++++------------------------
 1 file changed, 49 insertions(+), 57 deletions(-)

(limited to 'es-es')

diff --git a/es-es/perl-es.html.markdown b/es-es/perl-es.html.markdown
index 4f0c26c1..fecaf5c4 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,7 +32,7 @@ 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:
@@ -39,91 +40,86 @@ 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:
-
+# 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.
-
+# 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)"
+    ...;
+}
+
+# Esto se ofrece como una versión más fácil de leer que "if (!condición)"
 
-# La post condición al modo Perl
+# 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++) {
-                  ...
-               }
+    ...;
+}
 
 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 +127,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`
-- 
cgit v1.2.3


From 5f15d684efd831a6b048f2d42ea66f2494728d7f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Joaqu=C3=ADn=20Ferrero?= <explorer@joaquinferrero.com>
Date: Sun, 24 Aug 2014 22:56:09 +0200
Subject: Update perl-es.html.markdown

Perl syntax errors.
---
 es-es/perl-es.html.markdown | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

(limited to 'es-es')

diff --git a/es-es/perl-es.html.markdown b/es-es/perl-es.html.markdown
index fecaf5c4..644182ff 100644
--- a/es-es/perl-es.html.markdown
+++ b/es-es/perl-es.html.markdown
@@ -36,19 +36,19 @@ my $respuesta = 42;
 
 ## 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"};
+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)
 
@@ -87,6 +87,10 @@ for ($i = 0; $i <= $max; $i++) {
     ...;
 }
 
+for $i (0 .. $max) {
+    ...;
+}
+
 foreach (@array) {
     print "Este elemento es $_\n";
 }
-- 
cgit v1.2.3


From eab554a7a7f2869ff7dac9f54acce9a7ed55cfa4 Mon Sep 17 00:00:00 2001
From: Adam <adam@adambard.com>
Date: Mon, 8 Sep 2014 13:08:28 +0200
Subject: Review docs for added rouge lexers and update those with new
 highlighters

---
 es-es/markdown-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to '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 
-- 
cgit v1.2.3


From e68f2b4da1eb766f7c21e4ae1f3185fb3dba5c3f Mon Sep 17 00:00:00 2001
From: Mienaikage <Mienaikage@gmail.com>
Date: Tue, 23 Sep 2014 17:15:36 +0100
Subject: Added 'lang: es-es'

---
 es-es/bash-es.html.markdown | 1 +
 1 file changed, 1 insertion(+)

(limited to 'es-es')

diff --git a/es-es/bash-es.html.markdown b/es-es/bash-es.html.markdown
index 489fd39e..fb89b2a0 100644
--- a/es-es/bash-es.html.markdown
+++ b/es-es/bash-es.html.markdown
@@ -11,6 +11,7 @@ contributors:
 translators:
     - ["Daniel Zendejas", "https://github.com/danielzendejas"]
 filename: LearnBash-es.sh
+lang: es-es
 ---
 
 Tutorial de Shell en español.
-- 
cgit v1.2.3


From ef6544a8868d3b19a115804b2db3962d91ad7979 Mon Sep 17 00:00:00 2001
From: Geoffrey Liu <liug.2012@gmail.com>
Date: Sun, 12 Oct 2014 14:24:42 -0700
Subject: Capitalize language names for translations.

#137
---
 es-es/julia-es.html.markdown | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'es-es')

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
 ---
-- 
cgit v1.2.3


From 0d01004725423b29e196acf74a626bd3585934cc Mon Sep 17 00:00:00 2001
From: hirohope <hiro.hope@gmail.com>
Date: Tue, 20 Jan 2015 23:16:35 -0300
Subject: haml-es

---
 es-es/haml-es.html.markdown | 159 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 159 insertions(+)
 create mode 100644 es-es/haml-es.html.markdown

(limited to 'es-es')

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.
-- 
cgit v1.2.3


From 898750902a9035830652ef367015b830525349f6 Mon Sep 17 00:00:00 2001
From: Nacho <nachopacheco@gmail.com>
Date: Thu, 19 Feb 2015 07:35:22 -0600
Subject: Updated Spanish translation

---
 es-es/go-es.html.markdown | 618 ++++++++++++++++++++++++++++------------------
 1 file changed, 371 insertions(+), 247 deletions(-)

(limited to 'es-es')

diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
index 86de33ec..90967727 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -1,326 +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.
+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
-en día, y tiene características que ayudan con la programación a gran
-escala.
+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 librería estándar muy buena y una comunidad entusiasta.
+Go viene con una biblioteca estándar muy buena y una entusiasta comunidad.
 
 ```go
 // Comentario de una sola línea
-/* Comentario 
-   multi línea */
+/* Comentario
+   multilínea */
 
-// La cláusula package aparece al comienzo de cada archivo fuente.
-// Main es un nombre especial que declara un ejecutable en vez de una librería.
+// La cláusula `package` aparece al comienzo de cada archivo fuente.
+// `main` es un nombre especial que declara un ejecutable en vez de una
+// biblioteca.
 package main
 
-// La declaración Import declara los paquetes de librerías
-// referenciados en este archivo.
+// La instrucción `import` declara los paquetes de bibliotecas referidos
+// en este archivo.
 import (
-    "fmt"      // Un paquete en la librería estándar de Go.
-    "net/http" // Sí, un servidor web!
-    "strconv"  // Conversiones de cadenas.
-    m "math"   // Librería matemáticas con alias local m.
+	"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.
+// 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("Hello world!")
+	// 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.
-    beyondHello()
+	// 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 beyondHello() {
-    var x int // Declaración de una variable.
-              // Las variables se deben declarar antes de utilizarlas.
-    x = 3     // Asignación de variables.
-    // Declaración "corta" con := para inferir el tipo, declarar y asignar.
-    y := 4
-    sum, prod := learnMultiple(x, y)        // Función devuelve dos valores.
-    fmt.Println("sum:", sum, "prod:", prod) // Simple salida.
-    learnTypes()                            // < y minutes, learn more!
+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 minutes, ¡aprende más!
 }
 
-// Las funciones pueden tener parámetros y (múltiples!) valores de retorno.
-func learnMultiple(x, y int) (sum, prod int) {
-    return x + y, x * y // Devolver dos valores.
+// 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 learnTypes() {
-    // La declaración corta suele darte lo que quieres.
-    s := "Learn Go!" // tipo cadena
-
-    s2 := ` Un tipo cadena "puro" puede incluir
+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 fuentes de Go son UTF-8.
-    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.
-    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 de uint8.
-
-    // Los Arrays tienen un tamaño fijo a la hora de compilar.
-    var a4 [4]int           // Un array de 4 ints, inicializados a 0.
-    a3 := [...]int{3, 1, 5} // Un array de 3 ints, inicializados como se indica.
-
-    // Los Slices tienen tamaño dinámico. Los arrays y slices tienen sus ventajas
-    // y desventajas pero los casos de uso para los slices son más comunes.
-    s3 := []int{4, 5, 9}    // Comparar con a3. No hay puntos suspensivos.
-    s4 := make([]int, 4)    // Asigna slices de 4 ints, inicializados a 0.
-    var d2 [][]float64      // Solo declaración, sin asignación.
-    bs := []byte("a slice") // Sintaxis de conversión de tipo.
-
-    p, q := learnMemory() // Declara p, q para ser un tipo puntero a int.
-    fmt.Println(*p, *q)   // * sigue un puntero. Esto imprime dos ints.
-
-    // Los Maps son arrays asociativos dinámicos, como los hash o
-    // diccionarios de otros lenguajes.
-    m := map[string]int{"three": 3, "four": 4}
-    m["one"] = 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)
-
-    learnFlowControl() // Vuelta al flujo.
+	// 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 puntero pero no aritmética de
-// punteros.  Puedes cometer un errores con un puntero nil, pero no
+// 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 learnMemory() (p, q *int) {
-    // q y p tienen un tipo puntero a int.
-    p = new(int) // Función incorporada que asigna memoria.
-    // La asignación de int se inicializa a 0, p ya no es nil.
-    s := make([]int, 20) // Asigna 20 ints a un solo bloque de memoria.
-    s[3] = 7             // Asignar uno de ellos.
-    r := -2              // Declarar otra variable local.
-    return &s[3], &r     // & toma la dirección de un objeto.
+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 expensiveComputation() float64 {
-    return m.Exp(10)
+func cálculoCaro() float64 {
+	return m.Exp(10)
 }
 
-func learnFlowControl() {
-    // La declaración If requiere llaves, pero no paréntesis.
-    if true {
-        fmt.Println("told ya")
-    }
-    // El formato está estandarizado por el comando "go fmt."
-    if false {
-        // Pout.
-    } else {
-        // Gloat.
-    }
-    // Utiliza switch preferiblemente 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.
+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 values (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
     }
-    // Como if, for no utiliza paréntesis tampoco.
-    // Variables declaradas en for y if son locales de su ámbito local.
-    for x := 0; x < 3; x++ { // ++ es una sentencia.
-        fmt.Println("iteration", x)
-    }
-    // x == 42 aqui.
+	// 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!
+}
 
-    // For es la única sentencia de bucle en Go, pero tiene formas alternativas.
-    for { // Bucle infinito.
-        break    // Solo bromeaba!
-        continue // No llega.
-    }
-    // Como en for, := en una sentencia if significa declarar y asignar primero,
-    // luego comprobar y > x.
-    if y := expensiveComputation(); y > x {
-        x = y
-    }
-    // Los literales de funciones son "closures".
-    xBig := func() bool {
-        return x > 100 // Referencia a x declarada encima de la sentencia switch.
-    }
-    fmt.Println("xBig:", xBig()) // verdadero (la última vez asignamos 1e6 a x).
-    x /= m.Exp(9)                // Esto lo hace x == e.
-    fmt.Println("xBig:", xBig()) // Ahora es falso.
+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"))
+}
 
-    // Cuando lo necesites, te encantará.
-    goto love
-love:
+// 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
+	}
+}
 
-    learnInterfaces() // Buen material dentro de poco!
+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
+	String() string
 }
 
-// Define pair como un struct con dos campos int, x e y.
-type pair struct {
-    x, y int
+// Define par como una estructura con dos campos int, x e y.
+type par struct {
+	x, y int
 }
 
-// Define un método del tipo pair. Pair ahora implementa Stringer.
-func (p pair) String() string { // p se llama "recibidor"
-    // Sprintf es otra función pública del paquete fmt.
-    // La sintaxis con punto referencia campos de p.
-    return fmt.Sprintf("(%d, %d)", p.x, p.y)
+// 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 learnInterfaces() {
-    // La sintaxis de llaves es un "literal struct". Evalúa a un struct
-    // inicializado.  La sintaxis := declara e inicializa p a este struct.
-    p := pair{3, 4}
-    fmt.Println(p.String()) // Llamar al método String de p, de tipo pair.
-    var i Stringer          // Declarar i como interfaz tipo Stringer.
-    i = p                   // Válido porque pair implementa Stringer.
-    // Llamar 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
-    // preguntar a un objeto por una versió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.
-
-    learnVariadicParams("great", "learning", "here!")
+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 learnVariadicParams(myStrings ...interface{}) {
-    // Iterar cada valor de la variadic.
-    for _, param := range myStrings {
-        fmt.Println("param:", param)
-    }
-    
-    // Pasar valor variadic como parámetro variadic.
-    fmt.Println("params:", fmt.Sprintln(myStrings...))
-
-    learnErrorHandling()
+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 learnErrorHandling() {
-    // ", ok" forma utilizada para saber si algo funcionó o no.
-    m := map[int]string{3: "three", 4: "four"}
-    if x, ok := m[1]; !ok { // ok será falso porque 1 no está en el map.
-        fmt.Println("no one there")
-    } else {
-        fmt.Print(x) // x sería el valor, si estuviera en el map.
-    }
-    // Un valor de error comunica más información sobre el problema aparte de "ok".
-    if _, err := strconv.Atoi("non-int"); err != nil { // _ descarta el valor
-        // Imprime "strconv.ParseInt: parsing "non-int": invalid syntax".
-        fmt.Println(err)
-    }
-    // Revisarmeos las interfaces más tarde. Mientras tanto,
-    learnConcurrency()
+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 de concurrencia segura.
+// 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 un canal aparece a la izquierda.
+	c <- i + 1 // <- es el operador "enviar" cuando aparece un canal a la
+				  // izquierda.
 }
 
 // Utilizaremos inc para incrementar algunos números concurrentemente.
-func learnConcurrency() {
-    // Misma función make utilizada antes para crear un slice. Make asigna e
-    // inicializa slices, maps, y channels.
-    c := make(chan int)
-    // Iniciar tres goroutines 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 channel.
-    go inc(0, c) // go es una sentencia que inicia una nueva goroutine.
-    go inc(10, c)
-    go inc(-805, c)
-    // Leer los tres resultados del channel e imprimirlos.
-    // No se puede saber en que orden llegarán los resultados!
-    fmt.Println(<-c, <-c, <-c) // Channel a la derecha, <- es el operador "recibir".
-
-    cs := make(chan string)       // Otro channel, este gestiona cadenas.
-    ccs := make(chan chan string) // Un channel de cadenas de channels.
-    go func() { c <- 84 }()       // Iniciar una nueva goroutine solo para
-                                  // enviar un valor.
-    go func() { cs <- "wordy" }() // Otra vez, para cs en esta ocasión.
-    // Select tiene una sintáxis parecida a la sentencia switch pero
-    // cada caso involucra una operacion de channels. Selecciona un caso
-    // de forma aleatoria de los casos que están listos para comunicarse.
-    select {
-    case i := <-c: // El valor recibido puede ser asignado a una variable,
-        fmt.Printf("it's a %T", i)
-    case <-cs:     // o el valor puede ser descartado.
-        fmt.Println("it's a string")
-    case <-ccs:    // Channel vacío, no está listo para la comunicación.
-        fmt.Println("didn't happen.")
-    }
-
-    // En este punto un valor fue devuelvto de c o cs. Uno de las dos
-    // goroutines que se iniciaron se ha completado, la otrá permancerá
-    // bloqueada.
-
-    learnWebProgramming() // Go lo hace. Tu también quieres hacerlo.
+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 learnWebProgramming() {
-    // El primer parámetro de la direccinón TCP a la que escuchar.
-    // El segundo parámetro es una interfaz, concretamente http.Handler.
-    err := http.ListenAndServe(":8080", pair{})
-    fmt.Println(err) // no ignorar errores
+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()
 }
 
-// Haz pair un http.Handler implementando su único método, ServeHTTP.
-func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-    // Servir datos con un método de http.ResponseWriter.
-    w.Write([]byte("You learned Go in Y minutes!"))
+// 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))
 }
 ```
 
-## Para leer más 
+## 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 raíz de todas las cosas de Go es la [web oficial de Go](http://golang.org/).
-Ahí puedes seguir el tutorial, jugar interactivamente y leer mucho.
+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).
 
-La propia definición del lenguaje también está altamente
-recomendada. Es fácil de leer e increíblemente corta (como otras
-definiciones de lenguajes hoy en día)
+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 lectura de estudiantes de Go está el código fuente de
-la librería estándar. Muy bien documentada, demuestra lo mejor de Go
-leíble, comprendible, estilo Go y formas Go. Pincha en el nombre de
-una función en la documentación y te aparecerá el código fuente!
+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/).
-- 
cgit v1.2.3


From b8ee0a0a525c4ff140b3f17fd3d75c8e123d5259 Mon Sep 17 00:00:00 2001
From: Nacho <nachopacheco@gmail.com>
Date: Thu, 19 Feb 2015 14:56:58 -0600
Subject: Updated the Spanish translation, the translated and linked to
 Playground code was tested, changed the URLs for resources in Spanish.

---
 es-es/go-es.html.markdown | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'es-es')

diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
index 90967727..c41d693d 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -33,13 +33,13 @@ Go viene con una biblioteca estándar muy buena y una entusiasta comunidad.
 /* Comentario
    multilínea */
 
-// La cláusula `package` aparece al comienzo de cada archivo fuente.
+// 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 archivo.
+// en este fichero.
 import (
 	"fmt"      // Un paquete en la biblioteca estándar de Go.
 	"io/ioutil" // Implementa algunas útiles funciones de E/S.
@@ -70,7 +70,7 @@ func másAlláDelHola() {
 	suma, producto := aprendeMúltiple(x, y) // La función devuelve dos
 											// valores.
 	fmt.Println("suma:", suma, "producto:", producto) // Simple salida.
-	aprendeTipos()                        // < y minutes, ¡aprende más!
+	aprendeTipos()                        // < y minutos, ¡aprende más!
 }
 
 // Las funciones pueden tener parámetros y (¡múltiples!) valores de
@@ -211,7 +211,7 @@ func aprendeControlDeFlujo() {
 
 	// 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 values (arreglo,
+	// `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
-- 
cgit v1.2.3


From 1cf3a8d797a25071470e6b529aa7db6a54f0b4ab Mon Sep 17 00:00:00 2001
From: Fabio Souto <fsoutomoure@gmail.com>
Date: Mon, 27 Apr 2015 17:03:00 +0200
Subject: Added missing section and fixes some typos

---
 es-es/python-es.html.markdown | 120 +++++++++++++++++++++++++++++++++---------
 1 file changed, 96 insertions(+), 24 deletions(-)

(limited to 'es-es')

diff --git a/es-es/python-es.html.markdown b/es-es/python-es.html.markdown
index f7a0ec02..4930eebc 100644
--- a/es-es/python-es.html.markdown
+++ b/es-es/python-es.html.markdown
@@ -4,6 +4,7 @@ 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
 ---
@@ -30,27 +31,47 @@ Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser apl
 # Tienes números
 3 #=> 3
 
-# Matemática es lo que esperarías
-1 + 1 #=> 2
-8 - 1 #=> 7
-10 * 2 #=> 20
-35 / 5 #=> 7
+# 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
+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
+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
+(1 + 3) * 2  #=> 8
+
+# Operadores booleanos
+# Nota: "and" y "or" son sensibles a mayúsculas
+True and False #=> False
+False or True #=> True
 
-# Valores 'boolean' (booleanos) son primitivos
-True
-False
+# 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
@@ -90,7 +111,7 @@ not False #=> True
 # 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 claves si no quieres contar.
+# Puedes usar palabras clave si no quieres contar.
 "{nombre} quiere comer {comida}".format(nombre="Bob", comida="lasaña")
 
 # None es un objeto
@@ -107,8 +128,8 @@ None is None  #=> True
 
 # None, 0, y strings/listas vacíos(as) todas se evalúan como False.
 # Todos los otros valores son True
-0 == False  #=> True
-"" == False #=> True
+bool(0) #=> False
+bool("") #=> False
 
 
 ####################################################
@@ -130,16 +151,16 @@ otra_variable  # Levanta un error de nombre
 # 'if' puede ser usado como una expresión
 "yahoo!" if 3 > 2 else 2 #=> "yahoo!"
 
-# Listas almacenan secuencias
+# 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]
+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
@@ -173,11 +194,11 @@ 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 largo de una lista con 'len'
+# Examina el tamaño de una lista con 'len'
 len(lista) #=> 6
 
 
-# Tuplas son como listas pero son inmutables.
+# Las tuplas son como las listas, pero son inmutables.
 tupla = (1, 2, 3)
 tupla[0] #=> 1
 tupla[0] = 3  # Levanta un error TypeError
@@ -266,7 +287,7 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
 # Hagamos sólo una variable
 una_variable = 5
 
-# Aquí está una declaración de un 'if'. ¡La indentación es significativa en Python!
+# 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."
@@ -400,12 +421,12 @@ class Humano(object):
     # Un atributo de clase es compartido por todas las instancias de esta clase
     especie = "H. sapiens"
 
-    # Constructor basico
+    # 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 metodo de instancia. Todos los metodos toman self como primer argumento
+    # Un método de instancia. Todos los metodos toman self como primer argumento
     def decir(self, msg):
        return "%s: %s" % (self.nombre, msg)
 
@@ -470,6 +491,56 @@ 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?
@@ -481,6 +552,7 @@ dir(math)
 * [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
 
-- 
cgit v1.2.3


From 9f17872f21bc3a43a1023325414802c2e4467534 Mon Sep 17 00:00:00 2001
From: Leonardo Diez <leio10@users.noreply.github.com>
Date: Fri, 3 Jul 2015 11:34:26 +0200
Subject: Update git-es.html.markdown

---
 es-es/git-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
index 5c9d3378..73853a9d 100644
--- a/es-es/git-es.html.markdown
+++ b/es-es/git-es.html.markdown
@@ -38,7 +38,7 @@ uno o varios archivos, a lo largo del tiempo.
 * Se puede trabajar sin conexion.
 * Colaborar con otros es sencillo!.
 * Derivar, Crear ramas del proyecto (aka: Branching) es facil!.
-* Combinar (aka: Marging)
+* Combinar (aka: Merging)
 * Git es rapido.
 * Git es flexible.
 
-- 
cgit v1.2.3


From a0e8d3202b1642d9be1a8fcc6db95273415373b4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ismael=20Venegas=20Castell=C3=B3?= <ismael.vc1337@gmail.com>
Date: Fri, 14 Aug 2015 20:28:08 -0500
Subject: Update julia-es to v0.3.11

---
 es-es/julia-es.html.markdown | 1268 ++++++++++++++++++++++++------------------
 1 file changed, 724 insertions(+), 544 deletions(-)

(limited to 'es-es')

diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 203ee3bb..1e01c2e3 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -4,757 +4,937 @@ 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
 ---
 
-Julia es un nuevo lenguaje funcional homoiconic enfocado en computación técnica.
-Aunque que tiene todo el poder de macros homoiconic, funciones de primera
-clase, y control de bajo nivel, Julia es tan fácil de aprender y utilizar como
-Python.
+![JuliaLang](https://camo.githubusercontent.com/e1ae5c7f6fe275a50134d5889a68f0acdd09ada8/687474703a2f2f6a756c69616c616e672e6f72672f696d616765732f6c6f676f5f68697265732e706e67)
 
-Esto se basa en la versión de desarrollo actual de Julia, del 18 de octubre de
-2013.
+[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).
 
-```ruby
+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.
 
-# Comentarios de una línea comienzan con una almohadilla (o signo gato)
+### ¡Prueba Julia ahora mismo!
 
-#= Commentarios multilinea pueden escribirse
-   usando '#=' antes de el texto  y '=#' 
-   después del texto. También se pueden anidar.
+* [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`.
+
+```julia
+# Los comentarios de una línea comienzan con una almohadilla (o signo de gato).
+
+#=
+  Los commentarios 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.
+##############################################
+# 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})
+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
-5/2 # => 2.5 # dividir un Int por un Int siempre resulta en un Float
-div (5, 2) # => 2 # para un resultado truncado, usa 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 # logical shift right
-2 >> 1  # => 1 # arithmetic shift right
-2 << 1  # => 4 # logical/arithmetic shift left
-
-# Se puede utilizar la función bits para ver la representación binaria de un
-# número.
+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"
 
-# Valores 'boolean' (booleanos) son primitivos
-true
-false
-
-# Operadores Boolean (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
+# 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
+1 < 2 < 3    # => true
+2 < 3 < 2    # => false
 
-# Strings se crean con " 
-"Esto es un string."
+# Los literales de cadenas (String) se crean con la comilla doble: "
+"Esto es una cadena."
 
-# Literales de caracteres se escriben con '
+# Los literales de caracteres (Char) se crean con la comilla simple: '
 'a'
 
-# Una string puede ser indexado como una array de caracteres
-"Esto es un string."[1] # => 'E' # �ndices en Julia empiezen del 1
-# Sin embargo, esto no va a funcionar bien para strings UTF8, 
+# 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 strings:
-"2 + 2 = $(2 + 2)" # => "2 + 2 = 4"
-# Se puede poner cualquier expresión de Julia dentro los paréntesis.
+# $ 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
 
-# Otro forma de formatear strings es el macro printf
-@printf "%d es menor de %f" 4.5 5.3 # 5 es menor de 5.300000
+# ¡Imprimir es muy fácil!
+println("¡Hola Julia!")    # ¡Hola Julia!
 
-# Imprimir es muy fácil
-println("Soy Julia. ¡Encantado de conocerte!")
 
-####################################################
-## 2. Variables y Colecciones
-####################################################
+##############################
+# 2. Variables y Colecciones #
+##############################
 
 # No hay necesidad de declarar las variables antes de asignarlas.
-una_variable = 5 # => 5
-una_variable # => 5
+una_variable = 5    # => 5
+una_variable        # => 5
 
-# Acceder a variables no asignadas previamente es una excepción.
+# Acceder a una variable no asignada previamente es una excepción.
 try
-    otra_variable # => ERROR: some_other_var not defined
+    otra_variable    # ERROR: otra_variable not defined
 catch e
-    println(e)
+    println(e)       # UndefVarError(:otra_variable)
 end
 
-# Los nombres de variables comienzan con una letra.
-# Después de eso, puedes utilizar letras, dígitos, guiones y signos de
+# 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.
-OtraVariable123! = 6 # => 6
+otraVariable_123! = 6    # => 6
+
+# También puedes utilizar caracteres Unicode.
+☃ = 8    # => 8
 
-# También puede utilizar caracteres unicode
-☃ = 8 # => 8
 # Estos son especialmente útiles para la notación matemática
-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 underscore ('\ _'). 
-#
-# * Los nombres de los tipos comienzan con una letra mayúscula y separación de
-#   palabras se muestra con CamelCase en vez de underscore.
-#
-# * Los nombres de las funciones y los macros están en minúsculas, sin
-#   underscore.
-#
-# * Funciones que modifican sus inputs tienen nombres que terminan en!. Estos 
-#   funciones a veces se llaman mutating functions o in-place functions.
-
-# Los Arrays almacenan una secuencia de valores indexados entre 1 hasta n
-a = Int64[] # => 0-element Int64 Array
-
-# Literales de arrays 1-dimensionales se pueden escribir con valores separados
-# por comas.
-b = [4, 5, 6] # => 3-element Int64 Array: [4, 5, 6]
-b[1] # => 4
-b[end] # => 6
-
-# Los arrays 2-dimensionales usan valores separados por espacios y filas
-# separados por punto y coma.
-matrix = [1 2; 3 4] # => 2x2 Int64 Array: [1 2; 3 4]
-
-# Añadir cosas a la final de una lista 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 de la 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 # recuerdan que 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
-
-# tambien 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]
-
-# Nombres de funciónes que terminan en exclamaciones indican que modifican 
-# su argumento.
-arr = [5,4,6] # => 3-element Int64 Array: [5,4,6]
-sort(arr) # => [4,5,6]; arr es todavía [5,4,6]
-sort!(arr) # => [4,5,6]; arr  es ahora [4,5,6]
-
-# Buscando fuera de límites es un BoundsError
+# (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 guion 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 a la 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 funciónes 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
+    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)
+    println(e)    # BoundsError()
 end
 
-# Errors dan la línea y el archivo de su procedencia, aunque sea en el standard
-# library. Si construyes Julia de source, puedes buscar en el source para
-# encontrar estos archivos.
+# 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]
 
-# Se puede inicializar arrays de un range
-a = [1:5] # => 5-element Int64 Array: [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]
 
-# Puedes mirar en ranges con sintaxis slice.
-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]
 
-# Eliminar elementos de una array por índice con splice!
-arr = [3,4,5]
-splice!(arr,2) # => 4 ; 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]
 
-# Concatenar listas con append!
-b = [1,2,3]
-append!(a,b) # ahroa a es [1, 2, 3, 4, 5, 1, 2, 3]
+# Comprueba la existencia de un elemento en un arreglo con in.
+in(1, a)    # => true
 
-# Comprueba la existencia en una lista con in
-in(1, a) # => true
+# Examina la longitud con length.
+length(a)    # => 8
 
-# 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
 
-# Tuples son immutable.
-tup = (1, 2, 3) # => (1,2,3) # un (Int64,Int64,Int64) tuple.
-tup[1] # => 1
 try:
-    tup[1] = 3 # => ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
+    tup[1] = 3     # ERROR: no method setindex!((Int64,Int64,Int64),Int64,Int64)
 catch e
-    println(e)
+    println(e)     # MethodError(setindex!,(:tup,3,1))
 end
 
-# Muchas funciones de lista también trabajan en las tuples
-length(tup) # => 3
-tup[1:2] # => (1,2)
-in(2, tup) # => true
+# Muchas funciones de arreglos también trabajan en con las tuplas.
+length(tup)    # => 3
+tup[1:2]       # => (1,2)
+in(2, tup)     # => true
 
-# Se puede desempacar tuples en variables
-a, b, c = (1, 2, 3) # => (1,2,3)  # a is now 1, b is now 2 and c is now 3
+# 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 tuples se crean, incluso si se omite el paréntesis
-d, e, f = 4, 5, 6 # => (4,5,6)
+# Los tuplas se crean, incluso si se omiten los paréntesis.
+d, e, f = 4, 5, 6    # => (4,5,6)
 
-# Un tuple 1-elemento es distinto del valor que contiene
-(1,) == 1 # => false
-(1) == 1 # => true
+# 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) # d is now 5 and e is now 4
+# 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
 
-# Dictionaries almanecan mapeos
-dict_vacio = Dict() # => Dict{Any,Any}()
+# 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"
+=#
 
-# Se puede crear un dictionary usando un literal
-dict_lleno = ["one"=> 1, "two"=> 2, "three"=> 3]
-# => Dict{ASCIIString,Int64}
+# Nota: los elementos del diccionario no están ordenados y no se guarda el orden
+# en que se insertan.
 
-# Busca valores con []
-dict_lleno["one"] # => 1
+# Obtén todos los valores.
+values(dicc_lleno)
+#=
+ => ValueIterator for a Dict{ASCIIString,Int64} with 3 entries. Values:
+      3
+      2
+      1
+=#
 
-# Obtén todas las claves 
-keys(dict_lleno)
-# => KeyIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
-# Nota - claves del dictionary no están ordenados ni en el orden en que se
-# insertan.
+# Nota: igual que el anterior en cuanto a ordenamiento de los elementos.
 
-# Obtén todos los valores
-values(dict_lleno)
-# => ValueIterator{Dict{ASCIIString,Int64}}(["three"=>3,"one"=>1,"two"=>2])
-# Nota - Igual que el anterior en cuanto a ordenamiento de claves.
+# Comprueba si una clave existe en un diccionario con in y haskey.
+in(("uno", 1), dicc_lleno)     # => true
+in(("tres", 3), dicc_lleno)    # => false
 
-# Compruebe si hay existencia de claves en un dictionary con in y haskey
-in(("uno", 1), dict_lleno) # => true
-in(("tres", 3), dict_lleno) # => false
-haskey(dict_lleno, "one") # => true
-haskey(dict_lleno, 1) # => false
+haskey(dicc_lleno, "uno")      # => true
+haskey(dicc_lleno, 1)          # => false
 
-# Tratando de buscar una clave que no existe producirá un error
+# Tratar de obtener un valor con una clave que no existe producirá un error.
 try
-    dict_lleno["dos"] # => ERROR: key not found: dos in getindex at dict.jl:489
+    # ERROR: key not found: cuatro in getindex at dict.jl:489
+    dicc_lleno["cuatro"]
 catch e
-    println(e)
+    println(e)    # KeyError("cuatro")
 end
 
-# Utilice el método get para evitar ese error proporcionando un valor
-# predeterminado
-# get(dictionary,key,default_value)
-get(dict_lleno,"one",4) # => 1
-get(dict_lleno,"four",4) # => 4
+# 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}({})
 
-# Usa Sets para representar colecciones (conjuntos) de valores únicos, no
-# ordenadas
-conjunto_vacio = Set() # => Set{Any}()
-# Iniciar una set de valores
-conjunto_lleno = Set(1,2,2,3,4) # => Set{Int64}(1,2,3,4)
+# 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}(5,4,2,3,1)
-push!(conjunto_lleno,5) # => Set{Int64}(5,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})
 
-# Compruebe si los valores están en el conjunto
-in(2, conjunto_lleno) # => true
-in(10, conjunto_lleno) # => false
+# Comprobar si los valores están en el conjunto.
+in(2, conjunto_lleno)     # => true
+in(10, conjunto_lleno)    # => false
 
-# Hay funciones de intersección de conjuntos, la unión, y la diferencia.
-conjunto_otro= Set(3, 4, 5, 6) # => Set{Int64}(6,4,5,3)
-intersect(conjunto_lleno, conjunto_otro) # => Set{Int64}(3,4,5)
-union(conjunto_lleno, conjunto_otro) # => Set{Int64}(1,2,3,4,5,6)
-setdiff(Set(1,2,3,4),Set(2,3,5)) # => Set{Int64}(1,4)
+# 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
-####################################################
+#######################
+# 3. Control de Flujo #
+#######################
 
-# Hagamos una variable
+# Hagamos una variable.
 una_variable = 5
 
-# Aquí está una declaración de un 'if'. La indentación no es significativa en
-# Julia
+# 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 mas grande que 10.")
-elseif una_variable < 10    # Este condición 'elseif' es opcional.
-    println("una_variable es mas chica que 10.")
-else                    # Esto también es opcional.
-    println("una_variable es de hecho 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 mas chica que 10."
+# imprime: una_variable es menor que 10.
 
-# For itera sobre tipos iterables
-# Tipos iterables incluyen Range, Array, Set, Dict, y String.
-for animal=["perro", "gato", "raton"]
-    println("$animal es un mamifero")
-    # Se puede usar $ para interpolar variables o expresiónes en strings
+# 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 mamifero
-#    gato es un mamifero
-#    raton es un mamifero
+#=
+ imprime:
+   perro es un mamífero.
+   gato es un mamífero.
+   ratón es un mamífero.
+=#
 
-for a in ["perro"=>"mamifero","gato"=>"mamifero","raton"=>"mamifero"]
-    println("$(a[1]) es un $(a[2])")
+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 mamifero
-#    gato es un mamifero
-#    raton es un mamifero
+#=
+ imprime:
+   perro es un mamífero.
+   gato es un mamífero.
+   ratón es un mamífero.
+=#
 
-for (k,v) in ["perro"=>"mamifero", "gato"=>"mamifero", "raton"=>"mamifero"]
-    println("$k es un $v")
+for (k,v) in ["perro"=>"mamífero", "gato"=>"mamífero", "ratón"=>"mamífero"]
+    println("$k es un $v.")
 end
-# imprime:
-#    perro es un mamifero
-#    gato es un mamifero
-#    raton es un mamifero
+#=
+ imprime:
+   perro es un mamífero.
+   gato es un mamífero.
+   ratón es un mamífero.
+=#
 
-# While itera hasta que una condición no se cumple.
+# 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
+    x += 1    # versión corta de: x = x + 1
 end
-# imprime:
-#   0
-#   1
-#   2
-#   3
+#=
+imprime:
+  0
+  1
+  2
+  3
+=#
 
-# Maneja excepciones con un bloque try/catch
-try
-   error("ayuda")
+# Maneja excepciones con un bloque try/catch.
+try    # intentar
+   error("Ooops!")
 catch e
-   println("capturando $e")
+   println("capturando: $e")    # capturando: ErrorException("Ooops!")
 end
-# => capturando ErrorException("ayuda")
 
 
-####################################################
-## 4. Funciones
-####################################################
+################
+# 4. Funciones #
+################
 
-# Usa 'function' para crear nuevas funciones
+# Usa function para crear nuevas funciones.
 
-#function nombre(arglist)
-#  cuerpo...
-#end
+#=
+    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 declaración
+    # 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 de 6"
+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
+# 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
-    # Usa la palabra clave return para devolver en cualquier lugar de la función
 end
 # => varargs (generic function with 1 method)
 
-varargs(1,2,3) # => (1,2,3)
+varargs(1, 2, 3)      # => (1,2,3)
+varargs([1, 2, 3])    # => ([1,2,3],)
 
-# El ... se llama un splat.
-# Acabamos de utilizar lo en una definición de función.
-# También se puede utilizar en una llamada de función,
-# donde va splat un Array o el contenido de un Tuple en la lista de argumentos.
-Set([1,2,3])    # => Set{Array{Int64,1}}([1,2,3]) # Produce un Set de Arrays
-Set([1,2,3]...) # => Set{Int64}(1,2,3) # esto es equivalente a Set(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)
-Set(x)          # => Set{(Int64,Int64,Int64)}((1,2,3)) # un Set de Tuples
-Set(x...)       # => Set{Int64}(2,3,1)
+x = (1, 2, 3)    # => (1,2,3)
+varargs(x)       # => ((1,2,3),)
+varargs(x...)    # => (1,2,3)
 
+varargs("abc"...)    # => ('a','b','c')
 
-# Puede definir funciones con argumentos posicionales opcionales
-function defaults(a,b,x=5,y=6)
+# 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"
 
-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: no method defaults(Char,)
-    defaults() # => ERROR: no methods defaults()
+    defaults('h')    # ERROR: `defaults` has no method matching defaults(::Char)
+    defaults()       # ERROR: `defaults` has no method matching defaults()
 catch e
-    println(e)
+    println(e)       # MethodError(defaults,('h',))
 end
 
-# Puedes definir funciones que toman argumentos de palabra clave
-function args_clave(;k1=4,nombre2="hola") # note the ;
-    return ["k1"=>k1,"nombre2"=>nombre2]
+# 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]
+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_normal, arg_posicional_opcional=2; arg_clave="foo")
-    println("argumento normal: $arg_normal")
-    println("argumento optional: $arg_posicional_opcional")
-    println("argumento de clave: $arg_clave")
+# 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 normal: 1
-#   argumento optional: 3
-#   argumento de clave: 4
+#=
+ imprime:
+   argumento posicional: 1
+     argumento opcional: 3
+        argumento clave: 4
+=#
 
-# Julia tiene funciones de primera clase
+# Julia tiene funciones de primera clase.
 function crear_suma(x)
-    suma = function (y)
+    suma = function (y)    # función anónima
         return x + y
     end
     return suma
 end
+# => crear_suma (generic function with 1 method)
 
-# Esta es el sintaxis "stabby lambda" para crear funciones anónimas
-(x -> x > 2)(3) # => true
+# 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.
-function crear_suma(x)
-    y -> x + y
-end
+crear_suma(x) = y -> x + y
 
-# También puedes nombrar la función interna, si quieres
+# 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_10(3) # => 13
+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]
 
-# 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 listas por comprensión para mapeos
-[suma_10(i) for i=[1, 2, 3]] # => [11, 12, 13]
-[suma_10(i) for i in [1, 2, 3]] # => [11, 12, 13]
+# 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]
 
-####################################################
-## 5. Tipos
-####################################################
+[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 #
+############
 
-# Julia tiene sistema de 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
+# 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
-typeof(Int64) # => DataType
-typeof(DataType) # => DataType
-# DataType es el tipo que representa los tipos, incluyéndose a sí mismo.
+# 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, optimizaciones, y envio.
-# No están comprobados estáticamente.
+# 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 tipos 
-# Son como registros o estructuras en otros idiomas. 
-# Nuevos tipos se definen utilizado la palabra clave `type`.
+# 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
-#   field::OptionalType
+#   atributo::UnTipo    # las anotaciones de tipos son opcionales
 #   ...
 # end
 type Tigre
-  longituddecola::Float64
-  colordelpelaje # no incluyendo una anotación de tipo es el mismo que `::Any`
+    longitud_cola::Float64
+    color_pelaje            # sin una anotación de tipo, es lo mismo que `::Any`
 end
 
-# Los argumentos del constructor por default son las propiedades 
-# del tipo, en el orden en que están listados en la definición
-tigger = Tigre(3.5,"anaranjado") # => Tiger(3.5,"anaranjado")
+# 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 la función constructora de valores de ese tipo
-sherekhan = typeof(tigger)(5.6,"fuego") # => Tiger(5.6,"fuego")
+# 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 concrete 
-# Se pueden crear instancias, pero no pueden tener subtipos. 
-# La otra clase de tipos es tipos abstractos (abstract types).
+# 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
-
-# De los tipos Abstract no se pueden crear instancias, pero pueden tener
-# subtipos.  Por ejemplo, Number es un tipo abstracto.
-subtypes(Number) # => 6-element Array{Any,1}:
-                 #     Complex{Float16}
-                 #     Complex{Float32}
-                 #     Complex{Float64}
-                 #     Complex{T<:Real}
-                 #     Real
-subtypes(Gato) # => 0-element Array{Any,1}
-
-# Cada tipo tiene un supertipo, utilice la función `súper` para conseguirlo.
-typeof(5) # => Int64
-super(Int64) # => Signed
-super(Signed) # => Real
-super(Real) # => Number
-super(Number) # => Any
-super(super(Signed)) # => Number
-super(Any) # => Any
-# Todo de estos tipos, a excepción de Int64, son abstractos.
-
-# <: es el operador de subtipos
-type Leon <: Gato # Leon es un subtipo de Gato
-  color_de_crin
-  rugido::String
-end
+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
 
-# Se puede definir más constructores para su tipo.
-# Sólo defina una función del mismo nombre que el tipo
-# y llame a un constructor existente para obtener un valor del tipo correcto
-Leon(rugido::String) = Leon("verde",rugido)
-# Este es un constructor externo porque es fuera de la definición del tipo
-
-type Pantera <: Gato # Pantera tambien es un a subtipo de Cat
-  color_de_ojos
-  Pantera() = new("verde")
-    # Panteras sólo tendrán este constructor, y ningún constructor
-    # predeterminado.
+# 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
-# Utilizar constructores internos, como Panther hace, te da control sobre cómo
-# se pueden crear valores del tipo.  Cuando sea posible, debes utilizar
-# constructores exteriores en lugar de los internos.
 
-####################################################
-## 6.  Envio múltiple
-####################################################
+# 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.
 
-# En Julia, todas las funciones nombradas son funciones genéricas.
-# Esto significa que se construyen a partir de muchos métodos pequeños 
-# Cada constructor de Leon es un método de la función genérica Leon.
+# Este es un constructor externo porque es fuera de la definición del tipo.
+Leon(rugido::String) = Leon("verde", rugido)
 
-# Por ejemplo, vamos a hacer un maullar función:
+type Pantera <: Gato    # Pantera también es un a subtipo de Gato
+    color_ojos
 
-# Definiciones para Leon, Pantera, y Tigre
-function maullar(animal::Leon)
-  animal.rugido # acceso utilizando notación de puntos
+    # Pantera sólo tendrá este constructor, y ningún constructor predeterminado.
+    Pantera() = new("verde")
 end
 
-function maullar(animal::Pantera)
-  "grrr"
-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.
 
-function maullar(animal::Tigre)
-  "rawwwr"
-end
 
-# Prueba de la función maullar
-maullar(tigger) # => "rawwr"
-maullar(Leon("cafe","ROAAR")) # => "ROAAR"
-maullar(Pantera()) # => "grrr"
+########################
+# 6. Despacho Múltiple #
+########################
 
-# Revisar la jerarquía de tipos locales
-issubtype(Tigre,Gato) # => false
-issubtype(Leon,Gato) # => true
-issubtype(Pantera,Gato) # => true
+# En Julia, todas las funciones nombradas son funciones genéricas.
+# Esto significa que se construyen a partir de muchos métodosmás pequeños.
+# Cada constructor de Leon es un método de la función genérica Leon.
 
-# Definición de una función que toma Gatos
-function mascota(gato::Gato)
-  println("El gato dice $(maullar(gato))")
-end
+# Por ejemplo, vamos a hacer métodos para 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
 
-mascota(Leon("42")) # => imprime "El gato dice 42"
 try
-    mascota(tigger) # => ERROR: no method mascota(Tigre))
+    mascota(tigre)    # ERROR: `mascota` has no method matching mascota(::Tigre)
 catch e
-    println(e)
+    println(e)        # MethodError(mascota,(Tigre(3.5,"anaranjado"),))
 end
 
-# En los lenguajes orientados a objetos, expedición única es común. Esto
-# significa que el método se recogió basándose en el tipo del primer argumento.
-# En Julia, todos los tipos de argumentos contribuyen a seleccionar el mejor
-# método.
+# 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
-function pelear(t::Tigre,c::Gato)
-  println("¡El tigre $(t.colordelpelaje) gana!")
-end
+pelear(t::Tigre, c::Gato) = println("¡El tigre $(t.color_pelaje) gana!")
 # => pelear (generic function with 1 method)
 
-pelear(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana!
-pelear(tigger,Leon("ROAR")) # => ¡El tigre anaranjado gana!
+pelear(tigre, Pantera())       # ¡El tigre anaranjado gana!
+pelear(tigre, Leon("ROAR"))    # ¡El tigre anaranjado gana!
 
-# Vamos a cambiar el comportamiento cuando el Gato es específicamente un Leon
-pelear(t::Tigre,l::Leon) = println("El león con melena $(l.color_de_crin) 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(tigger,Pantera()) # => imprime ¡El tigre anaranjado gana!
-pelear(tigger,Leon("ROAR")) # => imprime El león con melena verde gana
+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))")
-# => fight (generic function with 3 methods)
+# 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()) # => imprime El gato victorioso dice grrr
+pelear(Leon("balooga!"), Pantera())    # El gato victorioso dice grrr.
 try
-  pelear(Pantera(),Leon("RAWR")) # => ERROR: no method pelear(Pantera, Leon))
-catch
+    # 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 gato primero
+# 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 metodo de pelear será llamado
-# en:
-pelear(Leon("RAR"),Leon("cafe","rar")) # => imprime El gato victorioso dice rar
-# El resultado puede ser diferente en otras versiones de Julia
+#=
+  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")) # => imprime Los leones llegan a un empate
-
-
-# Un vistazo al nivel bajo
-# Se puede echar un vistazo a la LLVM y el código ensamblador generado.
-
-area_cuadrada(l) = l * l      # area_cuadrada (generic function with 1 method)
-
-area_cuadrada(5) # => 25
-
-# ¿Qué sucede cuando damos area_cuadrada diferentes argumentos?
-code_native(area_cuadrada, (Int32,))  
-	#	    .section    __TEXT,__text,regular,pure_instructions
-	#	Filename: none
-	#	Source line: 1              # Prologue
-	#	    push    RBP
-	#	    mov RBP, RSP
-	#	Source line: 1
-	#	    movsxd  RAX, EDI        # Fetch l from memory?
-	#	    imul    RAX, RAX        # Square l and store the result in RAX
-	#	    pop RBP                 # Restore old base pointer
-	#	    ret                     # Result will still be in RAX
-
-code_native(area_cuadrada, (Float32,))
-	#	    .section    __TEXT,__text,regular,pure_instructions
-	#	Filename: none
-	#	Source line: 1
-	#	    push    RBP
-	#	    mov RBP, RSP
-	#	Source line: 1
-	#	    vmulss  XMM0, XMM0, XMM0  # Scalar single precision multiply (AVX)
-	#	    pop RBP
-	#	    ret
-
-code_native(area_cuadrada, (Float64,))
-	#	    .section    __TEXT,__text,regular,pure_instructions
-	#	Filename: none
-	#	Source line: 1
-	#	    push    RBP
-	#	    mov RBP, RSP
-	#	Source line: 1
-	#	    vmulsd  XMM0, XMM0, XMM0 # Scalar double precision multiply (AVX)
-	#	    pop RBP
-	#	    ret
-	#	
-
-# Ten en cuenta que Julia usará instrucciones de "floating point" si alguno de
-# los argumentos son "floats"
-# Vamos a calcular el área de un círculo
-area_circulo(r) = pi * r * r     # circle_area (generic function with 1 method)
-area_circulo(5)                  # 78.53981633974483
+
+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
-	#	    vcvtsi2sd   XMM0, XMM0, EDI          # Load integer (r) from memory
-	#	    movabs  RAX, 4593140240              # Load pi
-	#	    vmulsd  XMM1, XMM0, QWORD PTR [RAX]  # pi * r
-	#	    vmulsd  XMM0, XMM0, XMM1             # (pi * r) * r
-	#	    pop RBP
-	#	    ret
-	#
+#=
+    .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, 4593140496
-	#	Source line: 1
-	#	    vmulsd  XMM1, XMM0, QWORD PTR [RAX]
-	#	    vmulsd  XMM0, XMM1, XMM0
-	#	    pop RBP
-	#	    ret
-	#	
+#=
+    .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
+=#
 ```
 
-## ¿Listo para más?
+![Julia-tan](http://www.mechajyo.org/wp/wp-content/uploads/2014/10/3a2c3b7de5dd39aa7f056a707cd4eb59.png)
 
-Puedes obtener muchos más detalles en [The Julia Manual](http://docs.julialang.org/en/latest/manual/)
+## ¿Listo para más?
 
-El mejor lugar para obtener ayuda con Julia es el (muy amable) [lista de correos](https://groups.google.com/forum/#!forum/julia-users).
+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).
-- 
cgit v1.2.3


From b84858d2df4b738f96241f65072d94da326bf106 Mon Sep 17 00:00:00 2001
From: Luis Alfredo <unluisco@users.noreply.github.com>
Date: Sun, 30 Aug 2015 19:35:54 -0500
Subject: Actualizar algunos detalles hasta punto 4

---
 es-es/javascript-es.html.markdown | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

(limited to 'es-es')

diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
index a1348508..fd01e7b9 100644
--- a/es-es/javascript-es.html.markdown
+++ b/es-es/javascript-es.html.markdown
@@ -16,8 +16,7 @@ con Java para aplicaciones más complejas. Debido a su integracion estrecha con
 web y soporte por defecto de los navegadores modernos se ha vuelto mucho más común 
 para front-end que Java.
 
-JavaScript no sólo se limita a los navegadores web:
-* Node.js: Un proyecto que provee con un ambiente para el motor V8 de Google Chrome.
+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
@@ -49,6 +48,7 @@ hazAlgo()
 
 // 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
@@ -102,9 +102,11 @@ false;
 
 // 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()
@@ -126,7 +128,7 @@ undefined; // usado para indicar que un valor no está presente actualmente
 // Aunque 0 === "0" sí es false.
 
 ///////////////////////////////////
-// 2. Variables, Arreglos y Objetos
+// 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 =.
@@ -220,7 +222,6 @@ for (var i = 0; i < 5; i++){
 }
 
 // && es un "y" lógico, || es un "o" lógico
-var casa = {tamano:"grande",casa:"color"};
 if (casa.tamano == "grande" && casa.color == "azul"){
     casa.contiene = "oso";
 }
-- 
cgit v1.2.3


From b0036199c4fa6974f285e3b9520e9e058294d584 Mon Sep 17 00:00:00 2001
From: Adam Bard <github@adambard.com>
Date: Wed, 30 Sep 2015 10:40:48 +0800
Subject: Still can't use `julia` highlighting

---
 es-es/julia-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 1e01c2e3..65cb4343 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -41,7 +41,7 @@ En Julia los programas están organizados entorno al [despacho múltiple](http:/
 
 Esto se basa en la versión `0.3.11`.
 
-```julia
+```ruby
 # Los comentarios de una línea comienzan con una almohadilla (o signo de gato).
 
 #=
-- 
cgit v1.2.3


From 64d031429dd68fdd5b76fdd0e87f8379ba681439 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ismael=20Venegas=20Castell=C3=B3?= <ismael.vc1337@gmail.com>
Date: Wed, 30 Sep 2015 00:10:14 -0500
Subject: Use smaller images

I didn't notice they wouldnt fit well, because they fitted ok in github preview.
---
 es-es/julia-es.html.markdown | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'es-es')

diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 65cb4343..95a16412 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -9,7 +9,7 @@ filename: learnjulia-es.jl
 lang: es-es
 ---
 
-![JuliaLang](https://camo.githubusercontent.com/e1ae5c7f6fe275a50134d5889a68f0acdd09ada8/687474703a2f2f6a756c69616c616e672e6f72672f696d616765732f6c6f676f5f68697265732e706e67)
+![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).
 
@@ -931,7 +931,7 @@ code_native(area_circulo, (Float64,))
 =#
 ```
 
-![Julia-tan](http://www.mechajyo.org/wp/wp-content/uploads/2014/10/3a2c3b7de5dd39aa7f056a707cd4eb59.png)
+![Julia-tan](http://s27.postimg.org/x37ndhz0j/julia_tan_small.png)
 
 ## ¿Listo para más?
 
-- 
cgit v1.2.3


From e4a33446a9c910f13bc0224c745c51baf62c1778 Mon Sep 17 00:00:00 2001
From: Jesus Tinoco <JesusTinoco@users.noreply.github.com>
Date: Thu, 1 Oct 2015 21:34:02 +0200
Subject: Typos fixed in julia-es.html.markdown

---
 es-es/julia-es.html.markdown | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'es-es')

diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index 95a16412..bf035edf 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -45,7 +45,7 @@ Esto se basa en la versión `0.3.11`.
 # Los comentarios de una línea comienzan con una almohadilla (o signo de gato).
 
 #=
-  Los commentarios multilínea pueden escribirse
+  Los comentarios multilínea pueden escribirse
   usando '#=' antes de el texto  y '=#'
   después del texto. También se pueden anidar.
 =#
@@ -174,7 +174,7 @@ otraVariable_123! = 6    # => 6
     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 guion bajo:
+    palabras se muestra con CamelCase en vez de guión bajo:
 
     OtroTipo
 
@@ -214,7 +214,7 @@ matrix = [1 2; 3 4]
      3  4
 =#
 
-# Añadir cosas a la final de un arreglo con push! y append!.
+# 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]
@@ -237,7 +237,7 @@ a[end]    # => 6
 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 funciónes que terminan en exclamaciones indican que modifican
+# 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]
@@ -710,7 +710,7 @@ end
 # 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 es fuera de la definición del tipo.
+# 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
@@ -730,7 +730,7 @@ end
 ########################
 
 # En Julia, todas las funciones nombradas son funciones genéricas.
-# Esto significa que se construyen a partir de muchos métodosmás pequeños.
+# 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 para Leon, Pantera, y Tigre de una
-- 
cgit v1.2.3


From c0b09da46f93bc1b59231c9ebd2832198bc85fcb Mon Sep 17 00:00:00 2001
From: Jesus Tinoco <JesusTinoco@users.noreply.github.com>
Date: Fri, 2 Oct 2015 16:11:23 +0200
Subject: Fixing typo in julia-es.html.markdown

---
 es-es/julia-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index bf035edf..e4181609 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -733,7 +733,7 @@ end
 # 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 para Leon, Pantera, y Tigre de una
+# 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
-- 
cgit v1.2.3


From 9b00510c452a24197f7b8d30dee1a5f170e3cdee Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gerson=20L=C3=A1zaro?= <gersonlazaro@gersonlazaro.com>
Date: Sun, 4 Oct 2015 00:09:26 -0500
Subject: =?UTF-8?q?[c++/es]=20a=C3=B1adido?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 es-es/c++-es.html.markdown | 829 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 829 insertions(+)
 create mode 100644 es-es/c++-es.html.markdown

(limited to 'es-es')

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>
-- 
cgit v1.2.3


From 224d4e9c7f8b13da852662edcf57f83d7f78c278 Mon Sep 17 00:00:00 2001
From: Jesus Tinoco <JesusTinoco@users.noreply.github.com>
Date: Sun, 4 Oct 2015 13:17:50 +0200
Subject: Fixing typo in git-es.html.markdown

---
 es-es/git-es.html.markdown | 64 +++++++++++++++++++++++-----------------------
 1 file changed, 32 insertions(+), 32 deletions(-)

(limited to 'es-es')

diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
index 73853a9d..f370aa4d 100644
--- a/es-es/git-es.html.markdown
+++ b/es-es/git-es.html.markdown
@@ -11,15 +11,15 @@ lang: es-es
 ---
 
 Git es un sistema de control de versiones distribuido diseñado para manejar
-cualquier tipo de proyecto ya sea largos o pequeños, con velocidad y eficiencia.
+cualquier tipo de proyect,o ya sea largo 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.
 
-### Que es el control de versiones?
-El control de versiones es un sistema que guarda todos los cambios realizados a
+### 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.
@@ -31,15 +31,15 @@ uno o varios archivos, a lo largo del tiempo.
 + El versionamiento distribuido no tiene una estructura definida, incluso se
   puede mantener el estilo de los repositorios SVN con git.
 
-[Informacion adicional](http://git-scm.com/book/es/Empezando-Acerca-del-control-de-versiones)
+[Información adicional](http://git-scm.com/book/es/Empezando-Acerca-del-control-de-versiones)
 
-### Por que usar Git?
+### Por qué usar Git?
 
 * Se puede trabajar sin conexion.
 * Colaborar con otros es sencillo!.
-* Derivar, Crear ramas del proyecto (aka: Branching) es facil!.
+* Derivar, Crear ramas del proyecto (aka: Branching) es fácil!.
 * Combinar (aka: Merging)
-* Git es rapido.
+* Git es rápido.
 * Git es flexible.
 
 ## Arquitectura de Git.
@@ -48,10 +48,10 @@ uno o varios archivos, a lo largo del tiempo.
 
 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, ademas de otras
+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 "arbol de trabajo".
+Un repositorio esta compuesto por la carpeta .git y un "árbol de trabajo".
 
 ### Directorio .git (componentes del repositorio)
 
@@ -62,38 +62,38 @@ y mas.
 
 ### Directorio de trabajo (componentes del repositorio)
 
-Es basicamente los directorios y archivos dentro del repositorio. La mayorioa de
+Es basicamente los directorios y archivos dentro del repositorio. La mayoría de
 las veces se le llama "directorio de trabajo".
 
-### Inidice (componentes del directorio .git)
+### �ndice (componentes del directorio .git)
 
-El inidice es la area de inicio en git. Es basicamente la capa que separa el
+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
-mas poder sobre lo que envia y recibe en el repositorio.
+mas poder sobre lo que envía y recibe en el 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 remueven 2,
-estos cambios se almacenaran en un commit (aka: captura). Este commit puede ser o
+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 ultimo commit (cambio
-registrado) que se ha realizado. A medida que se realizan mas commits, este
-apuntador se actualizara automaticamente hacia el ultimo commit.
+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" (component of .git dir)
 
 "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 numero de
+cualquier commit realizado, un repositorio puede tener cualquier número de
 "heads".
 
 ### conceptos - recursos.
 
-* [Git para informaticos](http://eagain.net/articles/git-for-computer-scientists/)
+* [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)
 
 
@@ -102,8 +102,8 @@ cualquier commit realizado, un repositorio puede tener cualquier numero de
 
 ### init
 
-Crear un repositorio de git vacio. Las configuraciones, informacion almacenada y
-demas son almacenadas en el directorio ".git".
+Crear un repositorio de git vacio. Las configuraciones, información almacenada y
+demás son almacenadas en el directorio ".git".
 
 ```bash
 $ git init
@@ -127,7 +127,7 @@ $ git config --global user.name "nombre"
 
 ### help
 
-Otorga un accceso rapido a una guia extremadamente detallada de cada comando en
+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
@@ -146,7 +146,7 @@ $ git help init
 
 ### status
 
-Muestra las diferencias entre el archivo indice y el commit al cual apunta el
+Muestra las diferencias entre el archivo índice y el commit al cual apunta el
 HEAD actualmente.
 
 
@@ -163,7 +163,7 @@ $ git help status
 
 Para añadir archivos al arbol (directorio, repositorio) de trabajo. Si no se
 utiliza `git add`, los nuevos archivos no se añadiran al arbol de trabajo, por
-lo que no se incluiran en los commits (cambios).
+lo que no se incluirán en los commits (cambios).
 
 ```bash
 # Añade un archivo en el directorio de trabajo actual.
@@ -202,7 +202,7 @@ $ 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 indice, o en un arbol de trabajo especificado.
+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')
@@ -215,8 +215,8 @@ $ git checkout -b jdei
 
 ### clone
 
-Clona, o copia, una repo existente en un nuevo directorio. Tambien añada el
-seguimiento hacia las ramas existentes del repo que ha sido clonada, lo que
+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
@@ -226,8 +226,8 @@ $ git clone https://github.com/jquery/jquery.git
 
 ### commit
 
-Almacena los cambios que almacenados en el indice en un nuevo "commit". Este
-commit contiene los cambios hechos mas un resumen hecho por el desarrollador.
+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
 # commit with a message
@@ -237,8 +237,8 @@ $ git commit -m "jedi anakin wil be - jedis.list"
 
 ### diff
 
-Muestra las diferencias entre un archivo en el directorio de trabajo, el indice
-y commits.
+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 indice.
@@ -253,7 +253,7 @@ $ git diff HEAD
 
 ### grep
 
-Permite realizar una busqueda rapida en un repositorio.
+Permite realizar una busqueda rápida en un repositorio.
 
 Configuracion opcionales:
 
-- 
cgit v1.2.3


From 8aec122beaffc6d7d8e108aa4bbe4a2218062a46 Mon Sep 17 00:00:00 2001
From: Jesus Tinoco <JesusTinoco@users.noreply.github.com>
Date: Sun, 4 Oct 2015 13:19:34 +0200
Subject: Typos fixed in git-es.html.markdown

---
 es-es/git-es.html.markdown | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'es-es')

diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
index f370aa4d..51812447 100644
--- a/es-es/git-es.html.markdown
+++ b/es-es/git-es.html.markdown
@@ -11,7 +11,7 @@ lang: es-es
 ---
 
 Git es un sistema de control de versiones distribuido diseñado para manejar
-cualquier tipo de proyect,o ya sea largo o pequeño, con velocidad y eficiencia.
+cualquier tipo de proyecto, ya sea largo o pequeño, con velocidad y eficiencia.
 
 Git realiza esto haciendo "snapshots" del proyecto, con ello permite
 versionar y administrar nuestro código fuente.
-- 
cgit v1.2.3


From 0a3bdcd6a5864bdfb6641f883d3f3e2f4545548c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ale=20Mu=C3=B1oz?= <bomberstudios@gmail.com>
Date: Mon, 5 Oct 2015 11:50:44 +0200
Subject: Fixed some typos

---
 es-es/git-es.html.markdown | 108 ++++++++++++++++++++++-----------------------
 1 file changed, 53 insertions(+), 55 deletions(-)

(limited to 'es-es')

diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
index 51812447..18b544b4 100644
--- a/es-es/git-es.html.markdown
+++ b/es-es/git-es.html.markdown
@@ -11,7 +11,7 @@ lang: es-es
 ---
 
 Git es un sistema de control de versiones distribuido diseñado para manejar
-cualquier tipo de proyecto, ya sea largo o pequeño, con velocidad y eficiencia.
+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.
@@ -36,8 +36,8 @@ uno o varios archivos, a lo largo del tiempo.
 ### Por qué usar Git?
 
 * Se puede trabajar sin conexion.
-* Colaborar con otros es sencillo!.
-* Derivar, Crear ramas del proyecto (aka: Branching) es fácil!.
+* ¡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.
@@ -48,7 +48,7 @@ uno o varios archivos, a lo largo del tiempo.
 
 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
+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".
@@ -68,13 +68,13 @@ 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
-mas poder sobre lo que envía y recibe en el repositorio.
+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 remueven 2,
+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.
 
@@ -84,7 +84,7 @@ 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" (component of .git dir)
+### "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
@@ -115,7 +115,7 @@ Se utiliza para configurar las opciones ya sea globalmente, o solamente en el
 repositorio.
 
 ```bash
-# Imprime y guarda algunas variables de configuracion basicas. (Globalmente)
+# Imprime y guarda algunas variables de configuracion básicas. (Globalmente)
 $ git config --global user.email
 $ git config --global user.name
 
@@ -123,7 +123,7 @@ $ git config --global user.email "corre@gmail.com"
 $ git config --global user.name "nombre"
 ```
 
-[Mas sobre git config.](http://git-scm.com/book/es/Personalizando-Git-Configuración-de-Git)
+[Más sobre git config.](http://git-scm.com/book/es/Personalizando-Git-Configuración-de-Git)
 
 ### help
 
@@ -131,7 +131,7 @@ Otorga un accceso rápido a una guía extremadamente detallada de cada comando e
 git. O puede ser usada simplemente como un recordatorio de estos.
 
 ```bash
-# Una vista rapido de los comandos disponibles.
+# Una vista rápida de los comandos disponibles.
 $ git help
 
 # Chequear todos los comandos disponibles
@@ -151,7 +151,7 @@ HEAD actualmente.
 
 
 ```bash
-# Mostrara el "branch", archivos sin añadir a la repo, cambios y otras
+# Mostrará el "branch", archivos sin añadir al repo, cambios y otras
 # diferencias
 $ git status
 
@@ -161,8 +161,8 @@ $ git help status
 
 ### add
 
-Para añadir archivos al arbol (directorio, repositorio) de trabajo. Si no se
-utiliza `git add`, los nuevos archivos no se añadiran al arbol de trabajo, por
+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
@@ -178,24 +178,24 @@ $ git add ./*.py
 
 ### branch
 
-Administra las ramas del repositorios ("branches"). Puedes ver, editar, crear y
+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ñada una nueva rama ("branch").
+# Añadir una nueva rama ("branch").
 $ git branch branchNueva
 
 # Eliminar una rama.
 $ git branch -d branchFoo
 
-# Renombra una rama.
+# Renombrar una rama.
 # git branch -m <anterior> <nuevo>
 $ git branch -m youngling padawan
 
-# Edita la descripcion de la rama.
+# Editar la descripcion de la rama.
 $ git branch master --edit-description
 ```
 
@@ -230,7 +230,6 @@ 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
-# commit with a message
 # realizar un commit y añadirle un mensaje.
 $ git commit -m "jedi anakin wil be - jedis.list"
 ```
@@ -241,13 +240,13 @@ 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 indice.
+# Muestra la diferencia entre un directorio de trabajo y el índice.
 $ git diff
 
-# Muestra la diferencia entre el indice y los commits mas recientes.
+# 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 mas reciente.
+# Muestra la diferencia entre el directorio de trabajo y el commit más reciente.
 $ git diff HEAD
 ```
 
@@ -255,31 +254,32 @@ $ git diff HEAD
 
 Permite realizar una busqueda rápida en un repositorio.
 
-Configuracion opcionales:
+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 busqueda mas lejible, incluyendo agrupacion.
+# 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
+# Busca por "unaVariable" en todos los archivos .java
 $ git grep 'unaVariable' -- '*.java'
 
-# Busca por una linea que contenga "nombreArreglo" y , "agregar" o "remover"
+# Busca por una línea que contenga "nombreArreglo" y "agregar" o "remover"
 $ git grep -e 'nombreArreglo' --and \( -e agregar -e remover \)
 ```
 
-Mas ejemplos:
-[Git Grep Ninja](http://travisjeffery.com/b/2012/02/search-a-git-repo-like-a-ninja)
+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 repositotrio.
+Muestra los commits (cambios) registrados en el repositorio.
 
 ```bash
 # Muestra todos los commits.
@@ -288,7 +288,7 @@ $ git log
 # Muestra un numero x de commits.
 $ git log -n 10
 
-# Muestra solo los commits que se han combinado en el hisotrial
+# Muestra solo los commits que se han combinado en el historial.
 $ git log --merges
 ```
 
@@ -301,7 +301,7 @@ que se trabaja.
 # Combina la rama especificada en la rama actual.
 $ git merge jediMaster
 
-# Siempre genere un solo merge commit cuando se utilizar merge.
+# Siempre genere un solo merge commit cuando se utiliza merge.
 $ git merge --no-ff jediMaster
 ```
 
@@ -310,7 +310,7 @@ $ git merge --no-ff jediMaster
 Renombra o mueve un archivo
 
 ```bash
-# Renombrando un archivo
+# Renombrando un archivo.
 $ git mv HolaMundo.c AdiosMundo.c
 
 # Moviendo un archivo.
@@ -322,33 +322,31 @@ $ git mv -f archivoA archivoB
 
 ### pull
 
-Sube (Empuja) de un repositorio y lo combina en otro en una rama diferente.
+Trae los cambios de un repositorio y los combina en otro en una rama diferente.
 
 ```bash
-# Actualiza el repositorio local, combinando los nuevos cambios.
+# Actualiza el repositorio local, combinando los nuevos cambios
 # de las ramas remotas "origin" y "master".
-# from the remote "origin" and "master" branch.
 # git pull <remota> <rama>
 $ git pull origin master
 ```
 
 ### push
 
-Push and merge changes from a branch to a remote & branch.
+Envía y combina los cambios de un repositorio local a un repositorio y rama remotos.
 
 ```bash
-# Push and merge changes from a local repo to a
-# Empuja y combina cambios de un repositorio local hacian un repositorio remoto
+# 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 publico*
+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"
@@ -356,47 +354,47 @@ de otra rama.
 $ git rebase master experimentBranch
 ```
 
-[Informacion adicional.](http://git-scm.com/book/es/Ramificaciones-en-Git-Procedimientos-básicos-para-ramificar-y-fusionar)
+[Información adicional.](http://git-scm.com/book/es/Ramificaciones-en-Git-Procedimientos-básicos-para-ramificar-y-fusionar)
 
-### reset (precaucion)
+### reset (precaución)
 
-Reinicia el cabezal actual hacia un estado especificado. Esto permite desacer
-combinaciones (merges), pulls, commits, adds y mas. Es un comando util, pero
-tambien peligrosa si no se sabe lo que se hace.
+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
-# Reinica el area principal, con el ultimo cambio registrado. (deja los
+# Reinicia el área principal, con el último cambio registrado. (deja los
 # directorios sin cambios)
 $ git reset
 
-# Reinica el area principal, con el ultimo cambio registrado, y reescribe el
+# 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 aun existen el directorio.
+# directorios), todos los cambios aún existen el directorio.
 $ git reset 31f2bb1
 
-# Mueve la rama actual devuelta a un commit especificado asi como el
-# directorios (borra todos los cambios que no fueron registros y todos los
-# cambios realizados despues del commit especificado).
+# 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 remueve los archivos del directorio de trabajo
+Lo contrario de git add, git rm elimina los archivos del directorio de trabajo
 actual.
 
 ```bash
-# Remueve FooBar.c
+# Elimina FooBar.c
 $ git rm FooBar.c
 
-# Remueve un archivo de un directorio.
+# Elimina un archivo de un directorio.
 $ git rm /directorio/del/archivo/FooBar.c
 ```
 
-## Informacion Adicional
+## Información Adicional
 
 * [tryGit - Una forma entretenida y rapida de aprender Git.](http://try.github.io/levels/1/challenges/1)
 
-- 
cgit v1.2.3


From e848adf9d53e8af5863497438753d704d30f7c5c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gerson=20L=C3=A1zaro?= <gersonlazaro@gersonlazaro.com>
Date: Mon, 5 Oct 2015 15:20:35 -0500
Subject: Fix for issue #1248 [fa-ir, zh-cn, ko-kr, es-es, ru-ru, fr-fr, de-de]

---
 es-es/javascript-es.html.markdown | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'es-es')

diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
index fd01e7b9..036d7082 100644
--- a/es-es/javascript-es.html.markdown
+++ b/es-es/javascript-es.html.markdown
@@ -478,9 +478,6 @@ miNumero === miNumeroObjeyo; // = false
 if (0){
     // Este código no se ejecutara porque 0 es false.
 }
-if (Number(0)){
-    // Este código sí se ejecutara, puesto que Number(0) es true.
-}
 
 // Aún así, los objetos que envuelven y los prototipos por defecto comparten
 // un prototipo. así que puedes agregar funcionalidades a un string de la 
-- 
cgit v1.2.3