Merge pull request #1 from adambard/master

Update from Upstream

11 files changed, 2350 insertions, 21 deletions

diff --git a/es-es/c++-es.html.markdown b/es-es/c++-es.html.markdown
index bd1ad07c..2c3762d5 100644
--- a/es-es/c++-es.html.markdown
+++ b/es-es/c++-es.html.markdown
@@ -823,7 +823,6 @@ v.swap(vector<Foo>());
 ```
 Otras lecturas:
 
-Una referencia del lenguaje hasta a la fecha se puede encontrar en
-<http://cppreference.com/w/cpp>
-
-Recursos adicionales se pueden encontrar en <http://cplusplus.com>
+* Una referencia del lenguaje hasta a la fecha se puede encontrar en [CPP Reference](http://cppreference.com/w/cpp).
+* Recursos adicionales se pueden encontrar en [[CPlusPlus]](http://cplusplus.com).
+* Un tutorial que cubre los conceptos básicos del lenguaje y la configuración del entorno de codificación está disponible en [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FF).
diff --git a/es-es/coldfusion-es.html.markdown b/es-es/coldfusion-es.html.markdown
new file mode 100644
index 00000000..2e98f910
--- /dev/null
+++ b/es-es/coldfusion-es.html.markdown
@@ -0,0 +1,330 @@
+---
+language: coldfusion
+filename: learncoldfusion-es.cfm
+contributors:
+    - ["Wayne Boka", "http://wboka.github.io"]
+    - ["Kevin Morris", "https://twitter.com/kevinmorris"]
+translators:
+    - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+---
+
+ColdFusion es un lenguaje de scripting para desarrollo web.
+[Lea más aquí](Http://www.adobe.com/products/coldfusion-family.html)
+
+### CFML
+_**C**old**F**usion **M**arkup **L**anguage_  
+ColdFusion comenzó como un lenguaje basado en etiquetas. Casi toda la funcionalidad está disponible usando etiquetas.
+
+```cfm
+<em>Se han proporcionado etiquetas HTML para facilitar la lectura.</em>
+
+<!--- Los comentarios comienzan con "<!---" y terminan con "--->" --->
+<!---
+    Los comentarios
+    también
+    pueden ocupar
+    multiples líneas
+--->
+
+<!--- Las etiquetas CFML tienen un formato similar a las etiquetas HTML. --->
+<h1>Variables simples</h1>
+<!--- Declaración de variables: las variables son débilmente tipadas, similar a javascript --->
+<p>Set <b>miVariable</b> to "miValor"</p>
+<cfset miVariable = "miValor" />
+<p>Set <b>miNumero</b> to 3.14</p>
+<cfset miNumero = 3.14 />
+
+<!--- Mostrando datos simples --->
+<!--- Use <cfoutput> para valores simples como cadenas, números y expresiones --->
+<p>Muestra <b>miVariable</b>: <cfoutput>#miVariable#</cfoutput></p><!--- miValor --->
+<p>Muestra <b>miNumero</b>: <cfoutput>#miNumero#</cfoutput></p><!--- 3.14 --->
+
+<hr />
+
+<h1>Variables complejas</h1>
+<!--- Declarar variables complejas. --->
+<!--- Declarar una matriz de 1 dimensión: literal o notación de corchete --->
+<p>Establecer <b>miArreglo1</b> en una matriz de 1 dimensión utilizando la notación literal o de corchete</p>
+<cfset miArreglo1 = [] />
+<!--- Declarar una matriz de 1 dimensión: notación de función --->
+<p>Establecer <b> miArreglo2 </b> en una matriz de 1 dimensión usando la notación de funciones</p>
+<cfset miArreglo2 = ArrayNew(1) />
+
+<!--- Salida de variables complejas. --->
+<p>Contenidos de <b>miArreglo1</b></p>
+<cfdump var="#miArreglo1#" /> <!--- Un objeto de matriz vacío --->
+<p>Contenidos de <b>miArreglo2</b></p>
+<cfdump var="#miArreglo2#" /> <!--- Un objeto de matriz vacío --->
+
+<!--- Los operadores --->
+<!--- Aritméticos --->
+<h1>Operadores</h1>
+<h2>Aritméticos</h2>
+<p>1 + 1 = <cfoutput>#1 + 1#</cfoutput></p>
+<p>10 - 7 = <cfoutput>#10 - 7#<br /></cfoutput></p>
+<p>15 * 10 = <cfoutput>#15 * 10#<br /></cfoutput></p>
+<p>100 / 5 = <cfoutput>#100 / 5#<br /></cfoutput></p>
+<p>120 % 5 = <cfoutput>#120 % 5#<br /></cfoutput></p>
+<p>120 mod 5 = <cfoutput>#120 mod 5#<br /></cfoutput></p>
+
+<hr />
+
+<!--- Comparación --->
+<h2>Comparación</h2>
+<h3>Notación estándar</h3>
+<p>Is 1 eq 1? <cfoutput>#1 eq 1#</cfoutput></p>
+<p>Is 15 neq 1? <cfoutput>#15 neq 1#</cfoutput></p>
+<p>Is 10 gt 8? <cfoutput>#10 gt 8#</cfoutput></p>
+<p>Is 1 lt 2? <cfoutput>#1 lt 2#</cfoutput></p>
+<p>Is 10 gte 5? <cfoutput>#10 gte 5#</cfoutput></p>
+<p>Is 1 lte 5? <cfoutput>#1 lte 5#</cfoutput></p>
+
+<h3>Notación alternativa</h3>
+<p>Is 1 == 1? <cfoutput>#1 eq 1#</cfoutput></p>
+<p>Is 15 != 1? <cfoutput>#15 neq 1#</cfoutput></p>
+<p>Is 10 > 8? <cfoutput>#10 gt 8#</cfoutput></p>
+<p>Is 1 < 2? <cfoutput>#1 lt 2#</cfoutput></p>
+<p>Is 10 >= 5? <cfoutput>#10 gte 5#</cfoutput></p>
+<p>Is 1 <= 5? <cfoutput>#1 lte 5#</cfoutput></p>
+
+<hr />
+
+<!--- Estructuras de Control --->
+<h1>Estructuras de Control</h1>
+
+<cfset miCondicion = "Prueba" />
+
+<p>Condición a probar: "<cfoutput>#miCondicion#</cfoutput>"</p>
+
+<cfif miCondicion eq "Prueba">
+    <cfoutput>#miCondicion#. Estamos probando.</cfoutput>
+<cfelseif miCondicion eq "Producción">
+    <cfoutput>#miCondicion#. Procede con cuidado!!!</cfoutput>
+<cfelse>
+    miCondicion es desconocido
+</cfif>
+
+<hr />
+
+<!--- Bucles --->
+<h1>Bucles</h1>
+<h2>Bucle For</h2>
+<cfloop from="0" to="10" index="i">
+	<p>Index equals <cfoutput>#i#</cfoutput></p>
+</cfloop>
+
+<h2>Bucle For Each (Variables complejas)</h2>
+
+<p>Establecer <b>miArreglo3</b> to [5, 15, 99, 45, 100]</p>
+
+<cfset miArreglo3 = [5, 15, 99, 45, 100] />
+
+<cfloop array="#miArreglo3#" index="i">
+	<p>Index equals <cfoutput>#i#</cfoutput></p>
+</cfloop>
+
+<p>Establecer <b>myArray4</b> to ["Alpha", "Bravo", "Charlie", "Delta", "Echo"]</p>
+
+<cfset myArray4 = ["Alpha", "Bravo", "Charlie", "Delta", "Echo"] />
+
+<cfloop array="#myArray4#" index="s">
+	<p>Index equals <cfoutput>#s#</cfoutput></p>
+</cfloop>
+
+<h2>Declaración Switch</h2>
+
+<p>Establecer <b>miArreglo5</b> to [5, 15, 99, 45, 100]</p>
+
+<cfset miArreglo5 = [5, 15, 99, 45, 100] />
+
+<cfloop array="#miArreglo5#" index="i">
+	<cfswitch expression="#i#">
+		<cfcase value="5,15,45" delimiters=",">
+			<p><cfoutput>#i#</cfoutput> es un múltiplo de 5.</p>
+		</cfcase>
+		<cfcase value="99">
+			<p><cfoutput>#i#</cfoutput> es noventa y nueve.</p>
+		</cfcase>
+		<cfdefaultcase>
+			<p><cfoutput>#i#</cfoutput> no es 5, 15, 45, or 99.</p>
+		</cfdefaultcase> 
+	</cfswitch> 
+</cfloop>
+
+<hr />
+
+<h1>Conversión de tipos</h1>
+
+<style>
+	table.table th, table.table td {
+		border: 1px solid #000000;
+		padding: 2px;
+	}
+	
+	table.table th {
+		background-color: #CCCCCC;
+	}
+</style>
+
+<table class="table" cellspacing="0">
+	<thead>
+		<tr>
+			<th>Valor</th>
+			<th>Como booleano</th>
+			<th>Como número</th>
+			<th>Como fecha</th>
+			<th>Como cadena</th>
+		</tr>
+	</thead>
+	<tbody>
+		<tr>
+			<th>"Si"</th>
+			<td>TRUE</td>
+			<td>1</td>
+			<td>Error</td>
+			<td>"Si"</td>
+		</tr>
+		<tr>
+			<th>"No"</th>
+			<td>FALSE</td>
+			<td>0</td>
+			<td>Error</td>
+			<td>"No"</td>
+		</tr>
+		<tr>
+			<th>TRUE</th>
+			<td>TRUE</td>
+			<td>1</td>
+			<td>Error</td>
+			<td>"Yes"</td>
+		</tr>
+		<tr>
+			<th>FALSE</th>
+			<td>FALSE</td>
+			<td>0</td>
+			<td>Error</td>
+			<td>"No"</td>
+		</tr>
+		<tr>
+			<th>Número</th>
+			<td>True si el número no es 0; False de lo contrario.</td>
+			<td>Número</td>
+			<td>Consulte &#34;Date-time values&#34; anteriormente en este capítulo.</td>
+			<td>Representación de cadena del número (for example, &#34;8&#34;).</td>
+		</tr>
+		<tr>
+			<th>Cadena</th>
+			<td>Si representa una fecha y hora (ver la siguiente columna), se convierte al valor numérico del objeto de fecha y hora correspondiente. <br> Si es una fecha, hora o marca de tiempo ODBC (por ejemplo, "{ts '2001-06-14 11:30:13'}", o si se expresa en un formato de fecha u hora estándar de EE. UU., incluido al usar nombres de mes completos o abreviados, se convierte al valor de fecha y hora correspondiente. <br> Los días de la semana o la puntuación inusual dan como resultado un error. <br> Generalmente se permiten guiones, barras diagonales y espacios. </td>
+			<td>Cadena</td>
+		</tr>
+		<tr>
+			<th>Fecha</th>
+			<td>Error</td>
+			<td>El valor numérico del objeto fecha-hora.</td>
+			<td>Fecha</td>
+			<td>una marca de tiempo de ODBC.</td>
+		</tr>
+	</tbody>
+</table>
+
+<hr />
+
+<h1>Componentes</h1>
+
+<em>Código de referencia (las funciones deben devolver algo para admitir IE)</em>
+```
+```cfs
+<cfcomponent>
+	<cfset this.hola = "Hola" />
+	<cfset this.mundo = "Mundo" />
+
+	<cffunction name="sayHhola">
+		<cfreturn this.hola & ", " & this.mundo & "!" />
+	</cffunction>
+	
+	<cffunction name="setHhola">
+		<cfargument name="newHola" type="string" required="true" />
+		
+		<cfset this.hola = arguments.newHola />
+		 
+		<cfreturn true />
+	</cffunction>
+	
+	<cffunction name="setMundo">
+		<cfargument name="newMundo" type="string" required="true" />
+		
+		<cfset this.mundo = arguments.newMundo />
+		 
+		<cfreturn true />
+	</cffunction>
+	
+	<cffunction name="getHola">
+		<cfreturn this.hola />
+	</cffunction>
+	
+	<cffunction name="getMundo">
+		<cfreturn this.mundo />
+	</cffunction>
+</cfcomponent>
+
+<cfset this.hola = "Hola" />
+<cfset this.mundo = "Mundo" />
+
+<cffunction name="sayHola">
+	<cfreturn this.hola & ", " & this.mundo & "!" />
+</cffunction>
+
+<cffunction name="setHola">
+	<cfargument name="newHola" type="string" required="true" />
+	
+	<cfset this.hola = arguments.newHola />
+	 
+	<cfreturn true />
+</cffunction>
+
+<cffunction name="setMundo">
+	<cfargument name="newMundo" type="string" required="true" />
+	
+	<cfset this.mundo = arguments.newMundo />
+	 
+	<cfreturn true />
+</cffunction>
+
+<cffunction name="getHola">
+	<cfreturn this.hola />
+</cffunction>
+
+<cffunction name="getMundo">
+	<cfreturn this.mundo />
+</cffunction>
+
+
+<b>sayHola()</b>
+<cfoutput><p>#sayHola()#</p></cfoutput>
+<b>getHola()</b>
+<cfoutput><p>#getHola()#</p></cfoutput>
+<b>getMundo()</b>
+<cfoutput><p>#getMundo()#</p></cfoutput>
+<b>setHola("Hola")</b>
+<cfoutput><p>#setHola("Hola")#</p></cfoutput>
+<b>setMundo("mundo")</b>
+<cfoutput><p>#setMundo("mundo")#</p></cfoutput>
+<b>sayHola()</b>
+<cfoutput><p>#sayHola()#</p></cfoutput>
+<b>getHola()</b>
+<cfoutput><p>#getHola()#</p></cfoutput>
+<b>getMundo()</b>
+<cfoutput><p>#getMundo()#</p></cfoutput>
+```
+
+### CFScript
+_**C**old**F**usion **S**cript_  
+En los últimos años, el lenguaje ColdFusion ha agregado sintaxis de script para simular la funcionalidad de etiquetas. Cuando se utiliza un servidor CF actualizado, casi todas las funciones están disponibles mediante la sintaxis de script.
+
+## Otras lecturas
+
+Los enlaces que se proporcionan a continuación son solo para comprender el tema, siéntase libre de buscar en Google y encuentrar ejemplos específicos.
+
+1. [Coldfusion Reference From Adobe](https://helpx.adobe.com/coldfusion/cfml-reference/topics.html)
+2. [Open Source Documentation](http://cfdocs.org/)
diff --git a/es-es/csharp-es.html.markdown b/es-es/csharp-es.html.markdown
index 5d730497..72a0f90c 100644
--- a/es-es/csharp-es.html.markdown
+++ b/es-es/csharp-es.html.markdown
@@ -5,7 +5,7 @@ contributors:
     - ["Irfan Charania", "https://github.com/irfancharania"]
     - ["Max Yankov", "https://github.com/golergka"]
 translators:
-    - ["Olfran Jiménez", "https://twitter.com/neslux"]	
+    - ["Olfran Jiménez", "https://twitter.com/neslux"]
 lang: es-es
 
 ---
diff --git a/es-es/erlang-es.html.markdown b/es-es/erlang-es.html.markdown
new file mode 100644
index 00000000..bc6317a5
--- /dev/null
+++ b/es-es/erlang-es.html.markdown
@@ -0,0 +1,293 @@
+---
+language: erlang
+lang: es-es
+contributors:
+    - ["Giovanni Cappellotto", "http://www.focustheweb.com/"]
+translators:
+  - ["Ernesto Pelayo", "http://github.com/ErnestoPelayo"]
+filename: learnerlang-es.erl
+---
+
+# Erlang
+%  Signo de porcentaje inicia un comentario de una línea.
+
+%% Se usarán dos por ciento de caracteres para comentar funciones.
+
+%%% Se usarán tres por ciento de caracteres para comentar los módulos.
+
+### Utilizamos tres tipos de puntuación en Erlang.
+
++ **Comas (`,`)**  argumentos separados en llamadas a funciones, constructores de
+datos y patrones.
+
++ **Periodos (`.`)** (seguido de espacios en blanco) separa funciones completas y
+expresiones en el shell.
+
++  **Semicolons (`;`)** cláusulas separadas. Encontramos cláusulas en varios contextos: de definiciones de funciones y en **`case`**,**` if`**, **`try..catch`**, y **` receive`** de expresiones.
+
+ ## 1.-Variables y coincidencia de patrones.
+
+
+- En Erlang, las nuevas variables están vinculadas con una instrucción **`=`**.
+>**Num = 42.**
+
+- Todos los nombres de variables deben comenzar con una letra mayúscula.
+
+- Erlang tiene variables de asignación única; si intentas asignar un diferente de valor a la variable **`Num`**, obtendrá un error.
+Num = 43. **error de excepción**: no coincide con el valor del lado derecho 43
+
+- En la mayoría de los idiomas, **`=`** denota una declaración de asignación. En Erlang, sin embargo,**`=`** denota una operación de coincidencia de patrones.
+
+- Cuando se usa una variable vacía en el del lado izquierdo del operador `=` to está vinculado (asignado), pero cuando está atado variable se usa en el lado izquierdo, se observa el siguiente comportamiento.
+>**`Lhs = Rhs`** realmente significa esto: evaluar el lado derecho (**` Rhs`**),  y luego coincide con el resultado contra el patrón en el lado izquierdo (**`Lhs`**).
+>**Num = 7 * 6.**
+
+- Número de punto flotante.
+Pi = 3.14159.
+
+- Los átomos se usan para representar diferentes valores constantes no numéricos.
+
+- Átomos comienza con letras minúsculas, seguido de una secuencia de caracteres
+
+- alfanuméricos de caracteres o el signo de subrayado (**`_`**) o en (**` @ `**).
+>**Hola = hola.**
+  **OtherNode = ejemplo @ nodo.**
+
+- Los átomos con valores no alfanuméricos se pueden escribir al encerrar los átomos con apóstrofes.
+>**AtomWithSpace = 'algún átomo con espacio'.**
+
++ Tuples son similares a las estructuras en C.
+>**Point = {point, 10, 45}.**
+
+- Si queremos extraer algunos valores de una tupla, usamos el patrón de coincidencia
+ operador **`=`**.
+> **{punto, X, Y} = Punto. % X = 10, Y = 45**
+
+- Podemos usar **`_`** como marcador de posición para variables que no nos interesan.
+
+- El símbolo **`_`** se llama una variable anónima. A diferencia de las variables  regulares,varias apariciones de `_` en el mismo patrón no tienen que vincularse a mismo valor.
+>**Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}.**
+**{_, {_, {_, who }, _}, _} = Persona. % Who = joe**
+
++ Creamos una lista al encerrar los elementos de la lista entre corchetes y separándolos con comas.
+
++ Los elementos individuales de una lista pueden ser de cualquier tipo.
+
+- El primer elemento de una lista es el encabezado de la lista. Si te imaginas eliminar del encabezado de la lista, lo que queda se llama cola de la lista.
+>**ThingsToBuy = [{manzanas, 10}, {peras, 6}, {leche, 3}].**
+
+- Si `T` es una lista, entonces **` [H | T] `** también es una lista, con la cabeza **` H`** y la cola **`T`**.
+
++ La barra vertical (**`|`**) separa el encabezado de una lista de su cola.
+  **`[]`** es la lista vacía.
+
++ Podemos extraer elementos de una lista con una operación de coincidencia de
+  patrones. Si nosotros tiene una lista no vacía **`L`**, luego la expresión **` [X | Y] = L`**, donde **`X`** y **` Y`** son variables independientes, extraerán el encabezado de la lista en **`X`** y la cola de la lista en **`Y`**.
+>**[FirstThing | OtherThingsToBuy] = ThingsToBuy.**
+**FirstThing = {manzanas, 10}**
+**OtherThingsToBuy = [{peras, 6}, {leche, 3}]**
+
++ No hay cadenas en Erlang. Las cadenas son realmente solo listas de enteros.
+
++ Las cadenas están entre comillas dobles (**`" `**).
+>**Nombre = "Hola".
+[72, 101, 108, 108, 111] = "Hola".**
+
+##  2. Programación secuencial.
+
+
+- Los módulos son la unidad básica de código en Erlang. Todas las funciones que escribimos son almacenado en módulos.
+
+- Los módulos se almacenan en archivos con extensiones **`.erl`**.
+- Los módulos deben compilarse antes de poder ejecutar el código. Un módulo compilado tiene el extensión **`.beam`**.
+>**-módulo (geometría).
+-export ([area / 1]).  de la lista de funciones exportadas desde el módulo.**
+
++ La función **`área`** consta de dos cláusulas. Las cláusulas están separadas por un punto y coma, y ​​la cláusula final termina con punto-espacio en blanco. Cada cláusula tiene una cabeza y un cuerpo; la cabeza consiste en un nombre de función seguido de un patrón (entre paréntesis), y el cuerpo consiste en una secuencia de expresiones, que se evalúan si el patrón en la cabeza es exitoso coincide con los argumentos de llamada. Los patrones se combinan en el orden aparecen en la definición de la función.
+>**área ({rectángulo, ancho, Ht}) -> ancho * Ht;
+área ({círculo, R}) -> 3.14159 * R * R** .
+
+ ### Compila el código en el archivo geometry.erl.
+c (geometría).  {ok, geometría}
+
++ Necesitamos incluir el nombre del módulo junto con el nombre de la función para identifica exactamente qué función queremos llamar.
+>**geometría: área ({rectángulo, 10, 5}). % 50**
+**geometría: área ({círculo, 1.4}). % 6.15752**
+
++ En Erlang, dos funciones con el mismo nombre y arity diferente (número de argumentos) en el mismo módulo representan funciones completamente diferentes.
+>-**module (lib_misc)**.
+-**export ([sum / 1])**.  
+
+- función de exportación **`suma`** de arity 1  acepta un argumento:
+>**lista de enteros.
+suma (L) -> suma (L, 0).
+suma ([], N) -> N;
+suma ([H | T], N) -> suma (T, H + N).**
++ Funs son funciones **"anónimas"**. Se llaman así porque tienen sin nombre. Sin embargo, pueden asignarse a variables.
+Doble = diversión (X) -> 2 * X final.  **`Doble`** apunta a una función anónima con el controlador: **#Fun <erl_eval.6.17052888>
+Doble (2). % 4**
+
+- Functions acepta funs como sus argumentos y puede devolver funs.
+>**Mult = diversión (Times) -> (fun (X) -> X * Times end) end.
+Triple = Mult (3).
+Triple (5). % 15**
+
+- Las listas de comprensión son expresiones que crean listas sin tener que usar
+ funs, mapas o filtros.
+ - La notación **`[F (X) || X <- L] `** significa" la lista de **`F (X)`** donde se toma **`X`**% de la lista **`L`."**
+>**L = [1,2,3,4,5].
+[2 * X || X <- L]. % [2,4,6,8,10]**
+
+- Una lista de comprensión puede tener generadores y filtros, que seleccionan un subconjunto de los valores generados
+>**EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4]**
+
+- Los protectores son construcciones que podemos usar para aumentar el poder del patrón coincidencia. Usando guardias, podemos realizar pruebas simples y comparaciones en el de variables en un patrón.
+Puede usar guardias en la cabeza de las definiciones de funciones donde están introducido por la palabra clave **`when`**, o puede usarlos en cualquier lugar del lenguaje donde se permite una expresión.
+>**max (X, Y) cuando X> Y -> X;
+max (X, Y) -> Y.**
+
+- Un guardia es una serie de expresiones de guardia, separadas por comas (**`,`**).
+- La guardia **`GuardExpr1, GuardExpr2, ..., GuardExprN`** es verdadera si todos los guardias expresiones **`GuardExpr1`,` GuardExpr2`, ..., `GuardExprN`** evalúan **`true`**.
+>**is_cat (A) cuando is_atom (A), A =: = cat -> true;
+is_cat (A) -> false.
+is_dog (A) cuando is_atom (A), A =: = dog -> true;
+is_dog (A) -> false.**
+
+No nos detendremos en el operador **`=: =`** aquí; Solo tenga en cuenta que está acostumbrado a comprueba si dos expresiones de Erlang tienen el mismo valor * y * del mismo tipo. Contrasta este comportamiento con el del operador **`==`**:
+
+>**1 + 2 =: = 3.% true
+1 + 2 =: = 3.0. % false
+1 + 2 == 3.0. % true**
+
+ Una secuencia de guardia es una guardia individual o una serie de guardias, separadas por punto y coma (**`;`**). La secuencia de guardia **`G1; G2; ...; Gn`** es verdadero si en menos uno de los guardias **`G1`,` G2`, ..., `Gn`** se evalúa como **` true`**.
+>**is_pet (A) cuando is_atom (A), (A =: = dog); (A =: = cat) -> true;
+is_pet (A) -> false.**
+
+- **Advertencia**: no todas las expresiones de Erlang válidas se pueden usar como expresiones de guarda; en particular, nuestras funciones **`is_cat`** y **`is_dog`** no se pueden usar dentro del secuencia de protección en la definición de **`is_pet`**. Para una descripción de expresiones permitidas en secuencias de guarda, consulte la sección específica en el manual de referencia de Erlang:
+### http://erlang.org/doc/reference_manual/expressions.html#guards
+
+- Los registros proporcionan un método para asociar un nombre con un elemento particular en un de tupla De las definiciones de registros se pueden incluir en los archivos de código fuente de Erlang o poner en archivos con la extensión **`.hrl`**, que luego están incluidos en el código fuente de Erlang de archivos.
+
+>**-record (todo, {
+  status = recordatorio,% valor predeterminado
+  quien = joe,
+  texto
+}).**
+
+- Tenemos que leer las definiciones de registro en el shell antes de que podamos definir un
+ de registro. Usamos la función shell **`rr`** (abreviatura de los registros de lectura) para hacer esto.
+
+>**rr ("records.hrl").** % [que hacer]
+
+- **Creando y actualizando registros:**
+>**X = #todo {}.
+% #todo {status = recordatorio, who = joe, text = undefined}
+X1 = #todo {estado = urgente, texto = "Corregir errata en el libro"}.
+% #todo {status = urgent, who = joe, text = "Corregir errata en el libro"}
+X2 = X1 # todo {estado = hecho}.
+% #todo {status = done, who = joe, text = "Corregir errata en el libro"}
+expresiones `case`**.
+
+**`filter`** devuelve una lista de todos los elementos **` X`** en una lista **`L`** para la cual **` P (X) `** es true.
+>**filter(P, [H|T]) ->
+  case P(H) of
+    true -> [H|filter(P, T)];
+    false -> filter(P, T)
+  end;
+filter(P, []) -> [].
+filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4]**
+
+expresiones **`if`**.
+>**max(X, Y) ->
+  if
+    X > Y -> X;
+    X < Y -> Y;
+    true -> nil
+  end.**
+
+**Advertencia:** al menos uno de los guardias en la expresión **`if`** debe evaluar a **`true`**; de lo contrario, se generará una excepción.
+
+## 3. Excepciones.
+
+
+- El sistema genera excepciones cuando se encuentran errores internos o explícitamente en el código llamando **`throw (Exception)`**, **`exit (Exception)`**, o **`erlang: error (Exception)`**.
+>**generate_exception (1) -> a;
+generate_exception (2) -> throw (a);
+generate_exception (3) -> exit (a);
+generate_exception (4) -> {'EXIT', a};
+generate_exception (5) -> erlang: error (a).**
+
+- Erlang tiene dos métodos para atrapar una excepción. Una es encerrar la llamada a de la función que genera la excepción dentro de una expresión **`try ... catch`**.
+>**receptor (N) ->
+  prueba generar_excepción (N) de
+    Val -> {N, normal, Val}
+  captura
+    throw: X -> {N, atrapado, arrojado, X};
+    exit: X -> {N, atrapado, salido, X};
+    error: X -> {N, atrapado, error, X}
+  end.**
+
+- El otro es encerrar la llamada en una expresión **`catch`**. Cuando atrapas un de excepción, se convierte en una tupla que describe el error.
+>**catcher (N) -> catch generate_exception (N).**
+
+## 4. Concurrencia
+
+- Erlang se basa en el modelo de actor para concurrencia. Todo lo que necesitamos para escribir de programas simultáneos en Erlang son tres primitivos: procesos de desove, de envío de mensajes y recepción de mensajes.
+
+- Para comenzar un nuevo proceso, usamos la función **`spawn`**, que toma una función como argumento.
+
+>**F = diversión () -> 2 + 2 final. % #Fun <erl_eval.20.67289768>
+spawn (F). % <0.44.0>**
+
+- **`spawn`** devuelve un pid (identificador de proceso); puedes usar este pid para enviar de mensajes al proceso. Para pasar mensajes, usamos el operador **`!`**.
+
+- Para que todo esto sea útil, debemos poder recibir mensajes. Esto es logrado con el mecanismo **`receive`**:
+
+>**-module (calcular Geometría).
+-compile (export_all).
+calculateArea () ->
+    recibir
+      {rectángulo, W, H} ->
+        W * H;
+      {circle, R} ->
+        3.14 * R * R;
+      _ ->
+        io: format ("Solo podemos calcular el área de rectángulos o círculos")
+    end.**
+
+- Compile el módulo y cree un proceso que evalúe **`calculateArea`** en cáscara.
+>**c (calcular Geometría).
+CalculateArea = spawn (calcular Geometría, calcular Área, []).
+CalculateArea! {círculo, 2}. % 12.56000000000000049738**
+
+- El shell también es un proceso; puedes usar **`self`** para obtener el pid actual.
+**self(). % <0.41.0>**
+
+## 5. Prueba con EUnit
+
+- Las pruebas unitarias se pueden escribir utilizando los generadores de prueba de EUnits y afirmar macros
+>**-módulo (fib).
+-export ([fib / 1]).
+-include_lib ("eunit / include / eunit.hrl").**
+
+>**fib (0) -> 1;
+fib (1) -> 1;
+fib (N) when N> 1 -> fib (N-1) + fib (N-2).**
+
+>**fib_test_ () ->
+    [? _assert (fib (0) =: = 1),
+     ? _assert (fib (1) =: = 1),
+     ? _assert (fib (2) =: = 2),
+     ? _assert (fib (3) =: = 3),
+     ? _assert (fib (4) =: = 5),
+     ? _assert (fib (5) =: = 8),
+     ? _assertException (error, function_clause, fib (-1)),
+     ? _assert (fib (31) =: = 2178309)
+    ]**
+
+- EUnit exportará automáticamente a una función de prueba () para permitir la ejecución de las pruebas en el shell Erlang
+fib: test ()
+
+- La popular barra de herramientas de construcción de Erlang también es compatible con EUnit
+**`` ` de la unidad de barras de refuerzo
+ ``**
diff --git a/es-es/fsharp-es.html.markdown b/es-es/fsharp-es.html.markdown
new file mode 100644
index 00000000..b7f80c44
--- /dev/null
+++ b/es-es/fsharp-es.html.markdown
@@ -0,0 +1,629 @@
+---
+language: F#
+lang: es-es
+contributors:
+  - ['Scott Wlaschin', 'http://fsharpforfunandprofit.com/']
+translators:
+  - ['Angel Arciniega', 'https://github.com/AngelsProjects']
+filename: learnfsharp-es.fs
+---
+
+F# es un lenguaje de programación funcional y orientado a objetos. Es gratis y su código fuente está abierto. Se ejecuta en Linux, Mac, Windows y más.
+
+Tiene un poderoso sistema de tipado que atrapa muchos errores de tiempo de compilación, pero usa inferencias de tipados que le permiten ser leídos como un lenguaje dinámico.
+
+La sintaxis de F# es diferente de los lenguajes que heredan de C.
+
+- Las llaves no se usan para delimitar bloques de código. En cambio, se usa sangría (como en Python).
+- Los espacios se usan para separar parámetros en lugar de comas.
+
+Si quiere probar el siguiente código, puede ir a [tryfsharp.org](http://www.tryfsharp.org/Create) y pegarlo en [REPL](https://es.wikipedia.org/wiki/REPL).
+
+```fsharp
+// Los comentarios de una línea se escibren con una doble diagonal
+(* Los comentarios multilínea usan parentesis (* . . . *)
+
+-final del comentario multilínea- *)
+
+// ================================================
+// Syntaxis básica
+// ================================================
+
+// ------ "Variables" (pero no realmente) ------
+// La palabra reservada "let" define un valor (inmutable)
+let miEntero = 5
+let miFlotante = 3.14
+let miCadena = "hola"           // Tenga en cuenta que no es necesario ningún tipado
+
+// ------ Listas ------
+let dosACinco = [2;3;4;5]        // Los corchetes crean una lista con
+                                 // punto y coma para delimitadores.
+let unoACinco = 1 :: dosACinco   // :: Crea una lista con un nuevo elemento
+// El resultado es [1;2;3;4;5]
+let ceroACinco = [0;1] @ dosACinco   // @ Concatena dos listas
+
+// IMPORTANTE: las comas no se usan para delimitar,
+// solo punto y coma !
+
+// ------ Funciones ------
+// La palabra reservada "let" también define el nombre de una función.
+let cuadrado x = x * x          // Tenga en cuenta que no se usa paréntesis.
+cuadrado 3                      // Ahora, ejecutemos la función.
+                              // De nuevo, sin paréntesis.
+
+let agregar x y = x + y           // ¡No use add (x, y)! Eso significa
+                              // algo completamente diferente.
+agregar 2 3                       // Ahora, ejecutemos la función.
+
+// Para definir una función en varias líneas, usemos la sangría.
+// Los puntos y coma no son necesarios.
+let pares lista =
+   let esPar x = x%2 = 0     // Establece "esPar" como una función anidada
+   List.filter esPar lista    // List.filter es una función de la biblioteca
+                              // dos parámetros: una función que devuelve un
+                              // booleano y una lista en la que trabajar
+
+pares unoACinco               // Ahora, ejecutemos la función.
+
+// Puedes usar paréntesis para aclarar.
+// En este ejemplo, "map" se ejecuta primero, con dos argumentos,
+// entonces "sum" se ejecuta en el resultado.
+// Sin los paréntesis, "List.map" se pasará como argumento a List.sum.
+let sumaDeCuadradosHasta100 =
+   List.sum ( List.map cuadrado [1..100] )
+
+// Puedes redirigir la salida de una función a otra con "|>"
+// Redirigir datos es muy común en F#, como con los pipes de UNIX.
+
+// Aquí está la misma función sumOfSquares escrita usando pipes
+let sumaDeCuadradosHasta100piped =
+   [1..100] |> List.map cuadrado |> List.sum  // "cuadrado" se declara antes
+
+// Puede definir lambdas (funciones anónimas) gracias a la palabra clave "fun"
+let sumaDeCuadradosHasta100ConFuncion =
+   [1..100] |> List.map (fun x -> x*x) |> List.sum
+
+// En F#, no hay palabra clave "return". Una función siempre regresa
+// el valor de la última expresión utilizada.
+
+// ------ Coincidencia de patrones ------
+// Match..with .. es una sobrecarga de la condición de case/ switch.
+let coincidenciaDePatronSimple =
+   let x = "a"
+   match x with
+    | "a" -> printfn "x es a"
+    | "b" -> printfn "x es b"
+    | _ -> printfn "x es algo mas"   // guion bajo corresponde con todos los demás
+
+// F# no permite valores nulos por defecto - debe usar el tipado de Option
+// y luego coincide con el patrón.
+// Some(..) y None son aproximadamente análogos a los envoltorios Nullable
+let valorValido = Some(99)
+let valorInvalido = None
+
+// En este ejemplo, match..with encuentra una coincidencia con "Some" y "None",
+// y muestra el valor de "Some" al mismo tiempo.
+let coincidenciaDePatronDeOpciones entrada =
+   match entrada with
+    | Some i -> printfn "la entrada es un int=%d" i
+    | None -> printfn "entrada faltante"
+
+coincidenciaDePatronDeOpciones validValue
+coincidenciaDePatronDeOpciones invalidValue
+
+// ------ Viendo ------
+// Las funciones printf/printfn son similares a las funciones
+// Console.Write/WriteLine de C#.
+printfn "Imprimiendo un int %i, a float %f, a bool %b" 1 2.0 true
+printfn "Un string %s, y algo generico %A" "hola" [1;2;3;4]
+
+// También hay funciones printf/sprintfn para formatear datos
+// en cadena. Es similar al String.Format de C#.
+
+// ================================================
+// Mas sobre funciones
+// ================================================
+
+// F# es un verdadero lenguaje funcional - las funciones son
+// entidades de primer nivel y se pueden combinar fácilmente
+// para crear construcciones poderosas
+
+// Los módulos se utilizan para agrupar funciones juntas.
+// Se requiere sangría para cada módulo anidado.
+module EjemploDeFuncion =
+
+    // define una función de suma simple
+    let agregar x y = x + y
+
+    // uso básico de una función
+    let a = agregar 1 2
+    printfn "1+2 = %i" a
+
+    // aplicación parcial para "hornear en" los parámetros (?)
+    let agregar42 = agregar 42
+    let b = agregar42 1
+    printfn "42+1 = %i" b
+
+    // composición para combinar funciones
+    let agregar1 = agregar 1
+    let agregar2 = agregar 2
+    let agregar3 = agregar1 >> agregar2
+    let c = agregar3 7
+    printfn "3+7 = %i" c
+
+    // funciones de primer nivel
+    [1..10] |> List.map agregar3 |> printfn "la nueva lista es %A"
+
+    // listas de funciones y más
+    let agregar6 = [agregar1; agregar2; agregar3] |> List.reduce (>>)
+    let d = agregar6 7
+    printfn "1+2+3+7 = %i" d
+
+// ================================================
+// Lista de colecciones
+// ================================================
+
+// Il y a trois types de collection ordonnée :
+// * Les listes sont les collections immutables les plus basiques
+// * Les tableaux sont mutables et plus efficients
+// * Les séquences sont lazy et infinies (e.g. un enumerator)
+//
+// Des autres collections incluent des maps immutables et des sets
+// plus toutes les collections de .NET
+
+module EjemplosDeLista =
+
+    // las listas utilizan corchetes
+    let lista1 = ["a";"b"]
+    let lista2 = "c" :: lista1    // :: para una adición al principio
+    let lista3 = lista1 @ lista2   // @ para la concatenación
+
+    // Lista de comprensión (alias generadores)
+    let cuadrados = [for i in 1..10 do yield i*i]
+
+    //  Generador de números primos
+    let rec tamiz = function
+        | (p::xs) -> p :: tamiz [ for x in xs do if x % p > 0 then yield x ]
+        | []      -> []
+    let primos = tamiz [2..50]
+    printfn "%A" primos
+
+    // coincidencia de patrones para listas
+    let listaDeCoincidencias unaLista =
+        match unaLista with
+        | [] -> printfn "la lista esta vacia"
+        | [primero] -> printfn "la lista tiene un elemento %A " primero
+        | [primero; segundo] -> printfn "la lista es %A y %A" primero segundo
+        | _ -> printfn "la lista tiene mas de dos elementos"
+
+    listaDeCoincidencias [1;2;3;4]
+    listaDeCoincidencias [1;2]
+    listaDeCoincidencias [1]
+    listaDeCoincidencias []
+
+    // Récursion en utilisant les listes
+    let rec suma unaLista =
+        match unaLista with
+        | [] -> 0
+        | x::xs -> x + suma xs
+    suma [1..10]
+
+    // -----------------------------------------
+    // Funciones de la biblioteca estándar
+    // -----------------------------------------
+
+    // mapeo
+    let agregar3 x = x + 3
+    [1..10] |> List.map agregar3
+
+    // filtrado
+    let par x = x % 2 = 0
+    [1..10] |> List.filter par
+
+    // mucho más - consulte la documentación
+
+module EjemploDeArreglo =
+
+    // los arreglos usan corchetes con barras.
+    let arreglo1 = [| "a";"b" |]
+    let primero = arreglo1.[0]        // se accede al índice usando un punto
+
+    // la coincidencia de patrones de los arreglos es la misma que la de las listas
+    let coincidenciaDeArreglos una Lista =
+        match unaLista with
+        | [| |] -> printfn "la matriz esta vacia"
+        | [| primero |] -> printfn "el arreglo tiene un elemento %A " primero
+        | [| primero; second |] -> printfn "el arreglo es %A y %A" primero segundo
+        | _ -> printfn "el arreglo tiene mas de dos elementos"
+
+    coincidenciaDeArreglos [| 1;2;3;4 |]
+
+    // La biblioteca estándar funciona como listas
+    [| 1..10 |]
+    |> Array.map (fun i -> i+3)
+    |> Array.filter (fun i -> i%2 = 0)
+    |> Array.iter (printfn "el valor es %i. ")
+
+module EjemploDeSecuencia =
+
+    // Las secuencias usan llaves
+    let secuencia1 = seq { yield "a"; yield "b" }
+
+    // Las secuencias pueden usar yield y
+    // puede contener subsecuencias
+    let extranio = seq {
+        // "yield" agrega un elemento
+        yield 1; yield 2;
+
+        // "yield!" agrega una subsecuencia completa
+        yield! [5..10]
+        yield! seq {
+            for i in 1..10 do
+              if i%2 = 0 then yield i }}
+    // prueba
+    extranio |> Seq.toList
+
+    // Las secuencias se pueden crear usando "unfold"
+    // Esta es la secuencia de fibonacci
+    let fib = Seq.unfold (fun (fst,snd) ->
+        Some(fst + snd, (snd, fst + snd))) (0,1)
+
+    // prueba
+    let fib10 = fib |> Seq.take 10 |> Seq.toList
+    printf "Los primeros 10 fib son %A" fib10
+
+// ================================================
+// Tipos de datos
+// ================================================
+
+module EejemploDeTipoDeDatos =
+
+    // Todos los datos son inmutables por defecto
+
+     // las tuplas son tipos anónimos simples y rápidos
+     // - Usamos una coma para crear una tupla
+    let dosTuplas = 1,2
+    let tresTuplas = "a",2,true
+
+    // Combinación de patrones para desempaquetar
+    let x,y = dosTuplas  // asignado x=1 y=2
+
+    // ------------------------------------
+    // Los tipos de registro tienen campos con nombre
+    // ------------------------------------
+
+    // Usamos "type" con llaves para definir un tipo de registro
+    type Persona = {Nombre:string; Apellido:string}
+
+    // Usamos "let" con llaves para crear un registro
+    let persona1 = {Nombre="John"; Apellido="Doe"}
+
+    // Combinación de patrones para desempaquetar
+    let {Nombre=nombre} = persona1    // asignado nombre="john"
+
+    // ------------------------------------
+    // Los tipos de unión (o variantes) tienen un conjunto de elección
+     // Solo un caso puede ser válido a la vez.
+    // ------------------------------------
+
+    // Usamos "type" con barra/pipe para definir una unión estándar
+    type Temp =
+        | GradosC of float
+        | GradosF of float
+
+    // Una de estas opciones se usa para crear una
+    let temp1 = GradosF 98.6
+    let temp2 = GradosC 37.0
+
+    // Coincidencia de patrón en todos los casos para desempaquetar (?)
+    let imprimirTemp = function
+       | GradosC t -> printfn "%f gradC" t
+       | GradosF t -> printfn "%f gradF" t
+
+    imprimirTemp temp1
+    imprimirTemp temp2
+
+    // ------------------------------------
+    // Tipos recursivos
+    // ------------------------------------
+
+    // Los tipos se pueden combinar recursivamente de formas complejas
+    // sin tener que crear subclases
+    type Empleado =
+      | Trabajador of Persona
+      | Gerente of Empleado lista
+
+    let jdoe = {Nombre="John";Apellido="Doe"}
+    let trabajador = Trabajador jdoe
+
+    // ------------------------------------
+    // Modelado con tipados (?)
+    // ------------------------------------
+
+    // Los tipos de unión son excelentes para modelar el estado sin usar banderas (?)
+    type DireccionDeCorreo =
+        | DireccionDeCorreoValido of string
+        | DireccionDeCorreoInvalido of string
+
+    let intentarEnviarCorreo correoElectronico =
+        match correoElectronico with // uso de patrones de coincidencia
+        | DireccionDeCorreoValido direccion -> ()   // enviar
+        | DireccionDeCorreoInvalido direccion -> () // no enviar
+
+    // Combinar juntos, los tipos de unión y tipos de registro
+     // ofrece una base excelente para el diseño impulsado por el dominio.
+     // Puedes crear cientos de pequeños tipos que reflejarán fielmente
+     // el dominio.
+
+    type ArticuloDelCarrito = { CodigoDelProducto: string; Cantidad: int }
+    type Pago = Pago of float
+    type DatosActivosDelCarrito = { ArticulosSinPagar: ArticuloDelCarrito lista }
+    type DatosPagadosDelCarrito = { ArticulosPagados: ArticuloDelCarrito lista; Pago: Pago}
+
+    type CarritoDeCompras =
+        | CarritoVacio  // sin datos
+        | CarritoActivo of DatosActivosDelCarrito
+        | CarritoPagado of DatosPagadosDelCarrito
+
+    // ------------------------------------
+    // Comportamiento nativo de los tipos
+    // ------------------------------------
+
+    // Los tipos nativos tienen el comportamiento más útil "listo para usar", sin ningún código para agregar.
+     // * Inmutabilidad
+     // * Bonita depuración de impresión
+     // * Igualdad y comparación
+     // * Serialización
+
+     // La impresión bonita se usa con %A
+    printfn "dosTuplas=%A,\nPersona=%A,\nTemp=%A,\nEmpleado=%A"
+             dosTuplas persona1 temp1 trabajador
+
+    // La igualdad y la comparación son innatas
+     // Aquí hay un ejemplo con tarjetas.
+    type JuegoDeCartas = Trebol | Diamante | Espada | Corazon
+    type Rango = Dos | Tres | Cuatro | Cinco | Seis | Siete | Ocho
+                | Nueve | Diez | Jack | Reina | Rey | As
+
+    let mano = [ Trebol,As; Corazon,Tres; Corazon,As;
+                 Espada,Jack; Diamante,Dos; Diamante,As ]
+
+    // orden
+    List.sort mano |> printfn "la mano ordenada es (de menos a mayor) %A"
+    List.max mano |> printfn "la carta más alta es%A"
+    List.min mano |> printfn "la carta más baja es %A"
+
+// ================================================
+// Patrones activos
+// ================================================
+
+module EjemplosDePatronesActivos =
+
+    // F# tiene un tipo particular de coincidencia de patrón llamado "patrones activos"
+    // donde el patrón puede ser analizado o detectado dinámicamente.
+
+    // "clips de banana" es la sintaxis de los patrones activos
+
+    // por ejemplo, definimos un patrón "activo" para que coincida con los tipos de "caracteres" ...
+    let (|Digito|Latra|EspacioEnBlanco|Otros|) ch =
+       if System.Char.IsDigit(ch) then Digito
+       else if System.Char.IsLetter(ch) then Letra
+       else if System.Char.IsWhiteSpace(ch) then EspacioEnBlanco
+       else Otros
+
+    // ... y luego lo usamos para hacer que la lógica de análisis sea más clara
+    let ImprimirCaracter ch =
+      match ch with
+      | Digito -> printfn "%c es un Digito" ch
+      | Letra -> printfn "%c es una Letra" ch
+      | Whitespace -> printfn "%c es un Espacio en blanco" ch
+      | _ -> printfn "%c es algo mas" ch
+
+    // ver una lista
+    ['a';'b';'1';' ';'-';'c'] |> List.iter ImprimirCaracter
+
+    // -----------------------------------------
+    // FizzBuzz usando patrones activos
+    // -----------------------------------------
+
+    // Puede crear un patrón de coincidencia parcial también
+    // Solo usamos un guión bajo en la definición y devolvemos Some si coincide.
+    let (|MultDe3|_|) i = if i % 3 = 0 then Some MultDe3 else None
+    let (|MultDe5|_|) i = if i % 5 = 0 then Some MultDe5 else None
+
+    // la función principal
+    let fizzBuzz i =
+      match i with
+      | MultDe3 & MultDe5 -> printf "FizzBuzz, "
+      | MultDe3 -> printf "Fizz, "
+      | MultDe5 -> printf "Buzz, "
+      | _ -> printf "%i, " i
+
+    // prueba
+    [1..20] |> List.iter fizzBuzz
+
+// ================================================
+// concisión
+// ================================================
+
+module EjemploDeAlgoritmo =
+
+    // F# tiene una alta relación señal / ruido, lo que permite leer el código
+    // casi como un algoritmo real
+
+    // ------ Ejemplo: definir una función sumaDeCuadrados ------
+    let sumaDeCuadrados n =
+       [1..n]                   // 1) Tome todos los números del 1 al n
+       |> List.map cuadrado     // 2) Elevar cada uno de ellos al cuadrado
+       |> List.sum              // 3) Realiza su suma
+
+    // prueba
+    sumaDeCuadrados 100 |> printfn "Suma de cuadrados = %A"
+
+    // ------ Ejemplo: definir una función de ordenación ------
+    let rec ordenar lista =
+       match lista with
+       // Si la lista está vacía
+       | [] ->
+            []                              // devolvemos una lista vacía
+       // si la lista no está vacía
+       | primerElemento::otrosElementos ->  // tomamos el primer elemento
+            let elementosMasPequenios =     // extraemos los elementos más pequeños
+                otrosElementos              // tomamos el resto
+                |> List.filter (fun e -> e < primerElemento)
+                |> ordenar                  // y los ordenamos
+            let elementosMasGrandes =       // extraemos el mas grande
+                otrosElementos              // de los que permanecen
+                |> List.filter (fun e -> e >= primerElemento)
+                |> ordenar                  // y los ordenamos
+            // Combinamos las 3 piezas en una nueva lista que devolvemos
+            List.concat [elementosMasPequenios; [primerElemento]; elementosMasGrandes]
+
+    // prueba
+    ordenar [1;5;23;18;9;1;3] |> printfn "Ordenado = %A"
+
+// ================================================
+// Código asíncrono
+// ================================================
+
+module AsyncExample =
+
+    // F# incluye características para ayudar con el código asíncrono
+    // sin conocer la "pirámide del destino"
+    //
+    // El siguiente ejemplo descarga una secuencia de página web en paralelo.
+
+    open System.Net
+    open System
+    open System.IO
+    open Microsoft.FSharp.Control.CommonExtensions
+
+    // Recuperar el contenido de una URL de forma asincrónica
+    let extraerUrlAsync url =
+        async {   // La palabra clave "async" y llaves
+                  // crear un objeto "asincrónico"
+            let solicitud = WebRequest.Create(Uri(url))
+            use! respuesta = solicitud.AsyncGetResponse()
+                // use! es una tarea asincrónica
+            use flujoDeDatos = resp.GetResponseStream()
+                // "use" dispara automáticamente la funcion close()
+                // en los recursos al final de las llaves
+            use lector = new IO.StreamReader(flujoDeDatos)
+            let html = lector.ReadToEnd()
+            printfn "terminó la descarga %s" url
+            }
+
+    // una lista de sitios para informar
+    let sitios = ["http://www.bing.com";
+                 "http://www.google.com";
+                 "http://www.microsoft.com";
+                 "http://www.amazon.com";
+                 "http://www.yahoo.com"]
+
+    // ¡Aqui vamos!
+    sitios
+    |> List.map extraerUrlAsync // crear una lista de tareas asíncrona
+    |> Async.Parallel           // decirle a las tareas que se desarrollan en paralelo
+    |> Async.RunSynchronously   // ¡Empieza!
+
+// ================================================
+// Compatibilidad .NET
+// ================================================
+
+module EjemploCompatibilidadNet =
+
+    // F# puede hacer casi cualquier cosa que C# pueda hacer, y se ajusta
+    // perfectamente con bibliotecas .NET o Mono.
+
+    // ------- Trabaja con las funciones de las bibliotecas existentes  -------
+
+    let (i1success,i1) = System.Int32.TryParse("123");
+    if i1success then printfn "convertido como %i" i1 else printfn "conversion fallida"
+
+    // ------- Implementar interfaces sobre la marcha! -------
+
+    // Crea un nuevo objeto que implemente IDisposable
+    let crearRecurso name =
+       { new System.IDisposable
+         with member this.Dispose() = printfn "%s creado" name }
+
+    let utilizarYDisponerDeRecursos =
+        use r1 = crearRecurso "primer recurso"
+        printfn "usando primer recurso"
+        for i in [1..3] do
+            let nombreDelRecurso = sprintf "\tinner resource %d" i
+            use temp = crearRecurso nombreDelRecurso
+            printfn "\thacer algo con %s" nombreDelRecurso
+        use r2 = crearRecurso "segundo recurso"
+        printfn "usando segundo recurso"
+        printfn "hecho."
+
+    // ------- Código orientado a objetos -------
+
+    // F# es también un verdadero lenguaje OO.
+    // Admite clases, herencia, métodos virtuales, etc.
+
+    // interfaz de tipo genérico
+    type IEnumerator<'a> =
+        abstract member Actual : 'a
+        abstract MoverSiguiente : unit -> bool
+
+    // Clase base abstracta con métodos virtuales
+    [<AbstractClass>]
+    type Figura() =
+        // propiedades de solo lectura
+        abstract member Ancho : int with get
+        abstract member Alto : int with get
+        // método no virtual
+        member this.AreaDelimitadora = this.Alto * this.Ancho
+        // método virtual con implementación de la clase base
+        abstract member Imprimir : unit -> unit
+        default this.Imprimir () = printfn "Soy una Figura"
+
+    // clase concreta que hereda de su clase base y sobrecarga
+    type Rectangulo(x:int, y:int) =
+        inherit Figura()
+        override this.Ancho = x
+        override this.Alto = y
+        override this.Imprimir ()  = printfn "Soy un Rectangulo"
+
+    // prueba
+    let r = Rectangulo(2,3)
+    printfn "La anchura es %i" r.Ancho
+    printfn "El area es %i" r.AreaDelimitadora
+    r.Imprimir()
+
+    // ------- extensión de método  -------
+
+    // Al igual que en C#, F# puede extender las clases existentes con extensiones de método.
+    type System.String with
+       member this.EmpiezaConA = this.EmpiezaCon "A"
+
+    // prueba
+    let s = "Alice"
+    printfn "'%s' empieza con una 'A' = %A" s s.EmpiezaConA
+
+    // ------- eventos -------
+
+    type MiBoton() =
+        let eventoClick = new Event<_>()
+
+        [<CLIEvent>]
+        member this.AlHacerClick = eventoClick.Publish
+
+        member this.PruebaEvento(arg) =
+            eventoClick.Trigger(this, arg)
+
+    // prueba
+    let miBoton = new MiBoton()
+    miBoton.AlHacerClick.Add(fun (sender, arg) ->
+            printfn "Haga clic en el evento con arg=%O" arg)
+
+    miBoton.PruebaEvento("Hola Mundo!")
+```
+
+## Más información
+
+Para más demostraciones de F#, visite el sitio [Try F#](http://www.tryfsharp.org/Learn), o sigue la serie [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/).
+
+Aprenda más sobre F# en [fsharp.org](http://fsharp.org/).
diff --git a/es-es/lambda-calculus-es.html.markdown b/es-es/lambda-calculus-es.html.markdown
new file mode 100644
index 00000000..d49545c2
--- /dev/null
+++ b/es-es/lambda-calculus-es.html.markdown
@@ -0,0 +1,216 @@
+---
+category: Algorithms & Data Structures
+name: Lambda Calculus
+contributors:
+    - ["Max Sun", "http://github.com/maxsun"]
+    - ["Yan Hui Hang", "http://github.com/yanhh0"]
+translators:
+    - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+---
+
+# Cálculo Lambda
+
+Cálculo Lambda (Cálculo-λ), originalmente creado por 
+[Alonzo Church](https://es.wikipedia.org/wiki/Alonzo_Church),
+es el lenguaje de programación más pequeño del mundo.
+A pesar de no tener números, cadenas, valores booleanos o cualquier 
+tipo de datos no funcional, el cálculo lambda se puede utilizar para 
+representar cualquier máquina de Turing.
+
+El cálculo lambda se compone de 3 elementos: **variables**, **funciones** y
+**aplicaciones**.
+
+| Nombre        | Sintaxis                             | Ejemplo   | Explicación                                   |
+|-------------|------------------------------------|-----------|-----------------------------------------------|
+| Variable    | `<nombre>`                           | `x`       | una variable llamada "x"                          |
+| Función    | `λ<parámetro>.<cuerpo>`             | `λx.x`    | una función con parámetro "x" y cuerpo "x"    |
+| Aplicación | `<función><variable o función>` | `(λx.x)a` | llamando a la función "λx.x" con el argumento "a" |
+
+La función más básica es la función de identidad: `λx.x` que es equivalente a
+`f(x) = x`. La primera "x" es el argumento de la función y la segunda es el 
+cuerpo de la función.
+
+## Variables Libres vs. Enlazadas:
+
+- En la función `λx.x`, "x" se llama una variable enlazada porque está tanto en
+ el cuerpo de la función como en el parámetro.
+- En `λx.y`, "y" se llama variable libre porque nunca se declara de antemano.
+
+## Evaluación:
+
+Evaluación se realiza a través de
+[β-Reduction](https://es.wikipedia.org/wiki/C%C3%A1lculo_lambda#%CE%B2-reducci%C3%B3n),
+que es, esencialmente, sustitución de ámbito léxico.
+
+Al evaluar la expresión `(λx.x)a`, reemplazamos todas las ocurrencias de "x" 
+en el cuerpo de la función con "a".
+
+- `(λx.x)a` evalúa a: `a`
+- `(λx.y)a` evalúa a: `y`
+
+Incluso puedes crear funciones de orden superior:
+
+- `(λx.(λy.x))a` evalúa a: `λy.a`
+
+Aunque el cálculo lambda tradicionalmente solo admite funciones 
+de un solo parámetro, podemos crear funciones multiparamétricas usando 
+una técnica llamada [Currificación](https://es.wikipedia.org/wiki/Currificación).
+
+- `(λx.λy.λz.xyz)` es equivalente a `f(x, y, z) = ((x y) z)`
+
+Algunas veces `λxy.<cuerpo>` es usado indistintamente con: `λx.λy.<cuerpo>`
+
+----
+
+Es importante reconocer que el cálculo lambda tradicional **no tiene números, 
+caracteres ni ningún tipo de datos que no sea de función.**
+
+## Lógica Booleana:
+
+No hay "Verdadero" o "Falso" en el cálculo lambda. Ni siquiera hay un 1 o un 0.
+
+En vez:
+
+`T` es representado por: `λx.λy.x`
+
+`F` es representado por: `λx.λy.y`
+
+Primero, podemos definir una función "if" `λbtf` que devuelve 
+`t` si `b` es Verdadero y `f` si `b` es Falso
+
+`IF` es equivalente a: `λb.λt.λf.b t f`
+
+Usando `IF` podemos definir los operadores lógicos booleanos básicos:
+
+`a AND b` es equivalente a: `λab.IF a b F`
+
+`a OR b` es equivalente a: `λab.IF a T b`
+
+`a NOT b` es equivalente a: `λa.IF a F T`
+
+*Note: `IF a b c` es esencialmente diciendo: `IF((a b) c)`*
+
+## Números:
+
+Aunque no hay números en el cálculo lambda, podemos codificar números usando 
+[Númeral de Church](https://en.wikipedia.org/wiki/Church_encoding).
+
+Para cualquier número n: <code>n = λf.f <sup> n </sup></code> así:
+
+`0 = λf.λx.x`
+
+`1 = λf.λx.f x`
+
+`2 = λf.λx.f(f x)`
+
+`3 = λf.λx.f(f(f x))`
+
+Para incrementar un númeral de Church, usamos la función sucesora 
+`S(n) = n + 1` que es:
+
+`S = λn.λf.λx.f((n f) x)`
+
+Usando el sucesor, podemos definir AGREGAR:
+
+`AGREGAR = λab.(a S)n`
+
+**Desafío:** intenta definir tu propia función de multiplicación!
+
+## Vamos más pequeño: SKI, SK y Iota
+
+### Combinador de SKI
+
+Sean S, K, I las siguientes funciones:
+
+`I x = x`
+
+`K x y =  x`
+
+`S x y z = x z (y z)`
+
+Podemos convertir una expresión en el cálculo lambda en una expresión 
+en el cálculo del combinador de SKI:
+
+1. `λx.x = I`
+2. `λx.c = Kc`
+3. `λx.(y z) = S (λx.y) (λx.z)`
+
+Tome el número 2 de Church por ejemplo:
+
+`2 = λf.λx.f(f x)`
+
+Para la parte interior `λx.f(f x)`:
+```
+  λx.f(f x)
+= S (λx.f) (λx.(f x))          (case 3)
+= S (K f)  (S (λx.f) (λx.x))   (case 2, 3)
+= S (K f)  (S (K f) I)         (case 2, 1)
+```
+
+Así que:
+```
+  2
+= λf.λx.f(f x)
+= λf.(S (K f) (S (K f) I))
+= λf.((S (K f)) (S (K f) I))
+= S (λf.(S (K f))) (λf.(S (K f) I)) (case 3)
+```
+
+Para el primer argumento `λf.(S (K f))`:
+```
+  λf.(S (K f))
+= S (λf.S) (λf.(K f))       (case 3)
+= S (K S) (S (λf.K) (λf.f)) (case 2, 3)
+= S (K S) (S (K K) I)       (case 2, 3)
+```
+
+Para el segundo argumento `λf.(S (K f) I)`:
+```
+  λf.(S (K f) I)
+= λf.((S (K f)) I)
+= S (λf.(S (K f))) (λf.I)             (case 3)
+= S (S (λf.S) (λf.(K f))) (K I)       (case 2, 3)
+= S (S (K S) (S (λf.K) (λf.f))) (K I) (case 1, 3)
+= S (S (K S) (S (K K) I)) (K I)       (case 1, 2)
+```
+
+Uniéndolos:
+```
+  2
+= S (λf.(S (K f))) (λf.(S (K f) I))
+= S (S (K S) (S (K K) I)) (S (S (K S) (S (K K) I)) (K I))
+```
+
+Al expandir esto, terminaríamos con la misma expresión para el número 2 de Church nuevamente.
+
+### Cálculo del combinador SKI
+
+El cálculo del combinador SKI puede reducirse aún más. Podemos eliminar 
+el combinador I observando que `I = SKK`. Podemos sustituir 
+todos los 'I' con `SKK`.
+
+### Combinador Iota
+
+El cálculo del combinador SK todavía no se encuentra en su expresión mínima. 
+Definiendo:
+
+```
+ι = λf.((f S) K)
+```
+
+Tenemos que:
+
+```
+I = ιι
+K = ι(ιI) = ι(ι(ιι))
+S = ι(K) = ι(ι(ι(ιι)))
+```
+
+## Para una lectura más avanzada:
+
+1. [A Tutorial Introduction to the Lambda Calculus](http://www.inf.fu-berlin.de/lehre/WS03/alpi/lambda.pdf)
+2. [Cornell CS 312 Recitation 26: The Lambda Calculus](http://www.cs.cornell.edu/courses/cs3110/2008fa/recitations/rec26.html)
+3. [Wikipedia - Lambda Calculus](https://es.wikipedia.org/wiki/Cálculo_lambda)
+4. [Wikipedia - SKI combinator calculus](https://en.wikipedia.org/wiki/SKI_combinator_calculus)
+5. [Wikipedia - Iota and Jot](https://en.wikipedia.org/wiki/Iota_and_Jot)
diff --git a/es-es/learnsmallbasic-es.html.markdown b/es-es/learnsmallbasic-es.html.markdown
index 21208792..ff320afb 100644
--- a/es-es/learnsmallbasic-es.html.markdown
+++ b/es-es/learnsmallbasic-es.html.markdown
@@ -18,7 +18,7 @@ SmallBASIC fue desarrollado originalmente por Nicholas Christopoulos a finales d
 Versiones de SmallBASIC se han hecho para una serie dispositivos de mano antiguos, incluyendo Franklin eBookman y el Nokia 770. También se han publicado varias versiones de escritorio basadas en una variedad de kits de herramientas GUI, algunas de las cuales han desaparecido. Las plataformas actualmente soportadas son Linux y Windows basadas en SDL2 y Android basadas en NDK. También está disponible una versión de línea de comandos de escritorio, aunque no suele publicarse en formato binario.
 Alrededor de 2008 una gran corporación lanzó un entorno de programación BASIC con un nombre de similar. SmallBASIC no está relacionado con este otro proyecto.
 
-```SmallBASIC
+```
 REM Esto es un comentario
 ' y esto tambien es un comentario
 
diff --git a/es-es/matlab-es.html.markdown b/es-es/matlab-es.html.markdown
new file mode 100644
index 00000000..9f1656bb
--- /dev/null
+++ b/es-es/matlab-es.html.markdown
@@ -0,0 +1,568 @@
+---
+language: Matlab
+filename: learnmatlab-es.mat
+contributors:
+    - ["mendozao", "http://github.com/mendozao"]
+    - ["jamesscottbrown", "http://jamesscottbrown.com"]
+    - ["Colton Kohnke", "http://github.com/voltnor"]
+    - ["Claudson Martins", "http://github.com/claudsonm"]
+translators:
+    - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+---
+
+MATLAB significa 'MATrix LABoratory'. Es un poderoso lenguaje de computación numérica comúnmente usado en ingeniería y matemáticas.
+
+Si tiene algún comentario, no dude en ponerse en contacto el autor en
+[@the_ozzinator](https://twitter.com/the_ozzinator), o
+[osvaldo.t.mendoza@gmail.com](mailto:osvaldo.t.mendoza@gmail.com).
+
+```matlab
+%% Una sección de código comienza con dos símbolos de porcentaje. Los títulos de la sección van en la misma líneas.
+% Los comentarios comienzan con un símbolo de porcentaje.
+
+%{
+Los Comentarios de multiples líneas se
+ven
+como 
+esto
+%}
+
+% Dos símbolos de porcentaje denotan el comienzo de una nueva sección de código.
+% Secciones de código individuales pueden ser ejecutadas moviendo el cursor hacia la sección,
+% seguida por un clic en el botón de “Ejecutar Sección”
+% o usando Ctrl+Shift+Enter (Windows) o Cmd+Shift+Return (OS X)
+
+%% Este es el comienzo de una sección de código
+% Una forma de usar las secciones es separar un código de inicio costoso que no cambia, como cargar datos
+load learnmatlab.mat y
+
+%% Esta es otra sección de código
+% Esta sección puede ser editada y ejecutada de manera repetida por sí misma, 
+% y es útil para la programación exploratoria y demostraciones.
+A = A * 2;
+plot(A);
+
+%% Las secciones de código también son conocidas como celdas de código o modo celda (no ha de ser confundido con arreglo de celdas)
+
+
+% Los comandos pueden abarcar varias líneas, usando '...'
+ a = 1 + 2 + ...
+ + 4
+
+% Los comandos se pueden pasar al sistema operativo
+!ping google.com
+
+who % Muestra todas las variables en la memoria
+whos % Muestra todas las variables en la memoria con sus tipos
+clear % Borra todas tus variables de la memoria
+clear('A') % Borra una variable en particular
+openvar('A') % Variable abierta en editor de variables
+
+clc % Borra la escritura en la ventana de Comando
+diary % Alterna la escritura del texto de la ventana de comandos al archivo
+ctrl-c % Aborta el cálculo actual
+
+edit('myfunction.m') % Abrir función/script en el editor
+type('myfunction.m') % Imprime la fuente de la función/script en la ventana de comandos
+
+profile on 	% Enciende el generador de perfilador de código
+profile off 	% Apaga el generador de perfilador de código
+profile viewer 	% Abre el perfilador de código
+
+help command 	% Muestra la documentación del comando en la ventana de comandos
+doc command 	% Muestra la documentación del comando en la ventana de Ayuda
+lookfor command % Busca el comando en la primera línea comentada de todas las funciones
+lookfor command -all % busca el comando en todas las funciones
+
+
+% Formato de salida
+format short 	% 4 decimales en un número flotante
+format long 	% 15 decimales
+format bank 	% solo dos dígitos después del punto decimal - para cálculos financieros
+fprintf('texto') % imprime "texto" en la pantalla
+disp('texto') 	% imprime "texto" en la pantalla
+
+% Variables y expresiones
+myVariable = 4 	% Espacio de trabajo de aviso muestra la variable recién creada
+myVariable = 4; % Punto y coma suprime la salida a la Ventana de Comando
+4 + 6  		% ans = 10
+8 * myVariable 	% ans = 32
+2 ^ 3 		% ans = 8
+a = 2; b = 3;
+c = exp(a)*sin(pi/2) % c = 7.3891
+
+% Llamar funciones se pueden realizar de dos maneras:
+% Sintaxis de función estándar:
+load('myFile.mat', 'y') % argumentos entre paréntesis, separados por comas
+% Sintaxis del comando:
+load myFile.mat y 	% sin paréntesis, y espacios en lugar de comas
+% Tenga en cuenta la falta de comillas en el formulario de comandos: 
+% las entradas siempre se pasan como texto literal; no pueden pasar valores de variables.
+% Además, no puede recibir salida:
+[V,D] = eig(A);  % esto no tiene equivalente en forma de comando
+[~,D] = eig(A);  % si solo se quiere D y no V
+
+
+
+% Operadores lógicos
+1 > 5 % ans = 0
+10 >= 10 % ans = 1
+3 ~= 4 % No es igual a -> ans = 1
+3 == 3 % Es igual a -> ans = 1
+3 > 1 && 4 > 1 % AND -> ans = 1
+3 > 1 || 4 > 1 % OR -> ans = 1
+~1 % NOT -> ans = 0
+
+% Los operadores lógicos se pueden aplicar a matrices:
+A > 5
+% para cada elemento, si la condición es verdadera, ese elemento es 1 en la matriz devuelta
+A( A > 5 )
+% devuelve un vector que contiene los elementos en A para los que la condición es verdadera
+
+% Cadenas
+a = 'MiCadena'
+length(a) % ans = 8
+a(2) % ans = y
+[a,a] % ans = MiCadenaMiCadena
+
+
+% Celdas
+a = {'uno', 'dos', 'tres'}
+a(1) % ans = 'uno' - retorna una celda
+char(a(1)) % ans = uno - retorna una cadena
+
+% Estructuras
+A.b = {'uno','dos'};
+A.c = [1 2];
+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:3) % ans = 32 53
+x(2:end) % ans = 32 53 7 1
+
+x = [4; 32; 53; 7; 1] % Vector de columna
+
+x = [1:10] % x = 1 2 3 4 5 6 7 8 9 10
+x = [1:2:10] % Incrementa por 2, i.e. x = 1 3 5 7 9
+
+% Matrices
+A = [1 2 3; 4 5 6; 7 8 9]
+% Las filas están separadas por un punto y coma; los elementos se separan con espacio o coma
+% A =
+
+%     1     2     3
+%     4     5     6
+%     7     8     9
+
+A(2,3) % ans = 6, A(fila, columna)
+A(6) % ans = 8
+% (concatena implícitamente columnas en el vector, luego indexa en base a esto)
+
+
+A(2,3) = 42 % Actualiza la fila 2 col 3 con 42
+% A =
+
+%     1     2     3
+%     4     5     42
+%     7     8     9
+
+A(2:3,2:3) % Crea una nueva matriz a partir de la anterior
+%ans =
+
+%     5     42
+%     8     9
+
+A(:,1) % Todas las filas en la columna 1
+%ans =
+
+%     1
+%     4
+%     7
+
+A(1,:) % Todas las columnas en la fila 1
+%ans =
+
+%     1     2     3
+
+[A ; A] % Concatenación de matrices (verticalmente)
+%ans =
+
+%     1     2     3
+%     4     5    42
+%     7     8     9
+%     1     2     3
+%     4     5    42
+%     7     8     9
+
+% esto es lo mismo que
+vertcat(A,A);
+
+
+[A , A] % Concatenación de matrices (horizontalmente)
+
+%ans =
+
+%     1     2     3     1     2     3
+%     4     5    42     4     5    42
+%     7     8     9     7     8     9
+
+% esto es lo mismo que
+horzcat(A,A);
+
+
+A(:, [3 1 2]) % Reorganiza las columnas de la matriz original
+%ans =
+
+%     3     1     2
+%    42     4     5
+%     9     7     8
+
+size(A) % ans = 3 3
+
+A(1, :) =[] % Elimina la primera fila de la matriz
+A(:, 1) =[] % Elimina la primera columna de la matriz
+
+transpose(A) % Transponer la matriz, que es lo mismo que:
+A one
+ctranspose(A) % Hermitian transpone la matriz
+% (la transposición, seguida de la toma del conjugado complejo de cada elemento)
+A' % Versión concisa de transposición compleja
+A.' % Versión concisa de transposición (sin tomar complejo conjugado)
+
+
+
+
+% Elemento por elemento Aritmética vs. Matriz Aritmética
+% Por sí solos, los operadores aritméticos actúan sobre matrices completas. Cuando preceden
+% por un punto, actúan en cada elemento en su lugar. Por ejemplo:
+A * B % Multiplicación de matrices
+A .* B % Multiplica cada elemento en A por su elemento correspondiente en B
+
+% Hay varios pares de funciones, donde una actúa sobre cada elemento y 
+% la otra (cuyo nombre termina en m) actúa sobre la matriz completa.
+exp(A) % exponencializar cada elemento
+expm(A) % calcular la matriz exponencial
+sqrt(A) % tomar la raíz cuadrada de cada elemento
+sqrtm(A) % encuentra la matriz cuyo cuadrado es A
+
+
+% Trazando
+x = 0:.10:2*pi; % Crea un vector que comienza en 0 y termina en 2 * pi con incrementos de .1
+y = sin(x);
+plot(x,y)
+xlabel('x axis')
+ylabel('y axis')
+title('Plot of y = sin(x)')
+axis([0 2*pi -1 1]) % x rango de 0 a 2 * pi, y rango de -1 a 1
+
+plot(x,y1,'-',x,y2,'--',x,y3,':') % Para múltiples funciones en una parcela.
+legend('Line 1 label', 'Line 2 label') % Etiquetar curvas con una leyenda.
+
+% Método alternativo para trazar múltiples funciones en una parcela.
+% mientras 'hold' está activado, los comandos se agregan al gráfico existente en lugar de reemplazarlo.
+plot(x, y)
+hold on
+plot(x, z)
+hold off
+
+loglog(x, y) % Un diagrama de log-log.
+semilogx(x, y) % Un diagrama con el eje x logarítmico.
+semilogy(x, y) % Un diagrama con el eje y logarítmico.
+
+fplot (@(x) x^2, [2,5]) % Un diagrama con el eje y logarítmico...
+
+grid on % Muestra la cuadrícula; apague con 'grid off'.
+axis square % Hace que la región actual de los ejes sea cuadrada.
+axis equal % Establece la relación de aspecto para que las unidades de datos sean las mismas en todas las direcciones.
+
+scatter(x, y); % Gráfico de dispersión
+hist(x); % Histograma
+stem(x); % Traza los valores como tallos, útiles para mostrar datos discretos.
+bar(x); % Diagrama de barras
+
+z = sin(x);
+plot3(x,y,z); % Trazado de línea 3D.
+
+pcolor(A) % Trazado de línea 3D...
+contour(A) % Diagrama de contorno de la matriz.
+mesh(A) % Traza una superficie de malla.
+
+h = figure % Crea nuevo objeto figura, con el mango h.
+figure(h) % Hace que la figura correspondiente al mango h la figura actual.
+close(h) % Cierra la figura con mango h.
+close all % Cierra todas las ventanas con figura abierta.
+close % Cierra ventana de figura actual.
+
+shg % Trae una ventana gráfica existente hacia adelante, o crea una nueva si es necesario.
+clf clear % Borra la ventana de la figura actual y restablece la mayoría de las propiedades de la figura.
+
+% Las propiedades se pueden establecer y cambiar a través de un identificador de figura.
+% Puede guardar un identificador de una figura cuando la crea.
+% La función get devuelve un handle a la figura actual
+h = plot(x, y); % Puedes guardar un control de una figura cuando la creas
+set(h, 'Color', 'r')
+% 'y' yellow; 'm' magenta, 'c' cyan, 'r' red, 'g' green, 'b' blue, 'w' white, 'k' black
+set(h, 'LineStyle', '--')
+% '--' es línea continua, '---' discontinua, ':' punteada, '-.' dash-dot, 'none' es sin línea
+get (h, 'LineStyle')
+
+
+% La función gca devuelve un mango a los ejes para la figura actual
+set(gca, 'XDir', 'reverse'); % invierte la dirección del eje x
+
+% Para crear una figura que contenga varios ejes en posiciones de mosaico, use 'subplot'
+subplot(2,3,1); % seleccione la primera posición en una grilla de subtramas de 2 por 3
+plot(x1); title('First Plot') % traza algo en esta posición
+subplot(2,3,2); % selecciona la segunda posición en la grilla
+plot(x2); title('Second Plot') % trazar algo allí
+
+
+% Para usar funciones o scripts, deben estar en su ruta o directorio actual
+path % muestra la ruta actual
+addpath /path/to/dir % agrega a la ruta
+rmpath /path/to/dir % elimina de la ruta
+cd /path/to/move/into % cambia de directorio
+
+
+% Las variables se pueden guardar en archivos .mat
+save('myFileName.mat') % Guarda las variables en su espacio de trabajo
+load('myFileName.mat') % Carga las variables guardadas en espacio de trabajo
+
+% M-file Scripts
+% Un archivo de script es un archivo externo que contiene una secuencia de instrucciones.
+% Permiten evitar escribir repetidamente el mismo código en la ventana de comandos
+% Tienen extensiones .m
+
+% M-file Functions
+% Al igual que los scripts, y tienen la misma extensión .m
+% Pero pueden aceptar argumentos de entrada y devolver una salida
+% Además, tienen su propio espacio de trabajo (es decir, diferente alcance variable).
+% El nombre de la función debe coincidir con el nombre del archivo (por lo tanto, guarde este ejemplo como double_input.m).
+% 'help double_input.m' devuelve los comentarios en la línea que comienza la función
+function output = double_input(x)
+	% double_input(x) devuelve el doble del valor de x
+	output = 2*x;
+end
+double_input(6) % ans = 12
+
+
+% También puede tener subfunciones y funciones anidadas.
+% Las subfunciones están en el mismo archivo que la función primaria, y solo pueden ser
+% llamadas por funciones en el archivo. Las funciones anidadas se definen dentro de otra
+% otras funciones y tienen acceso tanto a su área de trabajo como a su propio espacio de trabajo.
+
+% Si desea crear una función sin crear un nuevo archivo, puede usar una
+% función anónima. Útil cuando se define rápidamente una función para pasar a
+% otra función (por ejemplo, trazar con fplot, evaluar una integral indefinida
+% con quad, encuentra roots con fzero, o encuentra mínimo con fminsearch).
+% Ejemplo que devuelve el cuadrado de su entrada, asignado al identificador sqr:
+sqr = @(x) x.^2;
+sqr(10) % ans = 100
+doc function_handle % averiguar más
+
+% User input
+a = input('Ingrese el valor:')
+
+% Detiene la ejecución del archivo y le da control al teclado: el usuario puede examinar
+% o cambiar las variables. Escriba 'return' para continuar la ejecución, o 'dbquit' para salir del teclado
+
+% Lectura de datos (también xlsread / importdata / imread para archivos de excel / CSV / image)
+fopen(filename)
+
+% Salida
+disp(a) % Imprime el valor de la variable a
+disp('Hola Mundo') % Imprime una cadena
+fprintf % Imprime en la ventana de comandos con más control
+
+% Declaraciones condicionales (los paréntesis son opcionales, pero buen estilo)
+if (a > 15)
+	disp('Mayor que 15')
+elseif (a == 23)
+	disp('a es 23')
+else
+	disp('Ninguna condicion se ha cumplido')
+end
+
+% Bucles
+% NB. haciendo un bucle sobre los elementos de un vector / matriz es lento!
+% Siempre que sea posible, use funciones que actúen en todo el vector / matriz a la vez
+for k = 1:5
+	disp(k)
+end
+
+k = 0;
+while (k < 5)
+	k = k + 1;
+end
+
+% Ejecución del código de tiempo: 'toc' imprime el tiempo desde que se llamó 'tic'
+tic
+A = rand(1000);
+A*A*A*A*A*A*A;
+toc
+
+% Conectarse a una base de datos MySQL
+dbname = 'database_name';
+username = 'root';
+password = 'root';
+driver = 'com.mysql.jdbc.Driver';
+dburl = ['jdbc:mysql://localhost:8889/' dbname];
+javaclasspath('mysql-connector-java-5.1.xx-bin.jar'); %xx depende de la versión, descarga disponible en http://dev.mysql.com/downloads/connector/j/
+conn = database(dbname, username, password, driver, dburl);
+sql = ['SELECT * from table_name where id = 22'] % Ejemplo de instrucción sql
+a = fetch(conn, sql) %a contendrá sus datos
+
+
+% Funciones matemáticas comunes
+sin(x)
+cos(x)
+tan(x)
+asin(x)
+acos(x)
+atan(x)
+exp(x)
+sqrt(x)
+log(x)
+log10(x)
+abs(x) % Si x es complejo, devuelve la magnitud
+min(x)
+max(x)
+ceil(x)
+floor(x)
+round(x)
+rem(x)
+rand % Números pseudoaleatorios distribuidos uniformemente
+randi % Enteros pseudoaleatorios distribuidos uniformemente
+randn % Números pseudoaleatorios distribuidos normalmente
+
+% Operaciones matemáticas complejas
+abs(x) 	 % Magnitud de la variable compleja x
+phase(x) % Fase (o ángulo) de la variable compleja x
+real(x)  % Retorna la parte real de x (es decir, devuelve a si x = a + jb)
+imag(x)  % Retorna la parte imaginaria de x (es decir, devuelve b si x = a + jb)
+conj(x)  % Retorna el complejo conjugado 
+
+
+% Constantes comunes
+pi
+NaN
+inf
+
+% Resolviendo ecuaciones matriciales (si no hay solución, devuelve una solución de mínimos cuadrados)
+%Los operadores \ y / son equivalentes a las funciones mldivide y mrdivide
+x=A\b % Resuelve Ax = b. Más rápido y más numéricamente preciso que usar inv (A) * b.
+x=b/A % Resuelve xA = b
+
+inv(A) % calcular la matriz inversa
+pinv(A) % calcular el pseudo-inverso
+
+% Funciones de matriz comunes
+zeros(m,n) % m x n matriz de 0
+ones(m,n) % m x n matriz de 1
+diag(A) % Extrae los elementos diagonales de una matriz A
+diag(x) % Construya una matriz con elementos diagonales enumerados en x, y ceros en otra parte
+eye(m,n) % Matriz de identidad
+linspace(x1, x2, n) % Devuelve n puntos equiespaciados, con min x1 y max x2
+inv(A) % Inverso de la matriz A
+det(A) % Determinante de A
+eig(A) % Valores propios y vectores propios de A
+trace(A) % Traza de la matriz: equivalente a sum(diag(A))
+isempty(A) % Determina si la matriz está vacía
+all(A) % Determina si todos los elementos son distintos de cero o verdaderos
+any(A) % Determina si alguno de los elementos es distinto de cero o verdadero
+isequal(A, B) % Determina la igualdad de dos matrices
+numel(A) % Cantidad de elementos en matriz
+triu(x) % Devuelve la parte triangular superior de x
+tril(x) % Devuelve la parte triangular inferior de x
+cross(A,B) % Devuelve el producto cruzado de los vectores A y B
+dot(A,B) % Devuelve un producto escalar de dos vectores (debe tener la misma longitud)
+transpose(A) % Devuelve la transposición de A
+fliplr(A) % Voltea la matriz de izquierda a derecha
+flipud(A) % Voltea la matriz de arriba hacia abajo
+
+% Factorizaciones de matrices
+[L, U, P] = lu(A) % Descomposición LU: PA = LU, L es triangular inferior, U es triangular superior, P es matriz de permutación
+[P, D] = eig(A) % eigen-decomposition: AP = PD, las columnas de P son autovectores y las diagonales de D'son valores propios
+[U,S,V] = svd(X) % SVD: XV = US, U y V son matrices unitarias, S tiene elementos diagonales no negativos en orden decreciente
+
+% Funciones comunes de vectores
+max     % componente más grande
+min     % componente más pequeño
+length  % longitud de un vector
+sort    % ordenar en orden ascendente
+sum     % suma de elementos
+prod    % producto de elementos
+mode    % valor modal
+median  % valor mediano
+mean    % valor medio
+std     % desviación estándar
+perms(x) % enumera todas las permutaciones de elementos de x
+find(x) % Encuentra todos los elementos distintos de cero de x y devuelve sus índices, puede usar operadores de comparación,
+        % i.e. find( x == 3 ) devuelve índices de elementos que son iguales a 3
+        % i.e. find( x >= 3 ) devuelve índices de elementos mayores o iguales a 3
+
+
+% Clases
+% 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
+classdef WaypointClass % El nombre de la clase.
+  properties % Las propiedades de la clase se comportan como Estructuras
+    latitude 
+    longitude 
+  end
+  methods 
+    % Este método que tiene el mismo nombre de la clase es el constructor.
+    function obj = WaypointClass(lat, lon)
+      obj.latitude = lat;
+      obj.longitude = lon;
+    end
+
+    % Otras funciones que usan el objeto Waypoint
+    function r = multiplyLatBy(obj, n)
+      r = n*[obj.latitude];
+    end
+
+    % Si queremos agregar dos objetos Waypoint juntos sin llamar
+    % 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]);
+    end
+  end
+end
+% Fin WaypointClass.m
+
+% 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.
+a.latitude = 70.0
+a.longitude = 25.0
+
+% Los métodos se pueden llamar de la misma manera que las funciones
+ans = multiplyLatBy(a,3)
+
+% El método también se puede llamar usando notación de puntos. En este caso, el objeto
+% 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
+% la adición de dos objetos Waypoint.
+b = WaypointClass(15.0, 32.0)
+c = a + b
+
+```
+
+## 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/)
+* [Loren on the Art of MATLAB (EN)](http://blogs.mathworks.com/loren/)
+* [Cleve's Corner (EN)](http://blogs.mathworks.com/cleve/)
+
diff --git a/es-es/pascal-es.html.markdown b/es-es/pascal-es.html.markdown
new file mode 100644
index 00000000..8328fa1e
--- /dev/null
+++ b/es-es/pascal-es.html.markdown
@@ -0,0 +1,205 @@
+---
+language: Pascal
+filename: learnpascal-es.pas
+contributors:
+    - ["Ganesha Danu", "http://github.com/blinfoldking"]
+    - ["Keith Miyake", "https://github.com/kaymmm"]
+translators:
+    - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+---
+
+
+>Pascal es un lenguaje de programación imperativo y de procedimiento, que Niklaus Wirth diseñó en 1968–69 y publicó en 1970, como un lenguaje pequeño y eficiente destinado a fomentar las buenas prácticas de programación utilizando programación estructurada y estructuración de datos. Se nombra en honor al matemático, filósofo y físico francés Blaise Pascal. fuente: [wikipedia](https://es.wikipedia.org/wiki/Pascal_(lenguaje_de_programación)))
+
+Para compilar y ejecutar un programa pascal puede usar un compilador pascal gratuito. [Descargar aquí](https://www.freepascal.org/)
+
+```pascal
+//Anatomía de un programa en Pascal 
+//Esto es un comentario
+{
+    Esto es un
+    comentario multilínea
+}
+
+//nombre del programa
+program learn_pascal; //<-- no olvides el punto y coma
+
+const
+    {
+        Aquí es donde se debe declarar valores constantes.
+    }
+type
+    {
+       Aquí es donde se debe declarar un tipo de datos personalizado
+    }
+var
+    {
+        aquí es donde se debe declarar una variable
+    }
+
+//área principal del programa
+begin
+    {
+        área para declarar su instrucción
+    }
+end. // El final de un área principal del programa debe requerir un símbolo "." 
+```
+
+```pascal
+//declarando variable
+//puedes hacer esto
+var a:integer;
+var b:integer;
+//o esto
+var 
+    a : integer;
+    b : integer;
+//o esto
+var a,b : integer;
+```
+
+```pascal
+program Learn_More;
+//Aprendamos sobre los tipos de datos y sus operaciones.
+
+const
+    PI = 3.141592654;
+    GNU = 'GNU No Es Unix';
+        // las constantes se nombran convencionalmente usando CAPS (mayúscula)
+        // sus valores son fijos y no se pueden cambiar durante el tiempo de ejecución
+        // tiene cualquier tipo de datos estándar (enteros, reales, booleanos, characteres, cadenas)
+
+type
+    ch_array : array [0..255] of char;
+        // los  son nuevos 'tipos' que especifican la longitud y el tipo de datos
+        // esto define un nuevo tipo de datos que contiene 255 caracteres
+        // (esto es funcionalmente equivalente a una variable string[256])
+    md_array : array of array of integer;
+        // los arreglos anidados son equivalentes a los arreglos multidimensionales
+        // puede definir arreglos de longitud cero (0) que son de tamaño dinámico
+        // esta es una matriz bidimensional de enteros
+
+//Declarando variables
+var
+    int, c, d  : integer;
+           // Tres variables que contienen números enteros.
+           // los enteros son de 16 bits y están limitados al rango [-32,768..32,767]
+    r    : real;
+           // una variable que contiene un número real como tipos de datos
+           // el rango de los reales pueden variar entre [3.4E-38..3.4E38]
+    bool : boolean;
+           // una variable que contiene un valor booleano (True/False)
+    ch   : char;
+           // una variable que contiene un valor de carácter
+           // Las variables char se almacenan como tipos de datos de 8 bits, por lo que no hay UTF
+    str  : string;
+           // una variable no estándar que contiene un valor de cadena
+           // Las cadenas son una extensión incluida en la mayoría de los compiladores de Pascal.
+           // se almacenan como una matriz de caracteres con una longitud predeterminada de 255.
+    s    : string[50];
+           // una cadena con longitud máxima de 50 caracteres.
+           // puede especificar la longitud de la cadena para minimizar el uso de memoria
+    my_str: ch_array;
+           // Puedes declarar variables de tipos personalizados.
+    my_2d : md_array;
+           // Las matrices de tamaño dinámico deben dimensionarse antes de que puedan usarse.
+
+    // tipos de datos enteros adicionales
+    b    : byte;     // rango [0..255]
+    shi  : shortint; // rango [-128..127]
+    smi  : smallint; // rango [-32,768..32,767] (entero estándar)
+    w    : word;     // rango [0..65,535]
+    li   : longint;  // rango [-2,147,483,648..2,147,483,647]
+    lw   : longword; // rango [0..4,294,967,295]
+    c    : cardinal; // longword
+    i64  : int64;    // rango [-9223372036854775808..9223372036854775807]
+    qw   : qword;    // rango [0..18,446,744,073,709,551,615]
+
+    // tipos reales adicionales
+    rr   : real;     // rango depende de la plataforma (i.e., 8-bit, 16-bit, etc.)
+    rs   : single;   // rango [1.5E-45..3.4E38]
+    rd   : double;   // rango [5.0E-324 .. 1.7E308]
+    re   : extended; // rango [1.9E-4932..1.1E4932]
+    rc   : comp;     // rango [-2E64+1 .. 2E63-1]
+
+Begin
+    int := 1;// como asignar un valor a una variable
+    r   := 3.14;
+    ch  := 'a';
+    str := 'manzana';
+    bool := true;
+    //pascal no es un lenguaje sensible a mayúsculas y minúsculas
+    //operación aritmética
+    int := 1 + 1; // int = 2 sobrescribiendo la asignacion anterior
+    int := int + 1; // int = 2 + 1 = 3;
+    int := 4 div 2; //int = 2 operación de división donde el resultado será redondeado.
+    int := 3 div 2; //int = 1
+    int := 1 div 2; //int = 0
+
+    bool := true or false; // bool = true
+    bool := false and true; // bool = false
+    bool := true xor true; // bool = false
+
+    r := 3 / 2; // un operador de división para reales
+    r := int; // Puede asignar un entero a una variable real pero no a la inversa
+
+    c := str[1]; // asigna la primera letra de str a c
+    str := 'hola' + 'mundo'; // combinando cadenas
+
+    my_str[0] := 'a'; // asignación de matriz necesita un índice
+
+    setlength(my_2d,10,10); // inicializa matrices de tamaño dinámico: matriz 10 × 10
+    for c := 0 to 9 do // los arreglos comienzan en 0 y terminan en longitud - 1
+        for d := 0 to 9 do // Para los contadores de bucle hay que declarar variables.
+        my_2d[c,d] := c * d;
+          // aborda las matrices multidimensionales con un único conjunto de corchete
+
+End.
+```
+
+```pascal
+program Functional_Programming;
+
+Var
+    i, dummy : integer;
+
+function recursion_factorial(const a: integer) : integer;
+{ calcula recursivamente el factorial del parámetro entero a }
+
+// Declare variables locales dentro de la función.
+// e.g.:
+// Var
+//    local_a : integer;
+
+Begin
+    If a >= 1 Then
+    // devuelva valores de las funciones asignando un valor al nombre de la función
+        recursion_factorial := a * recursion_factorial(a-1)
+    Else
+        recursion_factorial := 1;
+End; // termine una función usando un punto y coma después de la instrucción End.
+
+procedure obtener_entero(var i : integer; dummy : integer);
+{ obten la entrada del usuario y almacenarla en el parámetro entero i. 
+  los parámetros que preceden a 'var' son variables, lo que significa que su valor 
+  puede cambiar fuera del parámetro. Los parámetros de valor (sin 'var') como 'dummy' 
+  son estáticos y los cambios realizados dentro del alcance de la función/procedimiento 
+  no afectan la variable que se pasa como parámetro }
+
+Begin
+    write('Escriba un entero: ');
+    readln(i);
+    dummy := 4; // dummy no cambiará el valor fuera del procedimiento
+End;
+
+Begin // bloque de programa principal
+    dummy := 3;
+    obtener_entero(i, dummy);
+    writeln(i, '! = ', recursion_factorial(i));
+    // muestra i!
+    writeln('dummy = ', dummy); // siempre muestra '3' ya que dummy no ha cambiado.
+End.
+
+```
+
diff --git a/es-es/pyqt-es.html.markdown b/es-es/pyqt-es.html.markdown
new file mode 100644
index 00000000..6d4fdde7
--- /dev/null
+++ b/es-es/pyqt-es.html.markdown
@@ -0,0 +1,82 @@
+---
+category: tool
+tool: PyQT
+filename: learnpyqt-es.py
+contributors:
+    - ["Nathan Hughes", "https://github.com/sirsharpest"]
+translators:
+    - ["Adrian Rocamora", "https://github.com/adrianrocamora"]
+lang: es-es
+---
+
+**Qt** es un sistema altamente reconocido que permite desarrollar software multiplataforma que puede correr en diferentes entornos de software y hardware con pocos o ningún cambio. Aun así conserva la velocidad y poder de una aplicación nativa. **Qt** fue originalmente escrito en *C++*.
+
+Esta es una adaptación de la introducción a QT con C++ por [Aleksey Kholovchuk](https://github.com/vortexxx192), parte del código ejemplo debería resultar en la misma funcionalidad ¡pero usando python con PyQT!
+
+```python
+import sys
+from PyQt4 import QtGui
+	
+def window():
+    # Crear el objeto de la aplicación
+    app = QtGui.QApplication(sys.argv)
+    # Crear un widget en el que colocaremos nuestra etiqueta
+    w = QtGui.QWidget()
+    # Agregamos nuestra etiqueta al widget
+    b = QtGui.QLabel(w)
+    # Agregamos texto a nuestra etiqueta
+    b.setText("Hello World!")
+    # Fijemos información de posición y tamaño del widget
+    w.setGeometry(100, 100, 200, 50)
+    b.move(50, 20)
+    # Proporcionemos un título a nuestra ventana
+    w.setWindowTitle("PyQt")
+    # Mostremos todo
+    w.show()
+    # Ejecutemos lo que hayamos solicitado ya inicializado el resto
+    sys.exit(app.exec_())
+
+if __name__ == '__main__':
+    window()
+
+```
+
+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 
+import sys
+from PyQt4.QtGui import *
+from PyQt4.QtCore import *
+
+
+def window():
+    app = QApplication(sys.argv)
+    w = QWidget()
+    # Crear un botón y adjuntarlo al widget w
+    b = QPushButton(w)
+    b.setText("Press me")
+    b.move(50, 50)
+    # Indicar al botón b que llame esta función cuando reciba un click
+    # Nótese la falta de "()" en la llamada de la función
+    b.clicked.connect(showdialog)
+    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():
+    d = QDialog()
+    b1 = QPushButton("ok", d)
+    b1.move(50, 50)
+    d.setWindowTitle("Dialog")
+    # Esta modalidad le indica al popup que bloquee al padre mientras activo
+    d.setWindowModality(Qt.ApplicationModal)
+    # Al recibir un click me gustaría que el proceso termine
+    b1.clicked.connect(sys.exit)
+    d.exec_()
+
+if __name__ == '__main__':
+    window()
+```
diff --git a/es-es/python3-es.html.markdown b/es-es/python3-es.html.markdown
index 05fd7065..3236e73a 100644
--- a/es-es/python3-es.html.markdown
+++ b/es-es/python3-es.html.markdown
@@ -14,8 +14,6 @@ Es básicamente pseudocódigo ejecutable.
 
 ¡Comentarios serán muy apreciados! Pueden contactarme en [@louiedinh](http://twitter.com/louiedinh) o louiedinh [at] [servicio de email de google]
 
-Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser aplicable a Python 2.x. ¡Pronto un recorrido por Python 3!
-
 ```python
 
 # Comentarios de una línea comienzan con una almohadilla (o signo gato)
@@ -39,6 +37,8 @@ Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser apl
 
 # Excepto la división la cual por defecto retorna un número 'float' (número de coma flotante)
 35 / 5  # => 7.0
+# Sin embargo también tienes disponible división entera
+34 // 5 # => 6
 
 # Cuando usas un float, los resultados son floats
 3 * 2.0 # => 6.0
@@ -87,11 +87,14 @@ not False  # => True
 # .format puede ser usaro para darle formato a los strings, así:
 "{} pueden ser {}".format("strings", "interpolados")
 
-# Puedes repetir los argumentos de formateo para ahorrar tipeos.
+# Puedes reutilizar los argumentos de formato si estos se repiten.
 "{0} sé ligero, {0} sé rápido, {0} brinca sobre la {1}".format("Jack", "vela") #=> "Jack sé ligero, Jack sé rápido, Jack brinca sobre la vela"
 # Puedes usar palabras claves si no quieres contar.
-"{nombre} quiere comer {comida}".format(nombre="Bob", food="lasaña") #=> "Bob quiere comer lasaña"
-
+"{nombre} quiere comer {comida}".format(nombre="Bob", comida="lasaña") #=> "Bob quiere comer lasaña"
+# También puedes interpolar cadenas usando variables en el contexto
+nombre = 'Bob'
+comida = 'Lasaña'
+f'{nombre} quiere comer {comida}'  #=> "Bob quiere comer lasaña"
 
 # None es un objeto
 None  # => None
@@ -101,12 +104,13 @@ None  # => None
 "etc" is None #=> False
 None is None  #=> True
 
-# None, 0, y strings/listas/diccionarios vacíos(as) todos se evalúan como False.
+# None, 0, y strings/listas/diccionarios/conjuntos vacíos(as) todos se evalúan como False.
 # Todos los otros valores son True
 bool(0)  # => False
 bool("")  # => False
 bool([]) #=> False
 bool({}) #=> False
+bool(set()) #=> False
 
 
 ####################################################
@@ -170,7 +174,7 @@ lista + otra_lista #=> [1, 2, 3, 4, 5, 6] - Nota: lista y otra_lista no se tocan
 # Concatenar listas con 'extend'
 lista.extend(otra_lista) # lista ahora es [1, 2, 3, 4, 5, 6]
 
-# Chequea la existencia en una lista con 'in'
+# Verifica la existencia en una lista con 'in'
 1 in lista #=> True
 
 # Examina el largo de una lista con 'len'
@@ -196,7 +200,7 @@ d, e, f = 4, 5, 6
 e, d = d, e     # d ahora es 5 y e ahora es 4
 
 
-# Diccionarios almacenan mapeos
+# Diccionarios relacionan llaves y valores
 dicc_vacio = {}
 # Aquí está un diccionario prellenado
 dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
@@ -213,7 +217,7 @@ list(dicc_lleno.keys()) #=> ["tres", "dos", "uno"]
 list(dicc_lleno.values()) #=> [3, 2, 1]
 # Nota - Lo mismo que con las llaves, no se garantiza el orden.
 
-# Chequea la existencia de una llave en el diccionario con 'in'
+# Verifica la existencia de una llave en el diccionario con 'in'
 "uno" in dicc_lleno #=> True
 1 in dicc_lleno #=> False
 
@@ -253,7 +257,7 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
 # Haz diferencia de conjuntos con -
 {1,2,3,4} - {2,3,5} #=> {1, 4}
 
-# Chequea la existencia en un conjunto con 'in'
+# Verifica la existencia en un conjunto con 'in'
 2 in conjunto_lleno #=> True
 10 in conjunto_lleno #=> False
 
@@ -262,7 +266,7 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
 ## 3. Control de Flujo
 ####################################################
 
-# Let's just make a variable
+# Creemos una variable para experimentar
 some_var = 5
 
 # Aquí está una declaración de un 'if'. ¡La indentación es significativa en Python!
@@ -275,18 +279,17 @@ else:           # Esto también es opcional.
     print("una_variable es de hecho 10.")
 
 """
-For itera sobre listas
+For itera sobre iterables (listas, cadenas, diccionarios, tuplas, generadores...)
 imprime:
     perro es un mamifero
     gato es un mamifero
     raton es un mamifero
 """
 for animal in ["perro", "gato", "raton"]:
-    # Puedes usar % para interpolar strings formateados
     print("{} es un mamifero".format(animal))
 
 """
-`range(número)` retorna una lista de números
+`range(número)` retorna un generador de números
 desde cero hasta el número dado
 imprime:
     0
@@ -323,7 +326,7 @@ except IndexError as e:
 
 dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
 nuestro_iterable = dicc_lleno.keys()
-print(nuestro_iterable) #=> range(1,10). Este es un objeto que implementa nuestra interfaz Iterable
+print(nuestro_iterable) #=> dict_keys(['uno', 'dos', 'tres']). Este es un objeto que implementa nuestra interfaz Iterable
 
 Podemos recorrerla.
 for i in nuestro_iterable:
@@ -420,6 +423,10 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
 # Podemos usar listas por comprensión para mapeos y filtros agradables
 [add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
 [x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+# también hay diccionarios
+{k:k**2 for k in range(3)} #=> {0: 0, 1: 1, 2: 4}
+# y conjuntos por comprensión
+{c for c in "la cadena"} #=> {'d', 'l', 'a', 'n', ' ', 'c', 'e'}
 
 ####################################################
 ## 5. Classes