22 files changed, 1675 insertions, 702 deletions

diff --git a/es-es/amd-es.html.markdown b/es-es/amd-es.html.markdown
index 40aa6647..83c705c3 100644
--- a/es-es/amd-es.html.markdown
+++ b/es-es/amd-es.html.markdown
@@ -16,6 +16,7 @@ lang: es-es
 El API del **Módulo de Definición Asíncrono** especifica un mecanismo para definir módulos JavaScript de manera tal que tanto el módulo como sus dependencias puedan ser cargadas de manera asíncrona. Esto es particularmente adecuado para el entorno del navegador donde la carga sincronizada de los módulos genera problemas de rendimiento, usabilidad, depuración y acceso de multi-dominios.
 
 ### Conceptos básicos
+
 ```javascript
 // El API básico de AMD consiste en tan solo dos métodos: `define` y `require`
 // y se basa en la definición y consumo de los módulos:
@@ -137,6 +138,7 @@ require(['jquery', 'coolLibFromBower', 'modules/someHelpers'], function($, coolL
   coolLib.doFancyStuffWith(helpers.transform($('#foo')));
 });
 ```
+
 Las aplicaciones basadas en `require.js` usualmente tendrán un solo punto de entrada (`main.js`) que se pasa a la etiqueta del script `require.js` como un atributo de datos. Será cargado y ejecutado automáticamente al cargar la página:
 
 ```html
@@ -158,16 +160,19 @@ Muchas personas prefieren usar AMD para la organización del código durante el
 `require.js` incluye un script llamado `r.js` (el que probablemente correrás en node.js, aunque Rhino también es soportado) que puede analizar el gráfico de dependencias de tu proyecto, y armar un solo fichero que contenga todos tus módulos (adecuadamente nombrados), minificado y listo para consumo.
 
 Instálalo usando `npm`:
+
 ```shell
 $ npm install requirejs -g
 ```
 
 Ahora puedes alimentarlo con un fichero de configuración:
+
 ```shell
 $ r.js -o app.build.js
 ```
 
 Para nuestro ejemplo anterior el archivo de configuración luciría así:
+
 ```javascript
 /* file : app.build.js */
 ({
@@ -184,6 +189,7 @@ Para nuestro ejemplo anterior el archivo de configuración luciría así:
 ```
 
 Para usar el fichero creado en producción, simplemente intercambia `data-main`:
+
 ```html
 <script src="require.js" data-main="app/main-built"></script>
 ```
diff --git a/es-es/asciidoc-es.html.markdown b/es-es/asciidoc-es.html.markdown
index 6e357915..31406ee1 100644
--- a/es-es/asciidoc-es.html.markdown
+++ b/es-es/asciidoc-es.html.markdown
@@ -5,7 +5,7 @@ contributors:
 translators:
     - ["Abel Salgado Romero", "https://twitter.com/abelsromero"]
 lang: es-es
-filename: asciidoc-es.md
+filename: asciidoc-es.adoc
 ---
 
 AsciiDoc es un lenguaje de marcas similar a Markdown que puede ser usado para cualquier uso, desde libros a blogs.
diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown
index 725dae1d..1ee12956 100644
--- a/es-es/awk-es.html.markdown
+++ b/es-es/awk-es.html.markdown
@@ -196,7 +196,7 @@ function string_functions(    localvar, arr) {
     # Ambas regresan el número de matches remplazados.
     localvar = "fooooobar"
     sub("fo+", "Meet me at the ", localvar) # localvar => "Meet me at the bar"
-    gsub("e", ".", localvar) # localvar => "m..t m. at th. bar"
+    gsub("e", ".", localvar) # localvar => "M..t m. at th. bar"
 
     # Buscar una cadena que haga match con una expresión regular
     # index() hace lo mismo, pero no permite expresiones regulares
diff --git a/es-es/chapel-es.html.markdown b/es-es/chapel-es.html.markdown
new file mode 100644
index 00000000..732ee298
--- /dev/null
+++ b/es-es/chapel-es.html.markdown
@@ -0,0 +1,1219 @@
+---
+language: chapel
+filename: learnchapel.chpl
+contributors:
+    - ["Ian J. Bertolacci", "https://www.cs.arizona.edu/~ianbertolacci/"]
+    - ["Ben Harshbarger", "https://github.com/benharsh/"]
+translators:
+    - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+---
+
+Puede leer todo sobre Chapel en [el sitio web oficial de Chapel de Cray](https://chapel-lang.org).
+En resumen, Chapel es un lenguaje de programación paralela, código abierto, de alta productividad
+desarrolladp en Cray Inc. y está diseñado para ejecutarse en PC multi-nucleos, 
+así como en supercomputadoras multi-kilocore.
+
+
+Puede encontrar más información y asistencia al final de este documento.
+
+```chapel
+// Los comentarios son de estilo de la familia C
+
+// comentario de una línea
+/*
+ comentario de múltiples lineas
+*/
+
+// Impresión básica
+
+write("Hola, ");
+writeln("Mundo!");
+
+// write y writeln pueden tomar una lista de cosas para imprimir.
+// Cada cosa está impresa justo al lado de las demás, ¡así que incluye espacios!
+writeln("hay ", 3, " comas (\",\") en esta línea de código");
+
+// Diferentes canales de salida:
+stdout.writeln("Esto va a la salida estándar, al igual que lo hace writeln()");
+stderr.writeln("Esto va al error estándar");
+
+
+// Las variables no tienen que escribirse explícitamente 
+// mientras el compilador pueda determinar el tipo que contendrá.
+
+// 10 es un entero, asi que myVar es explícitamente un entero
+var myVar = 10;
+myVar = -10;
+var mySecondVar = myVar;
+// var anError; sería un error en tiempo de compilación
+
+// Podemos (y debemos) escribir cosas explícitamente.
+var myThirdVar: real;
+var myFourthVar: real = -1.234;
+myThirdVar = myFourthVar;
+
+// Tipos
+
+// Hay varios tipos básicos.
+var myInt: int = -1000; // Enteros firmados
+var myUint: uint = 1234; // Enteros sin-firmar
+var myReal: real = 9.876; // Números de punto flotante
+var myImag: imag = 5.0i; // Números imaginarios
+var myCplx: complex = 10 + 9i; // Números complejos
+myCplx = myInt + myImag; // Otra manera de formar números complejos
+var myBool: bool = false; // Booleanos
+var myStr: string = "Una cadena..."; // Cadenas
+var singleQuoteStr = 'Otra cadena...'; // Cadena literal con comillas simples
+
+// Algunos tipos pueden tener tamaños.
+var my8Int: int(8) = 10; // Entero de 8 bit (one byte);
+var my64Real: real(64) = 1.516; // Real de 64 bit (8 bytes)
+
+// Conversion de tipos.
+var intFromReal = myReal : int;
+var intFromReal2: int = myReal : int;
+
+// Alias de tipo.
+type chroma = int;        // Tipo de un solo tono
+type RGBColor = 3*chroma; // Tipo que representa un color completo
+var black: RGBColor = (0,0,0);
+var white: RGBColor = (255, 255, 255);
+
+// Constantes y Parámetros
+
+// una variable const es una constante y no se puede cambiar después de
+// establecerla en tiempo de ejecución.
+const almostPi: real = 22.0/7.0;
+
+// Un parámetro es una constante cuyo valor debe conocerse estáticamente 
+// en tiempo de compilación.
+
+param compileTimeConst: int = 16;
+
+// El modificador de configuración permite establecer valores en la línea de comando.
+// Establece valores con --varCmdLineArg=Value o --varCmdLineArg Value en tiempo de ejecución.
+config var varCmdLineArg: int = -123;
+config const constCmdLineArg: int = 777;
+
+// config param se puede configurar en tiempo de compilación.
+// Establece valores con --set paramCmdLineArg=value  en tiempo de compilación.
+config param paramCmdLineArg: bool = false;
+writeln(varCmdLineArg, ", ", constCmdLineArg, ", ", paramCmdLineArg);
+
+// Referencias
+
+// ref funciona de manera muy similar a una referencia en C ++. En Chapel, 
+// no se puede hacer una referencia como alias a una variable distinta 
+// de la variable con la que se inicializa.
+
+// Aquí, refToActual se refiere a actual.
+var actual = 10;
+ref refToActual = actual;
+writeln(actual, " == ", refToActual); // imprime el mismo valor
+actual = -123; // modificar actual (a lo que refToActual se refiere)
+writeln(actual, " == ", refToActual); // imprime el mismo valor
+refToActual = 99999999; //  modificar a qué se refiere refToActual (que es actual)
+writeln(actual, " == ", refToActual); // imprime el mismo valor
+
+// Operadores
+
+// Operadores matemáticos:
+var a: int, thisInt = 1234, thatInt = 5678;
+a = thisInt + thatInt;  // Adicción
+a = thisInt * thatInt;  // Multiplicación
+a = thisInt - thatInt;  // Substracción
+a = thisInt / thatInt;  // División
+a = thisInt ** thatInt; // Exponenciación
+a = thisInt % thatInt;  // residuo (módulo)
+
+// Operadores logicos:
+var b: bool, thisBool = false, thatBool = true;
+b = thisBool && thatBool; // Lógico y
+b = thisBool || thatBool; // Lógico o
+b = !thisBool;            // Lógico negación
+
+// Operadores relacionales:
+b = thisInt > thatInt;           // Mas grande que
+b = thisInt >= thatInt;          // Mas grande o igual que
+b = thisInt < a && a <= thatInt; // Menor que, y, Menor o igual que
+b = thisInt != thatInt;          // No es igual a
+b = thisInt == thatInt;          // es igual a
+
+// Operadores bit a bit:
+a = thisInt << 10;     // Desplazamiento de bit izquierdo por 10 bits;
+a = thatInt >> 5;      // Desplazamiento de bit derecho por 5 bits;
+a = ~thisInt;          // Negación bit a bit
+a = thisInt ^ thatInt; // bit a bit exclusivo o
+
+// Operadores de asignación compuesta:
+a += thisInt;          // Adición-igual (a = a + thisInt;)
+a *= thatInt;          // Multiplicación-igual (a = a * thatInt;)
+b &&= thatBool;        // Lógico e igual (b = b && thatBool;)
+a <<= 3;               // Desplazamiento a la izquierda igual (a = a << 10;)
+
+// A diferencia de otros lenguajes de familia C, no hay operadores de 
+// pre / post-incremento / decremento, tales como:
+//
+// ++j, --j, j++, j--
+
+// Operador de intercambio:
+var old_this = thisInt;
+var old_that = thatInt;
+thisInt <=> thatInt; // Intercambia los valores de thisInt y thatInt
+writeln((old_this == thatInt) && (old_that == thisInt));
+
+// También se pueden definir sobrecargas del operador, como veremos con los procedimientos.
+
+// Tuplas
+
+// Las tuplas pueden ser del mismo tipo o de diferentes tipos.
+var sameTup: 2*int = (10, -1);
+var sameTup2 = (11, -6);
+var diffTup: (int,real,complex) = (5, 1.928, myCplx);
+var diffTupe2 = (7, 5.64, 6.0+1.5i);
+
+// Se puede acceder a las tuplas usando corchetes o paréntesis,
+// y están indexadas en base 1.
+writeln("(", sameTup[1], ",", sameTup(2), ")");
+writeln(diffTup);
+
+// Las tuplas también se pueden escribir.
+diffTup(1) = -1;
+
+// Los valores de tupla se pueden expandir a sus propias variables.
+var (tupInt, tupReal, tupCplx) = diffTup;
+writeln(diffTup == (tupInt, tupReal, tupCplx));
+
+// También son útiles para imprimit una lista de variables, 
+// como es común en la depuración.
+writeln((a,b,thisInt,thatInt,thisBool,thatBool));
+
+// Flujo de control
+
+// if - then - else funciona como cualquier otro lenguaje de la familia C.
+if 10 < 100 then
+  writeln("All is well");
+
+if -1 < 1 then
+  writeln("Continuando creyendo en la realidad");
+else
+  writeln("¡Envia un matemático!, algo está mal");
+
+// Puedes usar paréntesis si lo prefieres.
+if (10 > 100) {
+  writeln("El Universo está roto, Por favor reinicie el universo.");
+}
+
+if a % 2 == 0 {
+  writeln(a, " es par.");
+} else {
+  writeln(a, " es impar.");
+}
+
+if a % 3 == 0 {
+  writeln(a, " es divisible entre 3.");
+} else if a % 3 == 1 {
+  writeln(a, " es divisible entre 3 con un residuo de 1.");
+} else {
+  writeln(b, " es divisible entre 3 con un residuo de 2.");
+}
+
+// Ternario:  if - then - else en una declaración.
+var maximum = if thisInt < thatInt then thatInt else thisInt;
+
+// las declaraciones select son muy parecidas a las declaraciones switch
+// en otros idiomas. Sin embargo, las declaraciones select no caen 
+// en cascada como en C o Java.
+var inputOption = "anOption";
+select inputOption {
+  when "anOption" do writeln("Escoge 'anOption'");
+  when "otherOption" {
+    writeln("Escoge 'otherOption'");
+    writeln("Que tiene un cuerpo");
+  }
+  otherwise {
+    writeln("Cualquier otra entrada");
+    writeln("El caso otherwise no necesita hacerse si el cuerpo es de una línea");
+  }
+}
+
+// Los bucles while y do-while también se comportan como sus contrapartes en C.
+var j: int = 1;
+var jSum: int = 0;
+while (j <= 1000) {
+  jSum += j;
+  j += 1;
+}
+writeln(jSum);
+
+do {
+  jSum += j;
+  j += 1;
+} while (j <= 10000);
+writeln(jSum);
+
+// Los bucles for son muy parecidos a los de Python porque iteran en un rango. 
+// Los rangos (como la expresión 1..10 a continuación) son un objeto de primera clase
+// en Chapel, y como tal pueden almacenarse en variables.
+for i in 1..10 do write(i, ", ");
+writeln();
+
+var iSum: int = 0;
+for i in 1..1000 {
+  iSum += i;
+}
+writeln(iSum);
+
+for x in 1..10 {
+  for y in 1..10 {
+    write((x,y), "\t");
+  }
+  writeln();
+}
+
+// Rangos y Dominios
+
+// Los bucles y matrices utilizan rangos y dominios para definir un conjunto de índices
+// que se pueden iterar. Los rangos son índices enteros unidimensionales, mientras 
+// que los dominios pueden ser multidimensionales y representan índices 
+// de diferentes tipos.
+
+// Son tipos ciudadanos de primera clase y pueden asignarse a variables.
+var range1to10: range = 1..10;  // 1, 2, 3, ..., 10
+var range2to11 = 2..11; // 2, 3, 4, ..., 11
+var rangeThisToThat: range = thisInt..thatInt; // usando variables
+var rangeEmpty: range = 100..-100; // esto es válido pero no contiene índices
+
+// Los rangos pueden ser ilimitados.
+var range1toInf: range(boundedType=BoundedRangeType.boundedLow) = 1.. ; // 1, 2, 3, 4, 5, ...
+var rangeNegInfTo1 = ..1; // ..., -4, -3, -2, -1, 0, 1
+
+// Los rangos se pueden andar (y revertir) utilizando el operador by.
+var range2to10by2: range(stridable=true) = 2..10 by 2; // 2, 4, 6, 8, 10
+var reverse2to10by2 = 2..10 by -2; // 10, 8, 6, 4, 2
+
+var trapRange = 10..1 by -1; // No te dejes engañar, esto sigue siendo un rango vacío
+writeln("Size of range ", trapRange, " = ", trapRange.length);
+
+// Note: range(boundedType= ...) and range(stridable= ...) solo son necesarios 
+// si escribimos explícitamente la variable.
+
+// El punto final de un rango se puede determinar utilizando el operador de conteo (#).
+var rangeCount: range = -5..#12; // intervalo de -5 to 6
+
+// Los operadores pueden ser mixtos.
+var rangeCountBy: range(stridable=true) = -5..#12 by 2; // -5, -3, -1, 1, 3, 5
+writeln(rangeCountBy);
+
+// Se pueden consultar las propiedades del rango.
+// En este ejemplo, imprime el primer índice, el último índice, el número de índices,
+// el paso y si 2 se incluye en el rango.
+writeln((rangeCountBy.first, rangeCountBy.last, rangeCountBy.length,
+           rangeCountBy.stride, rangeCountBy.member(2)));
+
+for i in rangeCountBy {
+  write(i, if i == rangeCountBy.last then "\n" else ", ");
+}
+
+// Los dominios rectangulares se definen usando la misma sintaxis de rango, 
+// pero se requiere que estén delimitados (a diferencia de los rangos).
+var domain1to10: domain(1) = {1..10};        // 1D domain from 1..10;
+var twoDimensions: domain(2) = {-2..2,0..2}; // 2D domain over product of ranges
+var thirdDim: range = 1..16;
+var threeDims: domain(3) = {thirdDim, 1..10, 5..10}; // using a range variable
+
+// Los dominios también pueden ser redimensionados
+var resizedDom = {1..10};
+writeln("antes, resizedDom = ", resizedDom);
+resizedDom = {-10..#10};
+writeln("despues, resizedDom = ", resizedDom);
+
+// Los índices pueden iterarse como tuplas.
+for idx in twoDimensions do
+  write(idx, ", ");
+writeln();
+
+// Estas tuplas también pueden ser deconstruidas.
+for (x,y) in twoDimensions {
+  write("(", x, ", ", y, ")", ", ");
+}
+writeln();
+
+// Los dominios asociativos actúan como conjuntos.
+var stringSet: domain(string); // empty set of strings
+stringSet += "a";
+stringSet += "b";
+stringSet += "c";
+stringSet += "a"; // Redundant add "a"
+stringSet -= "c"; // Remove "c"
+writeln(stringSet.sorted());
+
+// Los dominios asociativos también pueden tener una sintaxis literal
+var intSet = {1, 2, 4, 5, 100};
+
+// Tanto los rangos como los dominios se pueden dividir para producir un rango 
+// o dominio con la intersección de los índices.
+var rangeA = 1.. ; // range from 1 to infinity
+var rangeB =  ..5; // range from negative infinity to 5
+var rangeC = rangeA[rangeB]; // resulting range is 1..5
+writeln((rangeA, rangeB, rangeC));
+
+var domainA = {1..10, 5..20};
+var domainB = {-5..5, 1..10};
+var domainC = domainA[domainB];
+writeln((domainA, domainB, domainC));
+
+// Matrices
+
+// Las matrices son similares a otros lenguajes.
+// Sus tamaños son definidos usndo dominions que repretsenten sus indices.
+var intArray: [1..10] int;
+var intArray2: [{1..10}] int; // equivalent
+
+// Pueden ser accedidos usando brackets o paréntesis
+for i in 1..10 do
+  intArray[i] = -i;
+writeln(intArray);
+
+// No podemos acceder a intArray[0] porque existe fuera del conjunto de índices,
+// {1..10}, que definimos al principio. 
+// intArray [11] es ilegal por la misma razón.
+var realDomain: domain(2) = {1..5,1..7};
+var realArray: [realDomain] real;
+var realArray2: [1..5,1..7] real;   // equivalent
+var realArray3: [{1..5,1..7}] real; // equivalent
+
+for i in 1..5 {
+  for j in realDomain.dim(2) {   // Solo use la segunda dimensión del dominio
+    realArray[i,j] = -1.61803 * i + 0.5 * j;  // Acceso usando la lista de índice
+    var idx: 2*int = (i,j);                   // Nota: 'índice' es una palabra reservada
+    realArray[idx] = - realArray[(i,j)];      // Indice usando tuplas
+  }
+}
+
+// Las matrices tienen dominios como miembros y pueden ser iterados de manera normal.
+for idx in realArray.domain {  // De nuevo, idx es una tupla 2*int
+  realArray[idx] = 1 / realArray[idx[1], idx[2]]; // Acceso por tupla y lista
+}
+
+writeln(realArray);
+
+// Los valores de una matriz también se pueden iterar directamente.
+var rSum: real = 0;
+for value in realArray {
+  rSum += value; // Read a value
+  value = rSum;  // Write a value
+}
+writeln(rSum, "\n", realArray);
+
+// Las matrices asociativas (diccionarios) se pueden crear utilizando dominios asociativos.
+var dictDomain: domain(string) = { "one", "two" };
+var dict: [dictDomain] int = ["one" => 1, "two" => 2];
+dict["three"] = 3; // Adiciona 'three' a 'dictDomain' implícitamente
+for key in dictDomain.sorted() do
+  writeln(dict[key]);
+
+// Las matrices se pueden asignar entre sí de diferentes maneras.
+// Estos arreglos se usarán en el ejemplo.
+
+var thisArray : [0..5] int = [0,1,2,3,4,5];
+var thatArray : [0..5] int;
+
+// Primero, simplemente asigna uno al otro. Esto copia esta matriz en
+// thatArray, en lugar de simplemente crear una referencia. Por lo tanto, modificando
+// thisArray tampoco modifica thatArray.
+thatArray = thisArray;
+thatArray[1] = -1;
+writeln((thisArray, thatArray));
+
+// Asigna un segmento de una matriz a un segmento (del mismo tamaño) en el otro.
+thatArray[4..5] = thisArray[1..2];
+writeln((thisArray, thatArray));
+
+// Las operaciones también se pueden promover para trabajar en arreglos. 
+// 'thisPlusThat' también es una matriz.
+var thisPlusThat = thisArray + thatArray;
+writeln(thisPlusThat);
+
+// Continuando, las matrices y los bucles también pueden ser expresiones, donde 
+// la expresión del cuerpo del bucle es el resultado de cada iteración.
+var arrayFromLoop = for i in 1..10 do i;
+writeln(arrayFromLoop);
+
+// Una expresión puede resultar en nada, como cuando se filtra con una expresión if.
+var evensOrFives = for i in 1..10 do if (i % 2 == 0 || i % 5 == 0) then i;
+
+writeln(arrayFromLoop);
+
+// Las expresiones de matriz también se pueden escribir con una notación de paréntesis.
+// Nota: esta sintaxis utiliza el concepto paralelo forall discutido más adelante.
+var evensOrFivesAgain = [i in 1..10] if (i % 2 == 0 || i % 5 == 0) then i;
+
+// They can also be written over the values of the array.
+arrayFromLoop = [value in arrayFromLoop] value + 1;
+
+
+// Procedimientos
+
+// Los procedimientos de Chapel tienen funciones de sintaxis similares en otros idiomas.
+proc fibonacci(n : int) : int {
+  if n <= 1 then return n;
+  return fibonacci(n-1) + fibonacci(n-2);
+}
+
+// Los parámetros de entrada pueden estar sin tipo para crear un procedimiento genérico.
+proc doublePrint(thing): void {
+  write(thing, " ", thing, "\n");
+}
+
+// Se puede inferir el tipo de retorno, siempre que el compilador pueda resolverlo.
+proc addThree(n) {
+  return n + 3;
+}
+
+doublePrint(addThree(fibonacci(20)));
+
+// También es posible tomar un número variable de parámetros.
+proc maxOf(x ...?k) {
+  // x se refiere a una tupla de un tipo, con k elementos
+  var maximum = x[1];
+  for i in 2..k do maximum = if maximum < x[i] then x[i] else maximum;
+  return maximum;
+}
+writeln(maxOf(1, -10, 189, -9071982, 5, 17, 20001, 42));
+
+// Los procedimientos pueden tener valores de parámetros predeterminados, y
+// los parámetros pueden nombrarse en la llamada, incluso fuera de orden.
+proc defaultsProc(x: int, y: real = 1.2634): (int,real) {
+  return (x,y);
+}
+
+writeln(defaultsProc(10));
+writeln(defaultsProc(x=11));
+writeln(defaultsProc(x=12, y=5.432));
+writeln(defaultsProc(y=9.876, x=13));
+
+// El operador ? se llama operador de consulta y se usa para tomar valores 
+// indeterminados como tuplas o tamaños de matriz y tipos genéricos. 
+// Por ejemplo, tomar matrices como parámetros. 
+
+// El operador de consulta se utiliza para determinar el dominio de A. 
+// Esto es útil para definir el tipo de retorno, aunque no es obligatorio.
+proc invertArray(A: [?D] int): [D] int{
+  for a in A do a = -a;
+  return A;
+}
+
+writeln(invertArray(intArray));
+
+// Podemos consultar el tipo de argumentos a los procedimientos genéricos.
+// Aquí definimos un procedimiento que toma dos argumentos del mismo tipo,
+// pero no definimos cuál es ese tipo.
+proc genericProc(arg1 : ?valueType, arg2 : valueType): void {
+  select(valueType) {
+    when int do writeln(arg1, " and ", arg2, " are ints");
+    when real do writeln(arg1, " and ", arg2, " are reals");
+    otherwise writeln(arg1, " and ", arg2, " are somethings!");
+  }
+}
+
+genericProc(1, 2);
+genericProc(1.2, 2.3);
+genericProc(1.0+2.0i, 3.0+4.0i);
+
+// También podemos imponer una forma de polimorfismo con la cláusula where
+// Esto permite que el compilador decida qué función usar. 
+
+// Nota: Eso significa que toda la información debe conocerse en tiempo de compilación. 
+// El modificador param en el argumento se usa para imponer esta restricción.
+proc whereProc(param N : int): void
+ where (N > 0) {
+  writeln("N is greater than 0");
+}
+
+proc whereProc(param N : int): void
+ where (N < 0) {
+  writeln("N is less than 0");
+}
+
+whereProc(10);
+whereProc(-1);
+
+// whereProc(0) daría lugar a un error del compilador porque no hay funciones
+// que satisfagan la condición de la cláusula where. 
+// Podríamos haber definido un whereProc sin una cláusula where que
+// hubiera servido como captura para todos los demás casos (de los cuales solo hay uno).
+
+// Las cláusulas where también se pueden usar para restringir según el tipo de argumento.
+proc whereType(x: ?t) where t == int {
+  writeln("Inside 'int' version of 'whereType': ", x);
+}
+
+proc whereType(x: ?t) {
+  writeln("Inside general version of 'whereType': ", x);
+}
+
+whereType(42);
+whereType("hello");
+
+// Intenciones
+
+/* Los modificadores de intención en los argumentos transmiten cómo esos argumentos se pasan al procedimiento.
+
+     * in: copia arg adentro, pero no afuera
+     * out: copia arg, pero no dentro
+     * inout: copia arg adentro, copia arg afuera
+     * ref: pasa arg por referencia
+*/
+proc intentsProc(in inarg, out outarg, inout inoutarg, ref refarg) {
+  writeln("Adentro antes: ", (inarg, outarg, inoutarg, refarg));
+  inarg = inarg + 100;
+  outarg = outarg + 100;
+  inoutarg = inoutarg + 100;
+  refarg = refarg + 100;
+  writeln("Adentro después: ", (inarg, outarg, inoutarg, refarg));
+}
+
+var inVar: int = 1;
+var outVar: int = 2;
+var inoutVar: int = 3;
+var refVar: int = 4;
+writeln("Afuera antes: ", (inVar, outVar, inoutVar, refVar));
+intentsProc(inVar, outVar, inoutVar, refVar);
+writeln("Afuera después: ", (inVar, outVar, inoutVar, refVar));
+
+// Del mismo modo, podemos definir intentos en el tipo de retorno. 
+// refElement devuelve una referencia a un elemento de la matriz. Esto tiene más sentido 
+// práctico para los métodos de clase donde las referencias a elementos en una estructura 
+// de datos se devuelven a través de un método o iterador.
+proc refElement(array : [?D] ?T, idx) ref : T {
+  return array[idx];
+}
+
+var myChangingArray : [1..5] int = [1,2,3,4,5];
+writeln(myChangingArray);
+ref refToElem = refElement(myChangingArray, 5); // Almacena una referencia al elemento en variable de referencia
+writeln(refToElem);
+refToElem = -2; // modifica referencia que, a su vez, modifica el valor real en la matriz
+writeln(refToElem);
+writeln(myChangingArray);
+
+// Definiciones del operador
+
+// Chapel permite que los operadores se sobrecarguen.
+// Podemos definir los operadores unarios:
+// + - ! ~
+// y los operadores binarios:
+// + - * / % ** == <= >= < > << >> & | ˆ by
+// += -= *= /= %= **= &= |= ˆ= <<= >>= <=>
+
+// Exclusivo u operador booleano.
+proc ^(left : bool, right : bool): bool {
+  return (left || right) && !(left && right);
+}
+
+writeln(true  ^ true);
+writeln(false ^ true);
+writeln(true  ^ false);
+writeln(false ^ false);
+
+// Define un operador * en cualquiera de los dos tipos que devuelve una tupla de esos tipos.
+proc *(left : ?ltype, right : ?rtype): (ltype, rtype) {
+  writeln("\tIn our '*' overload!");
+  return (left, right);
+}
+
+writeln(1 * "a"); // Utiliza nuestro * operador.
+writeln(1 * 2);   // Utiliza el operador predeterminado *.
+
+//  Note: Podrías romper todo si te descuidas con tus sobrecargas.
+//  Esto aquí lo romperá todo. No lo hagas
+
+/*
+    proc +(left: int, right: int): int {
+      return left - right;
+    }
+*/
+
+// Iteradores
+
+// Los iteradores son hermanas del procedimiento, y casi todo lo relacionado 
+// con los procedimientos también se aplica a los iteradores. Sin embargo, en lugar de 
+// devolver un solo valor, los iteradores pueden generar múltiples valores en un bucle.
+
+// Esto es útil cuando se necesita un conjunto u orden complicado de iteraciones, 
+// ya que permite que el código que define las iteraciones 
+// se separe del cuerpo del bucle.
+iter oddsThenEvens(N: int): int {
+  for i in 1..N by 2 do
+    yield i; // yield values instead of returning.
+  for i in 2..N by 2 do
+    yield i;
+}
+
+for i in oddsThenEvens(10) do write(i, ", ");
+writeln();
+
+// Los iteradores también pueden ceder condicionalmente, cuyo resultado puede ser nada
+iter absolutelyNothing(N): int {
+  for i in 1..N {
+    if N < i { // Always false
+      yield i;     // Yield statement never happens
+    }
+  }
+}
+
+for i in absolutelyNothing(10) {
+  writeln("Woa there! absolutelyNothing yielded ", i);
+}
+
+// Podemos comprimir dos o más iteradores (que tienen el mismo número de iteraciones) 
+// usando zip () para crear un solo iterador comprimido, donde cada iteración 
+// del iterador comprimido produce una tupla de un valor de cada iterador.
+for (positive, negative) in zip(1..5, -5..-1) do
+  writeln((positive, negative));
+
+// La iteración de la cremallera es bastante importante en la asignación de matrices, 
+// segmentos de matrices y expresiones de matriz / bucle.
+var fromThatArray : [1..#5] int = [1,2,3,4,5];
+var toThisArray : [100..#5] int;
+
+// Algunas operaciones de cierre implementan otras operaciones.
+// La primera declaración y el bucle son equivalentes.
+toThisArray = fromThatArray;
+for (i,j) in zip(toThisArray.domain, fromThatArray.domain) {
+  toThisArray[i] = fromThatArray[j];
+}
+
+// Estos dos pedazos también son equivalentes.
+toThisArray = [j in -100..#5] j;
+writeln(toThisArray);
+
+for (i, j) in zip(toThisArray.domain, -100..#5) {
+  toThisArray[i] = j;
+}
+writeln(toThisArray);
+
+/*
+ Esto es muy importante para entender por qué esta declaración 
+ exhibe un error de tiempo de ejecución.
+*/
+
+/*
+  var iterArray : [1..10] int = [i in 1..10] if (i % 2 == 1) then i;
+*/
+
+// Aunque el dominio de la matriz y la expresión de bucle son del mismo tamaño,
+// el cuerpo de la expresión puede considerarse como un iterador.
+// Debido a que los iteradores pueden producir nada, ese iterador produce un número
+// diferente de cosas que el dominio de la matriz o bucle, que no está permitido.
+
+// Clases
+
+// Las clases son similares a las de C ++ y Java, asignadas en el montón.
+class MyClass {
+
+// Variables miembro
+  var memberInt : int;
+  var memberBool : bool = true;
+
+// Inicializador definido explícitamente. 
+// También obtenemos el inicializador generado por el compilador, con un argumento por campo.
+// Tenga en cuenta que pronto no habrá un inicializador generado por el compilador 
+// cuando definamos los inicializadores explícitamente.
+  proc init(val : real) {
+    this.memberInt = ceil(val): int;
+  }
+
+// Desinicializador explícitamente definido.
+// Si no escribiéramos uno, obtendríamos el desinicializador generado por el compilador, 
+// que tiene un cuerpo vacío.
+  proc deinit() {
+    writeln("MyClass deinitializer called ", (this.memberInt, this.memberBool));
+  }
+
+// Métodos de clase.
+  proc setMemberInt(val: int) {
+    this.memberInt = val;
+  }
+
+  proc setMemberBool(val: bool) {
+    this.memberBool = val;
+  }
+
+  proc getMemberInt(): int{
+    return this.memberInt;
+  }
+
+  proc getMemberBool(): bool {
+    return this.memberBool;
+  }
+} // termina MyClass
+
+// Llame al inicializador generado por el compilador, 
+// utilizando el valor predeterminado para memberBool.
+var myObject = new MyClass(10);
+    myObject = new MyClass(memberInt = 10); // Equivalente
+writeln(myObject.getMemberInt());
+
+// Same, but provide a memberBool value explicitly.
+var myDiffObject = new MyClass(-1, true);
+    myDiffObject = new MyClass(memberInt = -1, memberBool = true); // Equivalente
+writeln(myDiffObject);
+
+// Llame al inicializador que escribimos.
+var myOtherObject = new MyClass(1.95);
+    myOtherObject = new MyClass(val = 1.95); // Equivalente
+writeln(myOtherObject.getMemberInt());
+
+// También podemos definir un operador en nuestra clase,
+// pero la definición tiene que estar fuera de la definición de la clase.
+proc +(A : MyClass, B : MyClass) : MyClass {
+  return new MyClass(memberInt = A.getMemberInt() + B.getMemberInt(),
+                      memberBool = A.getMemberBool() || B.getMemberBool());
+}
+
+var plusObject = myObject + myDiffObject;
+writeln(plusObject);
+
+// Destrucción.
+delete myObject;
+delete myDiffObject;
+delete myOtherObject;
+delete plusObject;
+
+// Las clases pueden heredar de una o más clases primarias
+class MyChildClass : MyClass {
+  var memberComplex: complex;
+}
+
+// Aquí hay un ejemplo de clases genéricas.
+class GenericClass {
+  type classType;
+  var classDomain: domain(1);
+  var classArray: [classDomain] classType;
+
+// Constructor explícito.
+  proc GenericClass(type classType, elements : int) {
+    this.classDomain = {1..#elements};
+  }
+
+// Copiar constructor.
+// Nota: Todavía tenemos que poner el tipo como argumento, pero podemos usar
+// el operador de consulta (?) como predeterminado para el tipo del otro objeto. 
+// Además, podemos aprovechar esto para permitir a nuestro constructor de copias 
+// copiar clases de diferentes tipos y emitir sobre la marcha.
+  proc GenericClass(other : GenericClass(?otherType),
+                     type classType = otherType) {
+    this.classDomain = other.classDomain;
+    // Copiar y Convertir
+    for idx in this.classDomain do this[idx] = other[idx] : classType;
+  }
+
+// Defina la notación de corchetes en un objeto GenericClass
+// para que pueda comportarse como una matriz normal
+// i.e. objVar[i] or objVar(i)
+  proc this(i : int) ref : classType {
+    return this.classArray[i];
+  }
+
+// Definir un iterador implícito para que la clase produzca 
+// valores de la matriz a un bucle
+// i.e. for i in objVar do ...
+  iter these() ref : classType {
+    for i in this.classDomain do
+      yield this[i];
+  }
+} // end GenericClass
+
+// Podemos asignar a la matriz de miembros del objeto usando la notación de 
+// corchete que definimos.
+var realList = new GenericClass(real, 10);
+for i in realList.classDomain do realList[i] = i + 1.0;
+
+// Podemos iterar sobre los valores en nuestra lista con el iterador 
+// que definimos.
+for value in realList do write(value, ", ");
+writeln();
+
+// Haga una copia de realList usando el constructor de copias.
+var copyList = new GenericClass(realList);
+for value in copyList do write(value, ", ");
+writeln();
+
+// Haga una copia de realList y cambie el tipo, también utilizando el constructor de copias.
+var copyNewTypeList = new GenericClass(realList, int);
+for value in copyNewTypeList do write(value, ", ");
+writeln();
+
+
+// Módulos
+
+// Los módulos son la forma en que Chapel administra los espacios de nombres.
+// Los archivos que contienen estos módulos no necesitan ser nombrados después
+// de los módulos (como en Java), pero los archivos implícitamente nombran módulos. 
+// Por ejemplo, este archivo nombra implícitamente el módulo learnChapelInYMinutes
+
+module OurModule {
+
+// Podemos usar módulos dentro de otros módulos.
+// Time es uno de los módulos estándar.
+  use Time;
+
+// Usaremos este procedimiento en la sección de paralelismo.
+  proc countdown(seconds: int) {
+    for i in 1..seconds by -1 {
+      writeln(i);
+      sleep(1);
+    }
+  }
+
+// Es posible crear nidos de módulos arbitrariamente profundos.
+// i.e. submódulos de OurModule
+  module ChildModule {
+    proc foo() {
+      writeln("ChildModule.foo()");
+    }
+  }
+
+  module SiblingModule {
+    proc foo() {
+      writeln("SiblingModule.foo()");
+    }
+  }
+} // end OurModule
+
+// Usando OurModule también usa todos los módulos que usa.
+// Como OurModule usa Time, nosotros también usamos Time.
+use OurModule;
+
+// En este punto no hemos usado ChildModule o SiblingModule, por lo que sus símbolos 
+// (es decir, foo) no están disponibles para nosotros. Sin embargo, los nombres de
+// los módulos están disponibles y podemos llamar explícitamente a foo () a través de ellos.
+SiblingModule.foo();
+OurModule.ChildModule.foo();
+
+// Ahora usamos ChildModule, que permite llamadas no calificadas.
+use ChildModule;
+foo();
+
+// Paralelismo
+
+// En otros idiomas, el paralelismo generalmente se realiza con librerias complicadas
+// y extrañas jerarquías de estructura de clases. 
+// Chapel lo tiene directamente en el idioma.
+
+// Podemos declarar un procedimiento principal, pero todo el código anterior
+// a main todavía se ejecuta.
+proc main() {
+
+// Una declaración de inicio hará girar el cuerpo de esa declaración en una nueva tarea.
+// Una declaración de sincronización garantizará que el progreso de la tarea principal 
+// no avance hasta que los hijos hayan sincronizado nuevamente.
+
+  sync {
+    begin { // Inicio del cuerpo de la nueva tarea.
+      var a = 0;
+      for i in 1..1000 do a += 1;
+      writeln("Done: ", a);
+    } // Fin del nuevo cuerpo de tareas
+    writeln("escindió una tarea!");
+  }
+  writeln("De nuevo juntos");
+
+  proc printFibb(n: int) {
+    writeln("fibonacci(",n,") = ", fibonacci(n));
+  }
+
+// Una declaración de cobegin girará cada declaración del cuerpo en una nueva tarea.
+// Observe aquí que las impresiones de cada declaración pueden ocurrir en 
+// cualquier orden.
+  cobegin {
+    printFibb(20); // nueva tarea
+    printFibb(10); // nueva tarea
+    printFibb(5);  // nueva tarea
+    {
+      // Este es un cuerpo de declaración anidado y, por lo tanto, es una 
+      // declaración única para la declaración principal, ejecutada 
+      // por una sola tarea.
+      writeln("esto se ");
+      writeln("ejecuta");
+      writeln("como un todo");
+    }
+  }
+
+// Un bucle coforall creará una nueva tarea para CADA iteración. 
+// Nuevamente vemos que las impresiones suceden en cualquier orden. 
+// NOTA: ¡coforall debe usarse solo para crear tareas! 
+// ¡Usarlo para iterar sobre una estructura es una muy mala idea!
+  var num_tasks = 10; // Number of tasks we want
+  coforall taskID in 1..#num_tasks {
+    writeln("Hola de tarea# ", taskID);
+  }
+
+// los bucles forall son otro bucle paralelo, pero solo crean un número 
+// menor de tareas, específicamente --dataParTasksPerLocale = número de tareas.
+  forall i in 1..100 {
+    write(i, ", ");
+  }
+  writeln();
+
+// Aquí vemos que hay secciones que están en orden, seguidas de una sección 
+// que no seguiría (por ejemplo, 1, 2, 3, 7, 8, 9, 4, 5, 6,). 
+// Esto se debe a que cada tarea está asumiendo un fragmento del rango 1..10
+// (1..3, 4..6 o 7..9) haciendo ese fragmento en serie, pero cada tarea ocurre en paralelo. 
+// Sus resultados pueden depender de su máquina y configuración
+
+// Para los bucles forall y coforall, la ejecución de la tarea principal 
+// no continuará hasta que todos los hijos se sincronicen.
+
+// los bucles forall son particularmente útiles para la iteración paralela sobre matrices.
+// Hagamos un experimento para ver qué tan rápido es un ciclo paralelo.
+
+  use Time; // Importe el módulo Time para usar objetos de Timer
+  var timer: Timer;
+  var myBigArray: [{1..4000,1..4000}] real; // Gran matriz en la que escribiremos
+
+// Experimento en serie:
+  timer.start(); // Iniciar temporizador
+  for (x,y) in myBigArray.domain { // Iteración en serie
+    myBigArray[x,y] = (x:real) / (y:real);
+  }
+  timer.stop(); // Detener temporizador
+  writeln("Serial: ", timer.elapsed()); // Imprimir tiempo transcurrido
+  timer.clear(); // Limpia el temporizador para bucle paralelo
+
+// Experimento Paralelo:
+  timer.start(); // Iniciar temporizador
+  forall (x,y) in myBigArray.domain { // Iteración paralela
+    myBigArray[x,y] = (x:real) / (y:real);
+  }
+  timer.stop(); // Detener temporizador
+  writeln("Parallel: ", timer.elapsed()); // Imprimir tiempo transcurrido
+  timer.clear();
+
+// Puede que hayas notado que (dependiendo de cuántos núcleos tengas)
+// el ciclo paralelo fue más rápido que el ciclo serial.
+
+// La expresión de bucle estilo corchete descrita mucho antes utiliza
+// implícitamente un bucle forall.
+  [val in myBigArray] val = 1 / val; // Operación paralela
+
+// Las variables atómicas, comunes a muchos idiomas, son aquellas cuyas operaciones
+// ocurren sin interrupciones. Por lo tanto, varios subprocesos pueden modificar
+// las variables atómicas y pueden saber que sus valores son seguros. 
+// Las variables atómicas de la capilla pueden ser de tipo bool, int, uint y real.
+  var uranium: atomic int;
+  uranium.write(238);      // escribir atómicamente una variable
+  writeln(uranium.read()); // leer atómicamente una variable
+
+// Las operaciones atómicas se describen como funciones, por lo que puede definir
+// las suyas propias.
+  uranium.sub(3); // restar atómicamente una variable
+  writeln(uranium.read());
+
+  var replaceWith = 239;
+  var was = uranium.exchange(replaceWith);
+  writeln("El uranio era", was, ", pero ahora es ", replaceWith);
+
+  var isEqualTo = 235;
+  if uranium.compareExchange(isEqualTo, replaceWith) {
+    writeln("El uranio era igual a ", isEqualTo,
+             " pero valor reemplazado por", replaceWith);
+  } else {
+    writeln("uranio no era igual a ", isEqualTo,
+             " así que el valor permanece igual... sea lo que sea");
+  }
+
+  sync {
+    begin { // Tarea del lector
+      writeln("Lector: esperando que el uranio sea ", isEqualTo);
+      uranium.waitFor(isEqualTo);
+      writeln("Lector: el uranio fue configurado (por alguien) para ", isEqualTo);
+    }
+
+    begin { // Tarea de escritor
+      writeln("Escritor: establecerá uranio en el valor ", isEqualTo, " en...");
+      countdown(3);
+      uranium.write(isEqualTo);
+    }
+  }
+
+// las variables de sincronización tienen dos estados: vacío y lleno.
+// Si lee una variable vacía o escribe una variable completa, 
+// se espera hasta que la variable esté llena o vacía nuevamente.
+  var someSyncVar$: sync int; // varName$ Es una convención, no una ley.
+  sync {
+    begin { // Tarea del lector
+      writeln("Lector: esperando leer.");
+      var read_sync = someSyncVar$;
+      writeln("Lector: el valor es ", read_sync);
+    }
+
+    begin { // Tarea de escritor
+      writeln("Escritor: escribirá en...");
+      countdown(3);
+      someSyncVar$ = 123;
+    }
+  }
+
+// las variales individuales solo se pueden escribir una vez. 
+// Una lectura en un solo no escrito da como resultado una espera,
+// pero cuando la variable tiene un valor, puede leerse indefinidamente.
+  var someSingleVar$: single int; // varName$ Es una convención, no una ley.
+  sync {
+    begin { // Tarea del lector
+      writeln("Lector: esperando leer.");
+      for i in 1..5 {
+        var read_single = someSingleVar$;
+        writeln("Lector: iteración ", i,", y el valor es ", read_single);
+      }
+    }
+
+    begin { // Tarea de escritor
+      writeln("Escritor: escribirá en ...");
+      countdown(3);
+      someSingleVar$ = 5; // primero y único escrito.
+    }
+  }
+
+// Aquí hay un ejemplo usando atómica y una variable de sincronización 
+// para crear un mutex de cuenta regresiva
+//  (también conocido como multiplexor).
+  var count: atomic int; // nuestro mostrador
+  var lock$: sync bool;   // la cerradura mutex
+
+  count.write(2);       // Solo deje dos tareas a la vez.
+  lock$.writeXF(true);  // Establezca lock$ en completo (desbloqueado)
+  // Nota: el valor en realidad no importa, solo el estado
+  // (completo: desbloqueado / vacio: bloqueado)
+  // Además, writeXF() llena (F) la variable de sincronización independientemente de su estado (X)
+
+  coforall task in 1..#5 { // Generar tareas
+    // Create a barrier
+    do {
+      lock$;                 // Leer lock$ (espera)
+    } while (count.read() < 1); // Sigue esperando hasta que se abra un lugar
+
+    count.sub(1);          //disminuir el contador
+    lock$.writeXF(true); // Establezca lock$ en completo (señal)
+
+    // 'Trabajo' actual
+    writeln("Tarea #", task, " trabajando");
+    sleep(2);
+
+    count.add(1);        // Incrementa el contador
+    lock$.writeXF(true); // Establezca lock$ en completo (señal)
+  }
+
+// Podemos definir las operaciones + * & | ^ && || min max minloc maxloc
+// sobre una matriz completa usando escaneos y reducciones.
+// Las reducciones aplican la operación en toda la matriz
+// y dan como resultado un valor escalar.
+
+  var listOfValues: [1..10] int = [15,57,354,36,45,15,456,8,678,2];
+  var sumOfValues = + reduce listOfValues;
+  var maxValue = max reduce listOfValues; // 'max' da solo el valor máximo
+
+// maxloc proporciona el valor máximo y el índice del valor máximo.
+// Nota: Tenemos que comprimir la matriz y el dominio junto con el iterador zip.
+  var (theMaxValue, idxOfMax) = maxloc reduce zip(listOfValues,
+                                                  listOfValues.domain);
+
+  writeln((sumOfValues, maxValue, idxOfMax, listOfValues[idxOfMax]));
+
+// Los escaneos aplican la operación de forma incremental y devuelven una matriz
+// con los valores de la operación en ese índice a medida que avanza a través
+// de la matriz desde array.domain.low hasta array.domain.high.
+  var runningSumOfValues = + scan listOfValues;
+  var maxScan = max scan listOfValues;
+  writeln(runningSumOfValues);
+  writeln(maxScan);
+} // end main()
+```
+
+¿Para quién es este tutorial?
+-------------------------
+
+Este tutorial es para personas que desean aprender las cuerdas de chapel sin tener
+que escuchar sobre qué mezcla de fibras son las cuerdas, o cómo fueron trenzadas,
+o cómo las configuraciones de trenzas difieren entre sí. No le enseñará cómo
+desarrollar código increíblemente eficaz, y no es exhaustivo.
+Referirse a [especificación de idioma](https://chapel-lang.org/docs/latest/language/spec.html)(en) y
+a [documentación del módulo](https://chapel-lang.org/docs/latest/)(en) para más detalles.
+
+Ocasionalmente, vuelva aquí en el [website de Chapel](https://chapel-lang.org)
+para ver si se han agregado más temas o se han creado más tutoriales.
+
+### Lo que le falta a este tutorial:
+
+ * Exposición de los [módulos estándar](https://chapel-lang.org/docs/latest/modules/standard.html)
+ * Múltiples configuraciones regionales (sistema de memoria distribuida)
+ * Registros
+ * Iteradores paralelos
+
+¡Sus comentarios, preguntas y descubrimientos son importantes para los desarrolladores!
+-----------------------------------------------------------------------
+
+El lenguaje Chapel todavía está en desarrollo activo, por lo que 
+ocasionalmente hay problemas con el rendimiento y 
+las características del lenguaje.
+
+Cuanta más información brinde al equipo de desarrollo de Chapel 
+sobre los problemas que encuentre o las características que le gustaría ver, 
+mejor será el lenguaje.
+
+
+Hay varias formas de interactuar con los desarrolladores:
++ [Chat de Gitter](https://gitter.im/chapel-lang/chapel)
++ [lista de emails de Sourceforge](https://sourceforge.net/p/chapel/mailman)
+
+Si está realmente interesado en el desarrollo del compilador o en contribuir al proyecto,
+[consulte el repositorio maestro de GitHub](https://github.com/chapel-lang/chapel).
+Está bajo el [La licencia Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0).
+
+Instalar el compilador
+-----------------------
+
+[La documentación oficial de Chapel detalla cómo descargar y compilar el compilador de Chapel.](https://chapel-lang.org/docs/usingchapel/QUICKSTART.html)
+
+Chapel se puede construir e instalar en su máquina promedio 'nix (y cygwin). 
+[Descargue la última versión de lanzamiento](https://github.com/chapel-lang/chapel/releases/)
+y es tan fácil como
+
+ 1. `tar -xvf chapel-<VERSION>.tar.gz`
+ 2. `cd chapel-<VERSION>`
+ 3. `source util/setchplenv.bash # or .sh or .csh or .fish`
+ 4. `make`
+ 5. `make check # optional`
+
+You will need to `source util/setchplenv.EXT` from within the Chapel directory
+(`$CHPL_HOME`) every time your terminal starts so it's suggested that you drop
+that command in a script that will get executed on startup (like .bashrc).
+
+Necesitará `source util/setchplenv.EXT` desde el directorio de Chapel (`$CHPL_HOME`)
+cada vez que se inicie su terminal, por lo que se sugiere que suelte ese comando 
+en un script que se ejecutará al inicio (como .bashrc).
+
+Chapel se instala fácilmente con Brew para OS X
+
+ 1. `brew update`
+ 2. `brew install chapel`
+
+Compilando Código
+--------------
+
+Construye como otros compiladores:
+
+`chpl myFile.chpl -o myExe`
+
+Argumentos notables:
+
+ * `--fast`: habilita varias optimizaciones y deshabilita las comprobaciones 
+ de los límites de la matriz Solo debe habilitarse cuando la aplicación es estable.
+ * `--set <Nombre del Symbolo>=<Valor>`: establece el param de configuracion 
+ `<Nombre del Symbolo>` a `<Valor>`en tiempo de compilación.
+ * `--main-module <Nombre del módulo>`: use el procedimiento main() que se encuentra en el módulo
+    `<Nombre del módulo>` como principal del ejecutable.
+ * `--module-dir <Directorio>`: incluye `<Directorio>` en la ruta de búsqueda del módulo.
diff --git a/es-es/clojure-es.html.markdown b/es-es/clojure-es.html.markdown
index 62935ebe..9f25425c 100644
--- a/es-es/clojure-es.html.markdown
+++ b/es-es/clojure-es.html.markdown
@@ -431,7 +431,7 @@ funciones principales (pertenecientes al core):
 [http://clojuredocs.org/quickref](http://clojuredocs.org/quickref)
 
 4Clojure es una genial forma de mejorar tus habilidades con clojure/FP:
-[http://www.4clojure.com/](http://www.4clojure.com/)
+[https://4clojure.oxal.org/](https://4clojure.oxal.org/)
 
 Clojure-doc.org (sí, de verdad) tiene un buen número de artículos con los que
 iniciarse en Clojure: [http://clojure-doc.org](http://clojure-doc.org)
diff --git a/es-es/css-es.html b/es-es/css-es.html
deleted file mode 100644
index 506a9467..00000000
--- a/es-es/css-es.html
+++ /dev/null
@@ -1,327 +0,0 @@
----
-language: css
-contributors:
-    - ["Mohammad Valipour", "https://github.com/mvalipour"]
-    - ["Marco Scannadinari", "https://github.com/marcoms"]
-    - ["Geoffrey Liu", "https://github.com/g-liu"]
-    - ["Connor Shea", "https://github.com/connorshea"]
-    - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
-    - ["Brett Taylor", "https://github.com/glutnix"]
-    - ["Tyler Mumford", "https://tylermumford.com"]
-translators:
-    - ["miky ackerman", "https://github.com/mikyackerman"]
-lang: es-es
-filename: learncss-es.css
----
-
-Paginas web estan contruidas en HTML, lo cual especifica el contenido de una pagina
-CSS(Hoja de Estilos en Cascada) es un lenguaje separado el cual especifica
-la **apariencia** de una pagina.
-
-codigo CSS esta hecho de *reglas* estaticas. Cada regla toma uno o mas *selectores* y da *valores* especificos a un numero de *propiedades* visuales. Esas propiedades estan entonces aplicadas a los elementos indicados en una pagina por los selectores
-
-Esta guia ha sido escrita con CSS 2 en mente, la cual es extendida por una nueva caracterica de CSS 3.
-
-**NOTA:** Debido a que CSS produce resultados visuales, para aprenderlo, necesitas
-Probar todo en un patio de juegos CSS como [dabblet] (http://dabblet.com/).
-El objetivo principal de este artículo es la sintaxis y algunos consejos generales.
-
-## Sintaxis
-
-```css
-/* Los comentarios aparecen dentro  de un diagonal-asterisco, justo como esta linea
-   no hay "comentarios en una linea"; este es el unico estilo de comentario.*/
- 
-
-/* ####################
-   ## SELECTORS
-   #################### */
-
-/* el selector es usado para apuntar a un elemento de la pagina. */
-selector { property: value; /* more properties...*/ }
-
-/*
-Here is an example element:
-
-<div class='class1 class2' id='anID' attr='value' otherAttr='en-us foo bar' />
-*/
-
-/* You can target it using one of its CSS classes */
-.class1 { }
-
-/* or both classes! */
-.class1.class2 { }
-
-/* or its name */
-div { }
-
-/* or its id */
-#anID { }
-
-/* or using the fact that it has an attribute! */
-[attr] { font-size:smaller; }
-
-/* or that the attribute has a specific value */
-[attr='value'] { font-size:smaller; }
-
-/* starts with a value (CSS 3) */
-[attr^='val'] { font-size:smaller; }
-
-/* or ends with a value (CSS 3) */
-[attr$='ue'] { font-size:smaller; }
-
-/* or contains a value in a space-separated list */
-[otherAttr~='foo'] { }
-[otherAttr~='bar'] { }
-
-/* or contains a value in a dash-separated list, e.g., "-" (U+002D) */
-[otherAttr|='en'] { font-size:smaller; }
-
-
-/* You can combine different selectors to create a more focused selector. Don't
-   put spaces between them. */
-div.some-class[attr$='ue'] { }
-
-/* You can select an element which is a child of another element */
-div.some-parent > .class-name { }
-
-/* or a descendant of another element. Children are the direct descendants of
-   their parent element, only one level down the tree. Descendants can be any
-   level down the tree. */
-div.some-parent .class-name { }
-
-/* Warning: the same selector without a space has another meaning.
-   Can you guess what? */
-div.some-parent.class-name { }
-
-/* You may also select an element based on its adjacent sibling */
-.i-am-just-before + .this-element { }
-
-/* or any sibling preceding it */
-.i-am-any-element-before ~ .this-element { }
-
-/* There are some selectors called pseudo classes that can be used to select an
-   element only when it is in a particular state */
-
-/* for example, when the cursor hovers over an element */
-selector:hover { }
-
-/* or a link has been visited */
-selector:visited { }
-
-/* or hasn't been visited */
-selected:link { }
-
-/* or an element is in focus */
-selected:focus { }
-
-/* any element that is the first child of its parent */
-selector:first-child {}
-
-/* any element that is the last child of its parent */
-selector:last-child {}
-
-/* Just like pseudo classes, pseudo elements allow you to style certain parts of
-    a document  */
-
-/* matches a virtual first child of the selected element */
-selector::before {}
-
-/* matches a virtual last child of the selected element */
-selector::after {}
-
-/* At appropriate places, an asterisk may be used as a wildcard to select every
-   element */
-* { } /* all elements */
-.parent * { } /* all descendants */
-.parent > * { } /* all children */
-
-/* ####################
-   ## PROPERTIES
-   #################### */
-
-selector {
-
-    /* Units of length can be absolute or relative. */
-
-    /* Relative units */
-    width: 50%;       /* percentage of parent element width */
-    font-size: 2em;   /* multiples of element's original font-size */
-    font-size: 2rem;  /* or the root element's font-size */
-    font-size: 2vw;   /* multiples of 1% of the viewport's width (CSS 3) */
-    font-size: 2vh;   /* or its height */
-    font-size: 2vmin; /* whichever of a vh or a vw is smaller */
-    font-size: 2vmax; /* or greater */
-
-    /* Absolute units */
-    width: 200px;     /* pixels */
-    font-size: 20pt;  /* points */
-    width: 5cm;       /* centimeters */
-    min-width: 50mm;  /* millimeters */
-    max-width: 5in;   /* inches */
-
-    /* Colors */
-    color: #F6E;                 /* short hex format */
-    color: #FF66EE;              /* long hex format */
-    color: tomato;               /* a named color */
-    color: rgb(255, 255, 255);   /* as rgb values */
-    color: rgb(10%, 20%, 50%);   /* as rgb percentages */
-    color: rgba(255, 0, 0, 0.3); /* as rgba values (CSS 3) Note: 0 <= a <= 1 */
-    color: transparent;          /* equivalent to setting the alpha to 0 */
-    color: hsl(0, 100%, 50%);    /* as hsl percentages (CSS 3) */
-    color: hsla(0, 100%, 50%, 0.3); /* as hsl percentages with alpha */
-
-    /* Borders */
-    border-width:5px;
-    border-style:solid;
-    border-color:red;      /* similar to how background-color is set */
-    border: 5px solid red; /* this is a short hand approach for the same */
-    border-radius:20px;    /* this is a CSS3 property */    
-
-    /* Images as backgrounds of elements */
-    background-image: url(/img-path/img.jpg); /* quotes inside url() optional */
-
-    /* Fonts */
-    font-family: Arial;
-    /* if the font family name has a space, it must be quoted */
-    font-family: "Courier New";
-    /* if the first one is not found, the browser uses the next, and so on */
-    font-family: "Courier New", Trebuchet, Arial, sans-serif;
-}
-```
-
-## Usage
-
-Save a CSS stylesheet with the extension `.css`.
-
-```html
-<!-- You need to include the css file in your page's <head>. This is the
-     recommended method. Refer to http://stackoverflow.com/questions/8284365 -->
-<link rel='stylesheet' type='text/css' href='path/to/style.css'>
-
-<!-- You can also include some CSS inline in your markup. -->
-<style>
-   a { color: purple; }
-</style>
-
-<!-- Or directly set CSS properties on the element. -->
-<div style="border: 1px solid red;">
-</div>
-```
-
-## Precedence or Cascade
-
-An element may be targeted by multiple selectors and may have a property set on
-it in more than once. In these cases, one of the rules takes precedence over
-others. Rules with a more specific selector take precedence over a less specific
-one, and a rule occurring later in the stylesheet overwrites a previous one
-(which also means that if two different linked stylesheets contain rules for an
-element and if the rules are of the same specificity, then order of linking
-would take precedence and the sheet linked latest would govern styling) .
-
-This process is called cascading, hence the name Cascading Style Sheets.
-
-Given the following CSS:
-
-```css
-/* A */
-p.class1[attr='value']
-
-/* B */
-p.class1 { }
-
-/* C */
-p.class2 { }
-
-/* D */
-p { }
-
-/* E */
-p { property: value !important; }
-```
-
-and the following markup:
-
-```html
-<p style='/*F*/ property:value;' class='class1 class2' attr='value'>
-```
-
-The precedence of style is as follows. Remember, the precedence is for each
-**property**, not for the entire block.
-
-* `E` has the highest precedence because of the keyword `!important`. It is
-recommended that you avoid its usage.
-* `F` is next, because it is an inline style.
-* `A` is next, because it is more "specific" than anything else. It has 3
-    specifiers: The name of the element `p`, its class `class1`, an attribute
-    `attr='value'`.
-* `C` is next, even though it has the same specificity as `B`.
-    This is because it appears after `B`.
-* `B` is next.
-* `D` is the last one.
-
-## Media Queries
-
-CSS Media Queries are a feature in CSS 3 which allows you to specify when certain CSS rules should be applied, such as when printed, or when on a screen with certain dimensions or pixel density. They do not add to the selector's specificity.
-
-```css
-/* A rule that will be used on all devices */
-h1 {
-  font-size: 2em;
-  color: white;
-  background-color: black;
-}
-
-/* change the h1 to use less ink on a printer */
-@media print {
-  h1 {
-    color: black;
-    background-color: white;
-  }
-}
-
-/* make the font bigger when shown on a screen at least 480px wide */
-@media screen and (min-width: 480px) {
-  h1 {
-    font-size: 3em;
-    font-weight: normal;
-  }
-}
-```
-
-Media queries can include these features:
-`width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. Most of these features can be prefixed with `min-` or `max-`.
-
-The `resolution` feature is not supported by older devices, instead use `device-pixel-ratio`.
-
-Many smartphones and tablets will attempt to render the page as if it were on a desktop unless you provide a `viewport` meta-tag.
-
-```html
-<head>
-  <meta name="viewport" content="width=device-width; initial-scale=1.0">
-</head>
-```
-
-## Compatibility
-
-Most of the features in CSS 2 (and many in CSS 3) are available across all
-browsers and devices. But it's always good practice to check before using
-a new feature.
-
-## Resources
-
-* [CanIUse](http://caniuse.com) (Detailed compatibility info)
-* [Dabblet](http://dabblet.com/) (CSS playground)
-* [Mozilla Developer Network's CSS documentation](https://developer.mozilla.org/en-US/docs/Web/CSS) (Tutorials and reference)
-* [Codrops' CSS Reference](http://tympanus.net/codrops/css_reference/) (Reference)
-
-## Further Reading
-
-* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
-* [Selecting elements using attributes](https://css-tricks.com/almanac/selectors/a/attribute/)
-* [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)
-* [SASS](http://sass-lang.com/) and [LESS](http://lesscss.org/) for CSS pre-processing
-* [CSS-Tricks](https://css-tricks.com)
-
-
diff --git a/es-es/css-es.html.markdown b/es-es/css-es.html.markdown
index 6395f5fd..506a9467 100644
--- a/es-es/css-es.html.markdown
+++ b/es-es/css-es.html.markdown
@@ -1,253 +1,327 @@
 ---
 language: css
-filename: learncss-es.css
 contributors:
     - ["Mohammad Valipour", "https://github.com/mvalipour"]
     - ["Marco Scannadinari", "https://github.com/marcoms"]
+    - ["Geoffrey Liu", "https://github.com/g-liu"]
+    - ["Connor Shea", "https://github.com/connorshea"]
+    - ["Deepanshu Utkarsh", "https://github.com/duci9y"]
+    - ["Brett Taylor", "https://github.com/glutnix"]
+    - ["Tyler Mumford", "https://tylermumford.com"]
 translators:
-    - ["Daniel Zendejas","https://github.com/DanielZendejas"]
+    - ["miky ackerman", "https://github.com/mikyackerman"]
 lang: es-es
+filename: learncss-es.css
 ---
 
-Tutorial de CSS en español
+Paginas web estan contruidas en HTML, lo cual especifica el contenido de una pagina
+CSS(Hoja de Estilos en Cascada) es un lenguaje separado el cual especifica
+la **apariencia** de una pagina.
 
-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.
+codigo CSS esta hecho de *reglas* estaticas. Cada regla toma uno o mas *selectores* y da *valores* especificos a un numero de *propiedades* visuales. Esas propiedades estan entonces aplicadas a los elementos indicados en una pagina por los selectores
 
-Lo que CSS hace es proveer con una sintaxis que te permite apuntar a distintos 
-elementos HTML y asignarles diferentes propiedades visuales.
+Esta guia ha sido escrita con CSS 2 en mente, la cual es extendida por una nueva caracterica de CSS 3.
 
-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:** Debido a que CSS produce resultados visuales, para aprenderlo, necesitas
+Probar todo en un patio de juegos CSS como [dabblet] (http://dabblet.com/).
+El objetivo principal de este artículo es la sintaxis y algunos consejos generales.
 
-**NOTA:** Como los resultados de CSS son efectos visuales, para aprenderlo, 
-necesitarás probar todo tipo de cosas en ambientes como 
-[dabblet](http://dabblet.com/). Este artículo se enfoca, principalmente, en
-la sintaxis y consejos generales.
+## Sintaxis
 
 ```css
-/* ¡Los comentarios aparecen dentro de diagonal-asterisco, justo como esta línea! */
+/* Los comentarios aparecen dentro  de un diagonal-asterisco, justo como esta linea
+   no hay "comentarios en una linea"; este es el unico estilo de comentario.*/
+ 
 
 /* ####################
-   ## SELECTORES
-   ####################*/
-
-/* Generalmente, la sentencia principal en CSS es muy simple. */
-selector { propiedad: valor; /* más propiedades separados por punto y coma...*/ }
-
-/* El selector es usado para apuntar a (seleccionar) un elemento en la página.
+   ## SELECTORS
+   #################### */
 
-¡Puedes apuntar a todos los elementos en la página con el asterisco! */
-* { color:red; }
+/* el selector es usado para apuntar a un elemento de la pagina. */
+selector { property: value; /* more properties...*/ }
 
 /*
-Dado un elemento como este en la página:
+Here is an example element:
 
-<div class='una-clase clase2' id='unaId' attr='valor' />
+<div class='class1 class2' id='anID' attr='value' otherAttr='en-us foo bar' />
 */
 
-/* puedes seleccionar el <div> por el nombre de su clase */
-.una-clase { }
+/* You can target it using one of its CSS classes */
+.class1 { }
 
-/*¡O por sus dos clases! */
-.una-clase.clase2 { }
+/* or both classes! */
+.class1.class2 { }
 
-/* O por el nombre de su elemento */
+/* or its name */
 div { }
 
-/* O por su Id */
-#unaId { }
+/* or its id */
+#anID { }
 
-/* ¡O por el hecho de que tiene un atributo! */
+/* or using the fact that it has an attribute! */
 [attr] { font-size:smaller; }
 
-/* O por el hecho de que el atributo tiene un valor determinado */
-[attr='valor'] { font-size:smaller; }
+/* or that the attribute has a specific value */
+[attr='value'] { font-size:smaller; }
 
-/* Empieza con un valor ('val' en este caso)*/
+/* starts with a value (CSS 3) */
 [attr^='val'] { font-size:smaller; }
 
-/* O termina con un valor ('or' en este caso) */
-[attr$='or'] { font-size:smaller; }
+/* or ends with a value (CSS 3) */
+[attr$='ue'] { font-size:smaller; }
+
+/* or contains a value in a space-separated list */
+[otherAttr~='foo'] { }
+[otherAttr~='bar'] { }
+
+/* or contains a value in a dash-separated list, e.g., "-" (U+002D) */
+[otherAttr|='en'] { font-size:smaller; }
+
 
-/* O incluso contiene un valor ('lo' en este caso) */
-[attr~='lo'] { font-size:smaller; }
+/* You can combine different selectors to create a more focused selector. Don't
+   put spaces between them. */
+div.some-class[attr$='ue'] { }
 
-/*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'] { }
+/* You can select an element which is a child of another element */
+div.some-parent > .class-name { }
 
-/* También puedes seleccionar un elemento HTML basándote en sus padres*/
+/* or a descendant of another element. Children are the direct descendants of
+   their parent element, only one level down the tree. Descendants can be any
+   level down the tree. */
+div.some-parent .class-name { }
 
-/* Un elemento que es hijo directo de otro elemento (Seleccionado de la forma que
-vimos anteriormente) */
+/* Warning: the same selector without a space has another meaning.
+   Can you guess what? */
+div.some-parent.class-name { }
 
-div.un-padre > .nombre-clase {}
+/* You may also select an element based on its adjacent sibling */
+.i-am-just-before + .this-element { }
 
-/* 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 {}
+/* or any sibling preceding it */
+.i-am-any-element-before ~ .this-element { }
 
-/* advertencia: el mismo selector sin espacio tiene otro significado. ¿Puedes
-identificar la diferencia?*/
+/* There are some selectors called pseudo classes that can be used to select an
+   element only when it is in a particular state */
 
-/* También puedes seleccionar un elemento basado en su hermano inmediato previo*/
-.yo-estoy-antes + .este-elemento { }
+/* for example, when the cursor hovers over an element */
+selector:hover { }
 
-/*o cualquier hermano previo */
-.yo-soy-cualquiera-antes ~ .estes-elemento {}
+/* or a link has been visited */
+selector:visited { }
 
-/* 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) */
+/* or hasn't been visited */
+selected:link { }
 
-/* Por ejemplo, para cuando pasas el mouse por encima de un elemento */
-:hover {}
+/* or an element is in focus */
+selected:focus { }
 
-/* o una liga visitada*/
-:visited {}
+/* any element that is the first child of its parent */
+selector:first-child {}
 
-/* o una liga no visitada aún*/
-:link {}
+/* any element that is the last child of its parent */
+selector:last-child {}
 
-/* o un elemento de un formulario que esté seleccionado */
-:focus {}
+/* Just like pseudo classes, pseudo elements allow you to style certain parts of
+    a document  */
 
+/* matches a virtual first child of the selected element */
+selector::before {}
+
+/* matches a virtual last child of the selected element */
+selector::after {}
+
+/* At appropriate places, an asterisk may be used as a wildcard to select every
+   element */
+* { } /* all elements */
+.parent * { } /* all descendants */
+.parent > * { } /* all children */
 
 /* ####################
-   ## PROPIEDADES
-   ####################*/
+   ## PROPERTIES
+   #################### */
 
 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 */
+
+    /* Units of length can be absolute or relative. */
+
+    /* Relative units */
+    width: 50%;       /* percentage of parent element width */
+    font-size: 2em;   /* multiples of element's original font-size */
+    font-size: 2rem;  /* or the root element's font-size */
+    font-size: 2vw;   /* multiples of 1% of the viewport's width (CSS 3) */
+    font-size: 2vh;   /* or its height */
+    font-size: 2vmin; /* whichever of a vh or a vw is smaller */
+    font-size: 2vmax; /* or greater */
+
+    /* Absolute units */
+    width: 200px;     /* pixels */
+    font-size: 20pt;  /* points */
+    width: 5cm;       /* centimeters */
+    min-width: 50mm;  /* millimeters */
+    max-width: 5in;   /* inches */
+
+    /* Colors */
+    color: #F6E;                 /* short hex format */
+    color: #FF66EE;              /* long hex format */
+    color: tomato;               /* a named color */
+    color: rgb(255, 255, 255);   /* as rgb values */
+    color: rgb(10%, 20%, 50%);   /* as rgb percentages */
+    color: rgba(255, 0, 0, 0.3); /* as rgba values (CSS 3) Note: 0 <= a <= 1 */
+    color: transparent;          /* equivalent to setting the alpha to 0 */
+    color: hsl(0, 100%, 50%);    /* as hsl percentages (CSS 3) */
+    color: hsla(0, 100%, 50%, 0.3); /* as hsl percentages with alpha */
+
+    /* Borders */
+    border-width:5px;
+    border-style:solid;
+    border-color:red;      /* similar to how background-color is set */
+    border: 5px solid red; /* this is a short hand approach for the same */
+    border-radius:20px;    /* this is a CSS3 property */    
+
+    /* Images as backgrounds of elements */
+    background-image: url(/img-path/img.jpg); /* quotes inside url() optional */
+
+    /* Fonts */
     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*/
+    /* if the font family name has a space, it must be quoted */
+    font-family: "Courier New";
+    /* if the first one is not found, the browser uses the next, and so on */
+    font-family: "Courier New", Trebuchet, Arial, sans-serif;
 }
-
 ```
 
-## Uso
+## Usage
 
-Guarda cualquier CSS que quieras en un archivo con extensión `.css`.
+Save a CSS stylesheet with the extension `.css`.
 
-```xml
-<!-- Necesitas incluir tu archivo CSS en el elemento <head> de tu HTML: -->
-<link rel='stylesheet' type='text/css' href='ruta/archivoDeEstilos.css' />
+```html
+<!-- You need to include the css file in your page's <head>. This is the
+     recommended method. Refer to http://stackoverflow.com/questions/8284365 -->
+<link rel='stylesheet' type='text/css' href='path/to/style.css'>
 
-<!--
-también puedes incluir CSS dentro del archivo HTML. Esta no es una buena práctica
-y debe ser evitada.
--->
+<!-- You can also include some CSS inline in your markup. -->
 <style>
-   selector { propiedad:valor; }
+   a { color: purple; }
 </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;'>
+<!-- Or directly set CSS properties on the element. -->
+<div style="border: 1px solid red;">
 </div>
-
 ```
 
-## Preferencia y orden
+## Precedence or Cascade
+
+An element may be targeted by multiple selectors and may have a property set on
+it in more than once. In these cases, one of the rules takes precedence over
+others. Rules with a more specific selector take precedence over a less specific
+one, and a rule occurring later in the stylesheet overwrites a previous one
+(which also means that if two different linked stylesheets contain rules for an
+element and if the rules are of the same specificity, then order of linking
+would take precedence and the sheet linked latest would govern styling) .
 
-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:
+This process is called cascading, hence the name Cascading Style Sheets.
 
-Dado el siguiente CSS:
+Given the following CSS:
 
 ```css
-/*A*/
-p.clase1[attr='valor']
+/* A */
+p.class1[attr='value']
 
-/*B*/
-p.clase1 {}
+/* B */
+p.class1 { }
 
-/*C*/
-p.clase2 {}
+/* C */
+p.class2 { }
 
-/*D*/
-p {}
+/* D */
+p { }
 
-/*E*/
-p { propiedad: valor !important; }
+/* E */
+p { property: value !important; }
+```
 
+and the following markup:
+
+```html
+<p style='/*F*/ property:value;' class='class1 class2' attr='value'>
 ```
 
-Y el siguiente HTML:
+The precedence of style is as follows. Remember, the precedence is for each
+**property**, not for the entire block.
+
+* `E` has the highest precedence because of the keyword `!important`. It is
+recommended that you avoid its usage.
+* `F` is next, because it is an inline style.
+* `A` is next, because it is more "specific" than anything else. It has 3
+    specifiers: The name of the element `p`, its class `class1`, an attribute
+    `attr='value'`.
+* `C` is next, even though it has the same specificity as `B`.
+    This is because it appears after `B`.
+* `B` is next.
+* `D` is the last one.
+
+## Media Queries
+
+CSS Media Queries are a feature in CSS 3 which allows you to specify when certain CSS rules should be applied, such as when printed, or when on a screen with certain dimensions or pixel density. They do not add to the selector's specificity.
+
+```css
+/* A rule that will be used on all devices */
+h1 {
+  font-size: 2em;
+  color: white;
+  background-color: black;
+}
 
-```xml
-<p style='/*F*/ propiedad:valor;' class='clase1 clase2' attr='valor'>
-</p>
+/* change the h1 to use less ink on a printer */
+@media print {
+  h1 {
+    color: black;
+    background-color: white;
+  }
+}
+
+/* make the font bigger when shown on a screen at least 480px wide */
+@media screen and (min-width: 480px) {
+  h1 {
+    font-size: 3em;
+    font-weight: normal;
+  }
+}
 ```
 
-El orden respetado es el siguiente:  
-Recuerda, la preferencia es por cada **property**, no para el bloque completo.
+Media queries can include these features:
+`width`, `height`, `device-width`, `device-height`, `orientation`, `aspect-ratio`, `device-aspect-ratio`, `color`, `color-index`, `monochrome`, `resolution`, `scan`, `grid`. Most of these features can be prefixed with `min-` or `max-`.
 
-* `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`.
+The `resolution` feature is not supported by older devices, instead use `device-pixel-ratio`.
 
-## Compatibilidad
+Many smartphones and tablets will attempt to render the page as if it were on a desktop unless you provide a `viewport` meta-tag.
 
-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.
+```html
+<head>
+  <meta name="viewport" content="width=device-width; initial-scale=1.0">
+</head>
+```
+
+## Compatibility
 
-[QuirksMode CSS](http://www.quirksmode.org/css/) es una excelente referencia para esto.
+Most of the features in CSS 2 (and many in CSS 3) are available across all
+browsers and devices. But it's always good practice to check before using
+a new feature.
 
-## Recursos
+## Resources
 
-* Para ejecutar un test de compatibilidad, revisa [CanIUse](http://caniuse.com).
-* CSS Playground [Dabblet](http://dabblet.com/).
-* [Mozilla Developer Network's CSS documentation](https://developer.mozilla.org/en-US/docs/Web/CSS).
-* [Codrops' CSS Reference](http://tympanus.net/codrops/css_reference/).
+* [CanIUse](http://caniuse.com) (Detailed compatibility info)
+* [Dabblet](http://dabblet.com/) (CSS playground)
+* [Mozilla Developer Network's CSS documentation](https://developer.mozilla.org/en-US/docs/Web/CSS) (Tutorials and reference)
+* [Codrops' CSS Reference](http://tympanus.net/codrops/css_reference/) (Reference)
 
-## Otras lecturas
+## Further Reading
 
-* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/).
-* [Selecting elements using attributes](https://css-tricks.com/almanac/selectors/a/attribute/).
-* [QuirksMode CSS](http://www.quirksmode.org/css/).
+* [Understanding Style Precedence in CSS: Specificity, Inheritance, and the Cascade](http://www.vanseodesign.com/css/css-specificity-inheritance-cascaade/)
+* [Selecting elements using attributes](https://css-tricks.com/almanac/selectors/a/attribute/)
+* [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)
-* [SASS](http://sass-lang.com/) y [LESS](http://lesscss.org/) para preprocesamiento CSS.
-* [CSS-Tricks](https://css-tricks.com).
+* [SASS](http://sass-lang.com/) and [LESS](http://lesscss.org/) for CSS pre-processing
+* [CSS-Tricks](https://css-tricks.com)
+
 
diff --git a/es-es/docker-es.html.markdown b/es-es/docker-es.html.markdown
index 93e17f02..81e3cefe 100644
--- a/es-es/docker-es.html.markdown
+++ b/es-es/docker-es.html.markdown
@@ -1,167 +1,167 @@
----

-language: docker

-filename: docker-es.bat

-contributors:

-    - ["Ruslan López", "http://javapro.org/"]

-    - ["Michael Chen", "https://github.com/ML-Chen"]

-lang: es-es

----

-

-```bat

-:: descargar, instalar y ejecutar la imágen del hola mundo

-docker run hello-world

-

-:: Si esta es la primera vez, deberíais de poder ver el mensaje

-:: Unable to find image 'hello-world:latest' locally

-:: latest: Pulling from library/hello-world

-:: 1b930d010525: Pull complete                                                                                          

-::   Digest: sha256:4fe721ccc2e8dc7362278a29dc660d833570ec2682f4e4194f4ee23e415e1064

-:: Status: Downloaded newer image for hello-world:latest

-:: 

-:: Hello from Docker!

-:: This message shows that your installation appears to be working correctly.

-:: 

-:: To generate this message, Docker took the following steps:

-:: 1. The Docker client contacted the Docker daemon.

-:: 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.

-::     (amd64)

-:: 3. The Docker daemon created a new container from that image which runs the

-::     executable that produces the output you are currently reading.

-:: 4. The Docker daemon streamed that output to the Docker client, which sent it

-::     to your terminal.

-:: 

-:: To try something more ambitious, you can run an Ubuntu container with:

-::  $ docker run -it ubuntu bash

-:: 

-:: Share images, automate workflows, and more with a free Docker ID:

-::  https://hub.docker.com/

-:: 

-:: For more examples and ideas, visit:

-:: https://docs.docker.com/get-started/

-:: El susodicho mensaje se podría traducir como:

-:: 

-:: Hola desde Docker!

-:: Este mensaje muestra que su instalación parece estar funcionando crrectamente.

-:: 

-:: Para generar este mensaje, Docker realizó los siguientes pasos:

-:: 1. El cliente de Docker contactó a Docker daemon.

-:: 2. El Docker daemon obtubo la imágen "hello-world" desde Docker Hub.

-::     (amd64)

-:: 3. El Docker daemon creó un nuevo contenedor a partir de esa imagen con la cual ejecuta el

-::     ejecutable que produce la salida que estás leyendo.

-:: 4. El Docker daemon transmitió dicha salida el cliente Docker, el cual

-::     la envió a tu terminal.

-:: 

-:: Para intentar algo más ambicioso, puede correr un contenedor Ubuntu mediante:

-::  $ docker run -it ubuntu bash

-:: 

-:: Comparte imágenes, automatice flujos y más con un Docker ID gratuito:

-::  https://hub.docker.com/

-

-:: ahora veamos las imágenes que se están ejecutando actualmente

-docker ps

-:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS            

-::   NAMES

-

-:: veamos las imágenes que hemos ejecutado previamente

-docker ps -a

-

-:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS     

-::          NAMES

-:: 4a76281f9c53        hello-world         "/hello"            2 minutes ago       Exited (0) 2 minutes ago             

-::          happy_poincare

-:: la parte del nombre se genera automáticamente, así que probablemente sea diferente para vos

-

-:: eliminemos nuestra imagen previamente generada

-docker rm happy_poincare

-

-:: verifiquemos si realmente fue borrada

-docker ps -a

-:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS            

-::   NAMES

-

-:: especifiquemos un nombre personalizado para el contenedor

-docker run --name test_container hello-world

-:: Hello from Docker!

-:: This message shows that your installation appears to be working correctly.

-:: 

-:: To generate this message, Docker took the following steps:

-::  1. The Docker client contacted the Docker daemon.

-::  2. The Docker daemon pulled the "hello-world" image from the Docker Hub.

-::     (amd64)

-::  3. The Docker daemon created a new container from that image which runs the

-::     executable that produces the output you are currently reading.

-::  4. The Docker daemon streamed that output to the Docker client, which sent it

-::     to your terminal.

-:: 

-:: To try something more ambitious, you can run an Ubuntu container with:

-:: $ docker run -it ubuntu bash

-:: 

-:: Share images, automate workflows, and more with a free Docker ID:

-::  https://hub.docker.com/

-:: 

-:: For more examples and ideas, visit:

-::  https://docs.docker.com/get-started/

-

-docker ps -a

-:: CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS                         PORTS

-::               NAMES

-:: d345fe1a4f41        hello-world         "/hello"            About a minute ago   Exited (0) About a minute ago       

-::                test_container

-:: tal como podeis ver el nombre es el que especificamos

-

-:: obtener los registros de un contenedor nombrado

-docker logs test_container

-:: Hello from Docker!

-:: This message shows that your installation appears to be working correctly.

-:: 

-:: To generate this message, Docker took the following steps:

-::  1. The Docker client contacted the Docker daemon.

-::  2. The Docker daemon pulled the "hello-world" image from the Docker Hub.

-::     (amd64)

-::  3. The Docker daemon created a new container from that image which runs the

-::     executable that produces the output you are currently reading.

-::  4. The Docker daemon streamed that output to the Docker client, which sent it

-::     to your terminal.

-:: 

-:: To try something more ambitious, you can run an Ubuntu container with:

-:: $ docker run -it ubuntu bash

-:: 

-:: Share images, automate workflows, and more with a free Docker ID:

-::  https://hub.docker.com/

-:: 

-:: For more examples and ideas, visit:

-::  https://docs.docker.com/get-started/

-

-docker rm test_container

-

-docker run ubuntu

-::  Unable to find image 'ubuntu:latest' locally

-::  latest: Pulling from library/ubuntu

-::  2746a4a261c9: Pull complete                                                                                         

-::                                                        4c1d20cdee96: Pull complete                                                                                                                                                 0d3160e1d0de: Pull complete                                                                                                                                                 c8e37668deea: Pull complete                                                                                                                                                 Digest: sha256:250cc6f3f3ffc5cdaa9d8f4946ac79821aafb4d3afc93928f0de9336eba21aa4

-::  Status: Downloaded newer image for ubuntu:latest

-

-docker ps -a

-::  CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS    

-::           NAMES

-::  c19e9e5b000a        ubuntu              "/bin/bash"         5 seconds ago       Exited (0) 4 seconds ago            

-::           relaxed_nobel

-

-::  ejecutando un contenedor en modo interactivo

-docker run -it ubuntu

-::  root@e2cac48323d2:/# uname

-::  Linux

-::  root@e2cac48323d2:/# exit

-::  exit

-

-docker rm relaxed_nobel

-

-docker ps -a

-:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                          PORTS

-::               NAMES

-:: e2cac48323d2        ubuntu              "/bin/bash"         2 minutes ago       Exited (0) About a minute ago        

-::               nifty_goldwasser

-

-docker rm nifty_goldwasser

-```

+---
+language: docker
+filename: docker-es.bat
+contributors:
+    - ["Ruslan López", "http://javapro.org/"]
+    - ["Michael Chen", "https://github.com/ML-Chen"]
+lang: es-es
+---
+
+```bat
+:: descargar, instalar y ejecutar la imágen del hola mundo
+docker run hello-world
+
+:: Si esta es la primera vez, deberíais de poder ver el mensaje
+:: Unable to find image 'hello-world:latest' locally
+:: latest: Pulling from library/hello-world
+:: 1b930d010525: Pull complete                                                                                          
+::   Digest: sha256:4fe721ccc2e8dc7362278a29dc660d833570ec2682f4e4194f4ee23e415e1064
+:: Status: Downloaded newer image for hello-world:latest
+:: 
+:: Hello from Docker!
+:: This message shows that your installation appears to be working correctly.
+:: 
+:: To generate this message, Docker took the following steps:
+:: 1. The Docker client contacted the Docker daemon.
+:: 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
+::     (amd64)
+:: 3. The Docker daemon created a new container from that image which runs the
+::     executable that produces the output you are currently reading.
+:: 4. The Docker daemon streamed that output to the Docker client, which sent it
+::     to your terminal.
+:: 
+:: To try something more ambitious, you can run an Ubuntu container with:
+::  $ docker run -it ubuntu bash
+:: 
+:: Share images, automate workflows, and more with a free Docker ID:
+::  https://hub.docker.com/
+:: 
+:: For more examples and ideas, visit:
+:: https://docs.docker.com/get-started/
+:: El susodicho mensaje se podría traducir como:
+:: 
+:: Hola desde Docker!
+:: Este mensaje muestra que su instalación parece estar funcionando crrectamente.
+:: 
+:: Para generar este mensaje, Docker realizó los siguientes pasos:
+:: 1. El cliente de Docker contactó a Docker daemon.
+:: 2. El Docker daemon obtubo la imágen "hello-world" desde Docker Hub.
+::     (amd64)
+:: 3. El Docker daemon creó un nuevo contenedor a partir de esa imagen con la cual ejecuta el
+::     ejecutable que produce la salida que estás leyendo.
+:: 4. El Docker daemon transmitió dicha salida el cliente Docker, el cual
+::     la envió a tu terminal.
+:: 
+:: Para intentar algo más ambicioso, puede correr un contenedor Ubuntu mediante:
+::  $ docker run -it ubuntu bash
+:: 
+:: Comparte imágenes, automatice flujos y más con un Docker ID gratuito:
+::  https://hub.docker.com/
+
+:: ahora veamos las imágenes que se están ejecutando actualmente
+docker ps
+:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS            
+::   NAMES
+
+:: veamos las imágenes que hemos ejecutado previamente
+docker ps -a
+
+:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS     
+::          NAMES
+:: 4a76281f9c53        hello-world         "/hello"            2 minutes ago       Exited (0) 2 minutes ago             
+::          happy_poincare
+:: la parte del nombre se genera automáticamente, así que probablemente sea diferente para vos
+
+:: eliminemos nuestra imagen previamente generada
+docker rm happy_poincare
+
+:: verifiquemos si realmente fue borrada
+docker ps -a
+:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS            
+::   NAMES
+
+:: especifiquemos un nombre personalizado para el contenedor
+docker run --name test_container hello-world
+:: Hello from Docker!
+:: This message shows that your installation appears to be working correctly.
+:: 
+:: To generate this message, Docker took the following steps:
+::  1. The Docker client contacted the Docker daemon.
+::  2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
+::     (amd64)
+::  3. The Docker daemon created a new container from that image which runs the
+::     executable that produces the output you are currently reading.
+::  4. The Docker daemon streamed that output to the Docker client, which sent it
+::     to your terminal.
+:: 
+:: To try something more ambitious, you can run an Ubuntu container with:
+:: $ docker run -it ubuntu bash
+:: 
+:: Share images, automate workflows, and more with a free Docker ID:
+::  https://hub.docker.com/
+:: 
+:: For more examples and ideas, visit:
+::  https://docs.docker.com/get-started/
+
+docker ps -a
+:: CONTAINER ID        IMAGE               COMMAND             CREATED              STATUS                         PORTS
+::               NAMES
+:: d345fe1a4f41        hello-world         "/hello"            About a minute ago   Exited (0) About a minute ago       
+::                test_container
+:: tal como podeis ver el nombre es el que especificamos
+
+:: obtener los registros de un contenedor nombrado
+docker logs test_container
+:: Hello from Docker!
+:: This message shows that your installation appears to be working correctly.
+:: 
+:: To generate this message, Docker took the following steps:
+::  1. The Docker client contacted the Docker daemon.
+::  2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
+::     (amd64)
+::  3. The Docker daemon created a new container from that image which runs the
+::     executable that produces the output you are currently reading.
+::  4. The Docker daemon streamed that output to the Docker client, which sent it
+::     to your terminal.
+:: 
+:: To try something more ambitious, you can run an Ubuntu container with:
+:: $ docker run -it ubuntu bash
+:: 
+:: Share images, automate workflows, and more with a free Docker ID:
+::  https://hub.docker.com/
+:: 
+:: For more examples and ideas, visit:
+::  https://docs.docker.com/get-started/
+
+docker rm test_container
+
+docker run ubuntu
+::  Unable to find image 'ubuntu:latest' locally
+::  latest: Pulling from library/ubuntu
+::  2746a4a261c9: Pull complete                                                                                         
+::                                                        4c1d20cdee96: Pull complete                                                                                                                                                 0d3160e1d0de: Pull complete                                                                                                                                                 c8e37668deea: Pull complete                                                                                                                                                 Digest: sha256:250cc6f3f3ffc5cdaa9d8f4946ac79821aafb4d3afc93928f0de9336eba21aa4
+::  Status: Downloaded newer image for ubuntu:latest
+
+docker ps -a
+::  CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                     PORTS    
+::           NAMES
+::  c19e9e5b000a        ubuntu              "/bin/bash"         5 seconds ago       Exited (0) 4 seconds ago            
+::           relaxed_nobel
+
+::  ejecutando un contenedor en modo interactivo
+docker run -it ubuntu
+::  root@e2cac48323d2:/# uname
+::  Linux
+::  root@e2cac48323d2:/# exit
+::  exit
+
+docker rm relaxed_nobel
+
+docker ps -a
+:: CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                          PORTS
+::               NAMES
+:: e2cac48323d2        ubuntu              "/bin/bash"         2 minutes ago       Exited (0) About a minute ago        
+::               nifty_goldwasser
+
+docker rm nifty_goldwasser
+```
diff --git a/es-es/elixir-es.html.markdown b/es-es/elixir-es.html.markdown
index 885165a6..37acf6ad 100644
--- a/es-es/elixir-es.html.markdown
+++ b/es-es/elixir-es.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: elixir
+language: Elixir
 contributors:
     - ["Joao Marques", "http://github.com/mrshankly"]
     - ["Dzianis Dashkevich", "https://github.com/dskecse"]
@@ -23,10 +23,10 @@ y otras características más.
 # No hay comentarios multilinea,
 # pero se pueden apilar varios comentarios.
 
-# Para usar el shell de elixir se usa el comando `iex`.
+# Para usar el shell de Elixir se usa el comando `iex`.
 # Los módulos se compilan con el comando `elixirc`.
 
-# Ambos deberían estar en la ruta si elixir se instaló correctamente.
+# Ambos deberían estar en la ruta si Elixir se instaló correctamente.
 
 ## ---------------------------
 ## -- Tipos básicos
@@ -55,7 +55,7 @@ elem({1, 2, 3}, 0) #=> 1
 head #=> 1
 tail #=> [2,3]
 
-# En elixir, solo como Erlang, el `=` denota la coincidencia de patrones y
+# En Elixir, solo como Erlang, el `=` denota la coincidencia de patrones y
 # no una asignación.
 #
 # This is how the above example of accessing the head and tail of a list works.
@@ -87,7 +87,7 @@ string.
 <<?a, ?b, ?c>> #=> "abc"
 [?a, ?b, ?c]   #=> 'abc'
 
-# `?a` en elixir devuelve el valor ASCII para el caracter `a`
+# `?a` en Elixir devuelve el valor ASCII para el caracter `a`
 ?a #=> 97
 
 # Para concatenar listas se usa `++`, para binarios `<>`
@@ -120,7 +120,7 @@ genders.gillian #=> "female"
 5 * 2  #=> 10
 10 / 2 #=> 5.0
 
-# En elixir el operador `/` siempre devuelve un número flotante
+# En Elixir el operador `/` siempre devuelve un número flotante
 
 # Para hacer la división de número entero se debe usar `div`
 div(10, 2) #=> 5
@@ -175,7 +175,7 @@ else
 end
 
 # Se acuerda de la coincidencia de patrones?
-# Muchas estructuras de control de flujo en elixir confían en ella.
+# Muchas estructuras de control de flujo en Elixir confían en ella.
 
 # `case` permite comparar un valor con muchos patrones:
 case {:one, :two} do
@@ -305,7 +305,7 @@ Geometry.area({:circle, 3})       #=> 28.25999999999999801048
 # Geometry.area({:circle, "not_a_number"})
 #=> ** (FunctionClauseError) no function clause matching in Geometry.area/1
 
-# Debido a la inmutabilidad, la recursión es una gran parte de elixir
+# Debido a la inmutabilidad, la recursión es una gran parte de Elixir
 defmodule Recursion do
   def sum_list([head | tail], acc) do
     sum_list(tail, acc + head)
@@ -380,7 +380,7 @@ end
 ## ---------------------------
 
 # Elixir confía en el modelo actor para la concurrencia. Todo lo que se necesita para escribir
-# programas concurrentes en elixir son tres primitivas: procesos de desove,
+# programas concurrentes en Elixir son tres primitivas: procesos de desove,
 # envío de mensajes y recepción de mensajes.
 
 # Para empezar un nuevo proceso se usa la función `spawn`,
diff --git a/es-es/forth-es.html.markdown b/es-es/forth-es.html.markdown
index edc5d38c..61123151 100644
--- a/es-es/forth-es.html.markdown
+++ b/es-es/forth-es.html.markdown
@@ -13,7 +13,7 @@ Forth fue criado por Charles H. Moore en los 70s. Forth es un lenguaje imperativ
 Nota: Este articulo enfoca predominantemente en la Gforth implementación de Forth, pero casi todo 
 de lo que esta escrito aquí debe funcionar en otro sitio.
 
-```
+```forth
 \ Este es un comentario
 ( Este es un comentario también pero solo esta usado cuando definiendo palabras. )
 
diff --git a/es-es/git-es.html.markdown b/es-es/git-es.html.markdown
index dc0dda30..c93584d8 100644
--- a/es-es/git-es.html.markdown
+++ b/es-es/git-es.html.markdown
@@ -414,4 +414,4 @@ $ git rm /directorio/del/archivo/FooBar.c
 
 * [Pro Git](http://www.git-scm.com/book/en/v2)
 
-* [Una introducción a Git y Github para principiantes (Tutorial)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
+* [Una introducción a Git y GitHub para principiantes (Tutorial)](http://product.hubspot.com/blog/git-and-github-tutorial-for-beginners)
diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
index 78267695..17bf4a22 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -88,7 +88,7 @@ saltos de línea.` // mismo tipo cadena
 
 	// Literal no ASCII. Los ficheros fuente de Go son UTF-8.
 	g := 'Σ' // Tipo rune, un alias de int32, alberga un carácter unicode.
-	f := 3.14195 // float64, el estándar IEEE-754 de coma flotante 64-bit.
+	f := 3.14159 // 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
@@ -425,7 +425,7 @@ func consultaAlServidor() {
 ## Más información
 
 La raíz de todas las cosas sobre Go es el
-[sitio web oficial de Go](http://golang.org/).
+[sitio web oficial de Go](https://go.dev/).
 Allí puedes seguir el tutorial, jugar interactivamente y leer mucho más.
 
 La definición del lenguaje es altamente recomendada.  Es fácil de leer y
@@ -433,17 +433,17 @@ sorprendentemente corta (como la definición del lenguaje Go en estos
 días).
 
 Puedes jugar con el código en el
-[parque de diversiones Go](https://play.golang.org/p/ncRC2Zevag).  ¡Trata
+[parque de diversiones Go](https://go.dev/play/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
+utilizar [https://go.dev/play/]( https://go.dev/play/) como un
 [REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) para probar
 cosas y el código en el navegador, sin ni siquiera instalar Go.
 
 En la lista de lecturas para estudiantes de Go está el
-[código fuente de la biblioteca estándar](http://golang.org/src/pkg/). 
+[código fuente de la biblioteca estándar](https://go.dev/src/). 
 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
+nombre de función en [la documentación](https://go.dev/pkg/) y
 aparecerá el código fuente!
 
 Otro gran recurso para aprender Go está en
diff --git a/es-es/julia-es.html.markdown b/es-es/julia-es.html.markdown
index e4181609..355c7f29 100644
--- a/es-es/julia-es.html.markdown
+++ b/es-es/julia-es.html.markdown
@@ -28,7 +28,7 @@ En Julia los programas están organizados entorno al [despacho múltiple](http:/
 * [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 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**.
diff --git a/es-es/matlab-es.html.markdown b/es-es/matlab-es.html.markdown
index faa3dead..9290e505 100644
--- a/es-es/matlab-es.html.markdown
+++ b/es-es/matlab-es.html.markdown
@@ -1,5 +1,5 @@
 ---
-language: Matlab
+language: MATLAB
 filename: learnmatlab-es.mat
 contributors:
     - ["mendozao", "http://github.com/mendozao"]
@@ -139,7 +139,7 @@ A.d.e = false;
 
 % Vectores
 x = [4 32 53 7 1]
-x(2) % ans = 32, los índices en Matlab comienzan 1, no 0
+x(2) % ans = 32, los índices en MATLAB comienzan 1, no 0
 x(2:3) % ans = 32 53
 x(2:end) % ans = 32 53 7 1
 
@@ -506,7 +506,7 @@ find(x) % Encuentra todos los elementos distintos de cero de x y devuelve sus í
 
 
 % Clases
-% Matlab puede soportar programación orientada a objetos.
+% MATLAB puede soportar programación orientada a objetos.
 % Las clases deben colocarse en un archivo del nombre de la clase con la extensión .m. 
 % Para comenzar, creamos una clase simple para almacenar puntos de referencia de GPS.
 % Comience WaypointClass.m
@@ -528,7 +528,7 @@ classdef WaypointClass % El nombre de la clase.
     end
 
     % Si queremos agregar dos objetos Waypoint juntos sin llamar
-    % a una función especial, podemos sobrecargar la aritmética de Matlab así:
+    % a una función especial, podemos sobrecargar la aritmética de MATLAB así:
     function r = plus(o1,o2)
       r = WaypointClass([o1.latitude] +[o2.latitude], ...
                         [o1.longitude]+[o2.longitude]);
@@ -540,7 +540,7 @@ end
 % Podemos crear un objeto de la clase usando el constructor
 a = WaypointClass(45.0, 45.0)
 
-% Las propiedades de clase se comportan exactamente como estructuras de Matlab.
+% Las propiedades de clase se comportan exactamente como estructuras de MATLAB.
 a.latitude = 70.0
 a.longitude = 25.0
 
@@ -551,15 +551,15 @@ ans = multiplyLatBy(a,3)
 % no necesita ser pasado al método.
 ans = a.multiplyLatBy(a,1/3)
 
-% Las funciones de Matlab pueden sobrecargarse para manejar objetos.
-% En el método anterior, hemos sobrecargado cómo maneja Matlab
+% Las funciones de MATLAB pueden sobrecargarse para manejar objetos.
+% En el método anterior, hemos sobrecargado cómo maneja MATLAB
 % la adición de dos objetos Waypoint.
 b = WaypointClass(15.0, 32.0)
 c = a + b
 
 ```
 
-## Más sobre Matlab
+## Más sobre MATLAB
 
 * [The official website (EN)](http://www.mathworks.com/products/matlab/)
 * [The official MATLAB Answers forum (EN)](http://www.mathworks.com/matlabcentral/answers/)
diff --git a/es-es/powershell-es.html.markdown b/es-es/powershell-es.html.markdown
index 9eb35967..5b12b961 100644
--- a/es-es/powershell-es.html.markdown
+++ b/es-es/powershell-es.html.markdown
@@ -34,7 +34,7 @@ $PSVersionTable
 
 Para obtener ayuda:
 
-```
+```powershell
 # Si necesita encontrar algún comando
 Get-Command about_* # tiene por abreviación (o alias): gcm
 Get-Command -Verb Add # lista todos los comandos que tienen por verbo 'Add'
@@ -51,7 +51,7 @@ Update-Help # Actualiza la ayuda (debe ser ejecutado en una consola elevada como
 
 Acá inicia el tutorial:
 
-```
+```powershell
 # Como ya lo notó, los comentarios empiezan con #
 
 # Ejemplo de un simple hola mundo:
@@ -299,7 +299,7 @@ $Shortcut.Save()
 
 Configurando el shell
 
-```
+```powershell
 # $Profile es la ruta completa para su `Microsoft.PowerShell_profile.ps1`
 # Todo el código alojado allí será ejecutado cuando se ejecuta una nueva sesión de PS 
 if (-not (Test-Path $Profile)) {
diff --git a/es-es/pyqt-es.html.markdown b/es-es/pyqt-es.html.markdown
index 6d4fdde7..9a5eab8c 100644
--- a/es-es/pyqt-es.html.markdown
+++ b/es-es/pyqt-es.html.markdown
@@ -16,7 +16,7 @@ Esta es una adaptación de la introducción a QT con C++ por [Aleksey Kholovchuk
 ```python
 import sys
 from PyQt4 import QtGui
-	
+
 def window():
     # Crear el objeto de la aplicación
     app = QtGui.QApplication(sys.argv)
@@ -44,7 +44,7 @@ if __name__ == '__main__':
 Para poder hacer uso de las funciones más avanzades en **pyqt** necesitamos agregar elementos adicionales.
 Aquí mostramos cómo introducir una caja de diálogo popup, útil para permitir al usuario confirmar su decisión o para brindarnos información.
 
-```Python 
+```python
 import sys
 from PyQt4.QtGui import *
 from PyQt4.QtCore import *
@@ -63,7 +63,7 @@ def window():
     w.setWindowTitle("PyQt Dialog")
     w.show()
     sys.exit(app.exec_())
-	
+
 # Esta función debería crear una ventana de diálogo con un botón
 # que espera a recibir un click y luego sale del programa
 def showdialog():
diff --git a/es-es/python-es.html.markdown b/es-es/python-es.html.markdown
index 08cf9769..a8f01089 100644
--- a/es-es/python-es.html.markdown
+++ b/es-es/python-es.html.markdown
@@ -328,7 +328,7 @@ dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
 nuestro_iterable = dicc_lleno.keys()
 print(nuestro_iterable) #=> dict_keys(['uno', 'dos', 'tres']). Este es un objeto que implementa nuestra interfaz Iterable
 
-Podemos recorrerla.
+# Podemos recorrerla.
 for i in nuestro_iterable:
     print(i)    # Imprime uno, dos, tres
 
@@ -388,8 +388,8 @@ 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
+    print(args)
+    print(kwargs)
 """
 todos_los_argumentos(1, 2, a=3, b=4) imprime:
     (1, 2)
@@ -462,10 +462,10 @@ class Humano(object):
 
 # Instancia una clase
 i = Humano(nombre="Ian")
-print i.decir("hi")     # imprime "Ian: hi"
+print(i.decir("hi"))     # imprime "Ian: hi"
 
 j = Humano("Joel")
-print j.decir("hello")  #imprime "Joel: hello"
+print(j.decir("hello"))  #imprime "Joel: hello"
 
 # Llama nuestro método de clase
 i.get_especie() #=> "H. sapiens"
diff --git a/es-es/r-es.html.markdown b/es-es/r-es.html.markdown
index 2b710b27..850952fa 100644
--- a/es-es/r-es.html.markdown
+++ b/es-es/r-es.html.markdown
@@ -16,7 +16,7 @@ LaTeX.
 
 ```r
 
-# Los comentariso inician con símbolos numéricos.
+# Los comentarios inician con símbolos numéricos.
 
 # No puedes hacer comentarios de múltiples líneas
 # pero puedes agrupar múltiples comentarios de esta manera. 
diff --git a/es-es/raku-es.html.markdown b/es-es/raku-es.html.markdown
index e916d0fd..09341056 100644
--- a/es-es/raku-es.html.markdown
+++ b/es-es/raku-es.html.markdown
@@ -1,5 +1,5 @@
 ---
-name: perl6
+name: Raku
 category: language
 language: Raku
 filename: learnraku-es.raku
diff --git a/es-es/self-es.html.markdown b/es-es/self-es.html.markdown
index 11972214..1f985215 100644
--- a/es-es/self-es.html.markdown
+++ b/es-es/self-es.html.markdown
@@ -116,6 +116,7 @@ Las expresiones múltiples son separadas por un punto. ^ retorna inmediatamente.
 ```
 
 Los bloques son ejecutados al enviales el mensaje 'value' y son inherentes (delegados a) sus contextos:
+
 ```
 "returns 0"
 [|x|
diff --git a/es-es/visualbasic-es.html.markdown b/es-es/visualbasic-es.html.markdown
index c677c20f..fb0b1d27 100644
--- a/es-es/visualbasic-es.html.markdown
+++ b/es-es/visualbasic-es.html.markdown
@@ -8,7 +8,7 @@ filename: learnvisualbasic-es.vb
 lang: es-es
 ---
 
-```
+```visualbasic
 Module Module1
 
     Sub Main()
diff --git a/es-es/wolfram-es.html.markdown b/es-es/wolfram-es.html.markdown
index 44ec9e09..6858c286 100644
--- a/es-es/wolfram-es.html.markdown
+++ b/es-es/wolfram-es.html.markdown
@@ -15,7 +15,7 @@ El lenguaje de Wolfram tiene varias interfaces:
 
 El código de este ejemplo se puede escribir en cualquier interfaz y editarlo con Wolfram Workbench. Cargar directamente en Matematica puede resultar incómodo porque el archivo no contiene información de formato de celda (lo que haría que el archivo sea un desastre enorme para ser leído como texto) - puede ser visto / editado pero tal vez requerira algún ajuste.
 
-```
+```mathematica
 (* Esto es un comentario *)
 
 (* En Mathematica en lugar de utilizar estos comentarios, puede crear una celda de texto