summaryrefslogtreecommitdiffhomepage
path: root/es-es
diff options
context:
space:
mode:
Diffstat (limited to 'es-es')
-rw-r--r--es-es/asymptotic-notation-es.html.markdown1
-rw-r--r--es-es/binary-search-es.html.markdown68
-rw-r--r--es-es/dynamic-programming-es.html.markdown54
-rw-r--r--es-es/edn-es.html.markdown111
-rw-r--r--es-es/html-es.html.markdown122
-rw-r--r--es-es/jquery-es.html.markdown141
-rw-r--r--es-es/kotlin-es.html.markdown361
-rw-r--r--es-es/php-composer-es.html.markdown176
-rw-r--r--es-es/racket-es.html.markdown683
-rw-r--r--es-es/ruby-ecosystem-es.html.markdown157
-rw-r--r--es-es/sass-es.html.markdown585
-rw-r--r--es-es/swift-es.html.markdown88
-rw-r--r--es-es/tmux.html.markdown242
-rw-r--r--es-es/vim-es.html.markdown242
14 files changed, 2987 insertions, 44 deletions
diff --git a/es-es/asymptotic-notation-es.html.markdown b/es-es/asymptotic-notation-es.html.markdown
index f3fe1614..3507429c 100644
--- a/es-es/asymptotic-notation-es.html.markdown
+++ b/es-es/asymptotic-notation-es.html.markdown
@@ -168,3 +168,4 @@ definiciones y ejemplos.
* [MIT](http://web.mit.edu/16.070/www/lecture/big_o.pdf)
* [KhanAcademy](https://www.khanacademy.org/computing/computer-science/algorithms/asymptotic-notation/a/asymptotic-notation)
+* [Apuntes Facultad de Ingeniería](https://www.scribd.com/document/317979564/Apuntes-Sobre-Analisis-de-Algoritmos)
diff --git a/es-es/binary-search-es.html.markdown b/es-es/binary-search-es.html.markdown
new file mode 100644
index 00000000..a1b42d21
--- /dev/null
+++ b/es-es/binary-search-es.html.markdown
@@ -0,0 +1,68 @@
+---
+category: Algorithms & Data Structures
+name: Binary Search
+contributors:
+ - ["Abhishek Jaisingh", "http://github.com/abhishekjiitr"]
+translators:
+ - ["Gino Amaury", "https://github.com/ginoamaury"]
+lang: es-es
+---
+
+# Búsqueda Binaria
+
+## Por qué Búsqueda Binaria?
+
+La búsqueda es uno de los problemas principales en el dominio de la ciencia de la computación. Hoy en dia hay mas de 1 billon de búsquedas por año, y necesitamos tener algoritmos que puedan hacer esto muy rápido. La búsqueda binaria es uno de los algoritmos fundamentales en la ciencia de la computación. Con el fin de explorarlo, vamos a construir por primera vez un esqueleto teórico y lo utilizaremos para implementar el algoritmo apropiadamente.
+
+## Introducción
+
+Un método sencillo para poner en práctica la búsqueda es hacer una búsqueda lineal, pero este método requiere mucho tiempo y este crece linealmente con la cantidad o el número de datos. es decir, empezar desde el elemento a la izquierda de la matriz [] y uno por uno compara x con cada elemento de la matriz [], si x coincide con un elemento, devuelve el índice. Si x no coincide con ninguno de los elementos, devuelve -1.
+
+```
+Búsqueda Lineal: O (n) Tiempo lineal
+
+Búsqueda Binaria: O ( log(n) ) Tiempo logarítmico
+
+```
+```
+def search(arr, x):
+
+ for i in range(len(arr)):
+
+ if arr[i] == x:
+ return i
+
+ return -1
+
+```
+## Algoritmo de Búsqueda Binaria
+
+El requisito básico para que la búsqueda binaria funcione es que los datos a buscar deben estar ordenados (en cualquier orden).
+
+
+### Algo
+
+```
+La idea de la búsqueda binaria es usar la información de que la matriz está ordenada y así reducir la complejidad del tiempo a O(Logn). Básicamente ignoramos la mitad de los elementos después de la primera comparación.
+1) Compare x con el elemento del medio.
+2) si x coincide con el elemento del medio , retornamos el índice del elemento del medio.
+3) Si no coincide, si x es mayor que el elemento del medio, entonces x solo puede estar en la mitad derecha justo después del elemento del medio. Así que recurrimos a la mitad derecha.
+4) Si no (x es más pequeño) recurrimos a la mitad izquierda.
+Siguiendo la implementación recursiva de búsqueda binaria.
+
+```
+
+### Notas finales
+
+Hay otra forma de búsqueda binaria que es muy útil.
+
+## Libros
+
+* [CLRS EN](https://mitpress.mit.edu/books/introduction-algorithms)
+* [Algoritmos EN](http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X)
+* [Diseño de Algoritmos EN](http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651)
+
+## Recursos en línea
+
+* [GeeksforGeeks EN](http://www.geeksforgeeks.org/the-ubiquitous-binary-search-set-1/)
+* [Topcoder Tutorial EN](https://www.topcoder.com/community/data-science/data-science-tutorials/binary-search/)
diff --git a/es-es/dynamic-programming-es.html.markdown b/es-es/dynamic-programming-es.html.markdown
new file mode 100644
index 00000000..11930653
--- /dev/null
+++ b/es-es/dynamic-programming-es.html.markdown
@@ -0,0 +1,54 @@
+---
+category: Algorithms & Data Structures
+name: Dynamic Programming
+contributors:
+ - ["Akashdeep Goel", "http://github.com/akashdeepgoel"]
+translators:
+ - ["Gino Amaury", "https://github.com/ginoamaury"]
+lang: es-es
+---
+
+# programación dinámica
+
+## Introducción
+
+La programación dinámica es una técnica poderosa usada para resolver una clase particular de problemas como veremos más adelante. La idea es muy simple, si usted ha solucionado un problema con la entrada dada, entonces , guardaremos el resultado para una futura referencia, con el fin de evitar la solución del mismo problema de nuevo.
+
+
+Recuerde siempre!!
+"Aquellos que no pueden recordar el pasado están condenados a repetirlo"
+
+## Formas de resolver este tipo de problemas
+
+1.) De arriba hacia abajo : Empezamos resolviendo el problema dado descomponiendolo. Si ves que el problema fue resuelto, entonces retorna la respuesta guardada. si no se ha resuelto, resuélvelo y guarda la respuesta. Esto suele ser fácil pensar y muy intuitivo. Esto se conoce como memorización.
+
+2.) De abajo hacia arriba : Analiza el problema y mira el orden en que los subproblemas deben ser resueltos y empieza resolviendo el subproblema más trivial, hacia el problema dado.En este proceso, se garantiza que los subproblemas se resuelven antes de resolver el problema. Esto se conoce como programación dinámica.
+
+## Ejemplo de Programación Dinámica
+
+El problema de la subsecuencia creciente máxima consiste en encontrar la subsecuencia creciente máxima en una secuencia dada . Dada la secuencia S= {a1 , a2 , a3, a4, ............., an-1, an } tenemos que encontrar un subconjunto más largo tal que para todo j y i, j <i en el subconjunto aj <ai.
+En primer lugar tenemos que encontrar el valor de las subsecuencias más largas (LSI) en cada índice con el último elemento de la secuencia que es ai. El mayor LSi sería la subsecuencia más larga de la secuencia dada. Para empezar LSI es asignado a uno ya que ai es un elemento de la secuencia(El último elemento).Entonces, para todo j tal que j <i aj <ai, nos encontramos con Lsj más grande y lo agregamos a la LSI. A continuación, el algoritmo toma un tiempo de O (n2).
+Pseudocódigo para encontrar la longitud de la más larga subsecuencia creciente:
+La complejidad de este algoritmos podría reducirse mediante el uso de una mejor estructura de datos en lugar de una array. Almacenamiento de una matriz predecesora y una variable como Secuencia_mas_Grande_hasta_ahora y su índice podría ahorrar mucho tiempo.
+concepto similar se podría aplicar en encontrar el camino más largo de grafo acíclico dirigido.
+---------------------------------------------------------------------------
+ for i=0 to n-1
+ LS[i]=1
+ for j=0 to i-1
+ if (a[i] > a[j] and LS[i]<LS[j])
+ LS[i] = LS[j]+1
+ for i=0 to n-1
+ if (largest < LS[i])
+
+### Algunos problemas famosos de Programación Dinámica (DP).
+```
+Algoritmo Floyd Warshall(EN) - Tutorial y código fuente del programa en C:http://www.thelearningpoint.net/computer-science/algorithms-all-to-all-shortest-paths-in-graphs---floyd-warshall-algorithm-with-c-program-source-code
+
+Problema de la Mochila(EN) - Tutorial y código fuente del programa en C: http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---the-integer-knapsack-problem
+
+
+Problema de Subsecuencia Común mas Larga(EN) - Tutorial y código fuente del programa en C : http://www.thelearningpoint.net/computer-science/algorithms-dynamic-programming---longest-common-subsequence
+
+## Recursos en línea
+
+* [codechef EN](https://www.codechef.com/wiki/tutorial-dynamic-programming) \ No newline at end of file
diff --git a/es-es/edn-es.html.markdown b/es-es/edn-es.html.markdown
new file mode 100644
index 00000000..32bba37d
--- /dev/null
+++ b/es-es/edn-es.html.markdown
@@ -0,0 +1,111 @@
+---
+language: edn
+filename: learnedn-es.edn
+contributors:
+ - ["Jason Yeo", "https://github.com/jsyeo"]
+translators:
+ - ["Gino Amaury", "https://github.com/ginoamaury"]
+lang: es-es
+---
+
+La notación de datos extensible (Extensible Data Notation (EDN)) es un formato para serializar los datos.
+
+La notación se utiliza internamente por Clojure para representar programas. También es
+utilizado como un formato de transferencia de datos como JSON. A pesar de que se utiliza más comúnmente en
+Clojure, existen implementaciones de EDN para muchos otros lenguajes.
+
+El principal beneficio de EDN sobre JSON y YAML es que es extensible.
+Vamos a ver cómo se extiende más adelante.
+
+```clojure
+; Los comentarios comienzan con un punto y coma.
+; Cualquier cosa después del punto y coma es ignorado.
+
+;;;;;;;;;;;;;;;;;;;
+;;;Tipos Básicos;;;
+;;;;;;;;;;;;;;;;;;;
+
+nil ; También conocido en otros lenguajes como nulo (null).
+
+; Booleanos
+true
+false
+
+; Las cadenas se encierran entre comillas dobles
+"desayuno húngaro"
+"tortilla de queso del granjero"
+
+; Los caracteres están precedidos por barras invertidas
+\g \r \a \c \e
+
+; Las palabras claves comienzan con dos puntos.Se comportan como las enumeraciones. Más o menos
+; Como símbolos en Ruby
+:huevos
+:queso
+:aceitunas
+
+; Los símbolos se utilizan para representar los identificadores.Estos empiezan con #.
+; puedes tener espacios usando el símbolo /. cualquier cosa precedida / es
+; un espacio en el nombre.
+#cuchara
+#cocina/cuchara ; no es lo mismo que #spoon
+#cocina/tenedor
+#github/tenedor ; no se puede comer con este.
+
+; Números enteros y flotantes
+42
+3.14159
+
+; Las listas son secuencias de valores.
+(:bollo :empanada-de-res 9 "yum!")
+
+; Vectores permiten acceso aleatorio
+[:helado 1 2 -2]
+
+; Los mapas son estructuras de datos asociativos que se asocian con la clave de su valor.
+{:huevos 2
+ :jugo-de-limon 3.5
+ :mantequilla 1}
+
+; Usted no está restringido a usar palabras clave como claves.
+{[1 2 3 4] "decirle a la gente lo que llevaba",
+ [5 6 7 8] "Entre mas tu ves, mas lo odias"}
+
+; Puede usar comas para facilitar la lectura. Se tratan como espacios en blanco.
+
+; Los conjuntos son colecciones que contienen elementos únicos.
+#{:a :b 88 "huat"}
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;Elementos de etiqueta ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; EDN puede ser extendido por elementos de etiqueta con el símbolo #.
+
+#MyYelpClone/MenuItem {:nombre "huevos-Benedict" :clasificacion 10}
+
+; Permíteme explicar esto con un ejemplo en colujre. Supongamos que quiero
+; transformar ese pedazo de EDN en un registro del Menú.
+
+(defrecord MenuItem [nombre clasificacion])
+
+; Para transformar EDN en valores clojure, necesitaremos usar el constructor en EDN
+; lectura, edn/read-string
+
+(edn/read-string "{:huevos 2 :mantequilla 1 :harina 5}")
+; -> {:huevos 2 :mantequilla 1 :harina 5}
+
+; Para transformar los elementos de etiqueta, definir la función de lectura y pasar un mapa
+; que asigna etiquetas a funciones del lector de edn/read-string al igual que.
+
+(edn/read-string {:lectores {'MyYelpClone/MenuItem map->menu-item}}
+ "#MyYelpClone/MenuItem {:nombre \"huevos-benedict\" :clasificacion 10}")
+; -> #user.MenuItem{:nombre "huevos-benedict", :clasificacion 10}
+
+```
+
+# Referencias
+
+- [EDN spec (EN)](https://github.com/edn-format/edn)
+- [Implementations (EN)](https://github.com/edn-format/edn/wiki/Implementations)
+- [Tagged Elements (EN)](http://www.compoundtheory.com/clojure-edn-walkthrough/)
diff --git a/es-es/html-es.html.markdown b/es-es/html-es.html.markdown
new file mode 100644
index 00000000..e4623131
--- /dev/null
+++ b/es-es/html-es.html.markdown
@@ -0,0 +1,122 @@
+---
+language: html
+filename: learnhtml-es.html
+contributors:
+ - ["Christophe THOMAS", "https://github.com/WinChris"]
+translators:
+ - ["Gino Amaury", "https://github.com/ginoamaury"]
+lang: es-es
+---
+
+HTML significa Lenguaje de marcado de hipertexto (HyperText Markup Language).
+Este es un lenguaje usado para escribir páginas en la web (WWW).
+Este es un lenguaje de marcado, es usado para escribir páginas web usando código para indicar cómo se debe mostrar el texto y los datos.
+En efecto, los archivos html son simples archivos de texto.
+Qué es esto de marcado? es un método para organizar los datos de la página encerrandolos con etiquetas de apertura y cierre.
+Este marcado sirve para darle significancia al texto que éste encierra.
+Como en otros lenguajes computacionales, HTML tiene varias versiones. Aquí hablaremos acerca de HTML5.
+
+**Nota :** Puedes probrar las diferentes etiquetas y elementos a medida que progresas en un tutorial en un sitio como [codepen](http://codepen.io/pen/) con el fin de ver sus efectos, entender como funcionan y familiarizarse con el lenguaje.
+Este artículo está centrado principalmente en la sintaxis HTML y algunos tips de importancia.
+
+
+```html
+<!-- los comentarios están encerrados como en esta línea! -->
+
+<!-- #################### Las Etiquetas #################### -->
+
+<!-- Este es un ejemplo de un archivo HTML que analizaremos! -->
+
+<!doctype html>
+ <html>
+ <head>
+ <title>Mi Sitio</title>
+ </head>
+ <body>
+ <h1>Hola, Mundo!</h1>
+ <a href = "http://codepen.io/anon/pen/xwjLbZ">ven mira lo que esto muestra. </a>
+ <p>Esto es un párrafo</p>
+ <p>Este es otro párrafo</p>
+ <ul>
+ <li>Este es un elemento de una lista no numerada (lista de viñetas)</li>
+ <li>Este es otro ítem</li>
+ <li>Y este es el último ítem de la lista</li>
+ </ul>
+ </body>
+ </html>
+
+<!-- En un archivo HTML siempre inicia indicando le al buscador que esta es una página HTML. -->
+<!doctype html>
+
+<!-- Después de esto, iniciamos abriendo una etiqueta html <html> -->
+<html>
+
+<!-- Cuando termine el archivo cerraremos la etiqueta así </html>. -->
+</html>
+
+<!-- Después de la etiqueta final nada aparecerá o podrá aparecer -->
+
+<!-- Dentro (Entre las etiquetas de apertura y cierre <html></html>), encontraremos: -->
+
+<!-- Un encabezado definido por <head> (Este debe ser cerrado por </head>). -->
+
+<!-- El encabezado contiene alguna descripción y información adicional que no se muestra; estos son los metadatos. -->
+
+<head>
+ <title>Mi Sitio</title><!-- La etiqueta <title> Indica al buscador el título a mostrar en la ventana del buscador en la barra de título y en el nombre de la pestaña. -->
+</head>
+
+<!-- Después de la sección del encabezado <head> , Encontraremos la etiqueta de cuerpo - <body> -->
+<!-- Hasta este punto. no hay nada descrito para que se muestre en la ventana del navegador -->
+<!-- Debemos llenar el cuerpo con el contenido que se mostrará -->
+
+<body>
+ <h1>Hola, Mundo!</h1> <!-- La etiqueta <h1> crea un título. -->
+ <!-- También tenemos subtítulos para <h1> desde la más importante <h2> a la más precisa <h6> -->
+ <a href = "http://codepen.io/anon/pen/xwjLbZ">ven mira lo que esto muestra.</a> <!-- Un hipervínculo a la URL dada por el atributo href="" -->
+ <p>Esto es un párrafo.</p> <!-- La etiqueta <p> nos permite incluir texto en nuestra página HTML -->
+ <p>Este es otro párrafo.</p>
+ <ul> <!-- La etiqueta <ul> crea una lista de viñetas -->
+ <!-- Para tener una lista numerada usamos la etiqueta <ol> dando 1. para el primer elemento, 2. para el segundo, etc. -->
+ <li>Este es un elemento de una lista no numerada (lista de viñetas)</li>
+ <li>Este es otro ítem</li>
+ <li>Y este es el último ítem de la lista</li>
+ </ul>
+</body>
+
+<!-- Y esto es todo, la creación de un archivo HTML puede ser muy simple. -->
+
+<!-- Sin embargo, es posible añadir muchos otros tipos de etiquetas HTML -->
+
+<!-- Para insertar una imagen -->
+<img src="http://i.imgur.com/XWG0O.gif"/> <!-- La fuente donde se localiza la imagen se indica utilizando el atributo src=""-->
+<!-- La fuente puede ser una URL o incluso una ruta a una archivo en tu computador. -->
+
+<!-- También es posible crear una tabla -->
+
+<table> <!-- Abrimos una etiqueta o elemento tabla <table> -->
+ <tr> <!-- <tr> Nos permite crear una fila. -->
+ <th>Primer encabezado</th> <!-- <th> Nos permite dar un título a una columna de una tabla -->
+ <th>Segundo encabezado</th>
+ </tr>
+ <tr>
+ <td>Primera fila, primera columna</td> <!-- <td> nos permite crear una celda -->
+ <td>Primera fila, segunda columna</td>
+ </tr>
+ <tr>
+ <td>Segunda fila, primera columna</td>
+ <td>Segunda fila, segunda columna</td>
+ </tr>
+</table>
+
+```
+
+## Uso
+
+HTML es escrito en archivos que terminan con (extensión) `.html`.
+
+## Para aprender más!
+
+* [wikipedia](https://es.wikipedia.org/wiki/HTML)
+* [HTML tutorial](https://developer.mozilla.org/es/docs/Web/HTML)
+* [W3School (EN)](http://www.w3schools.com/html/html_intro.asp)
diff --git a/es-es/jquery-es.html.markdown b/es-es/jquery-es.html.markdown
new file mode 100644
index 00000000..d35e6f17
--- /dev/null
+++ b/es-es/jquery-es.html.markdown
@@ -0,0 +1,141 @@
+---
+category: tool
+tool: jquery
+contributors:
+ - ["Sawyer Charles", "https://github.com/xssc"]
+translators:
+ - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+filename: jquery-es.js
+---
+
+jQuery es una librería de JavaScript que le ayuda a "hacer más y escribir menos". Esto hace que muchas de las tareas comunes de JavaScript sean más fáciles de escribir. jQuery es utilizado por muchas de las grandes empresas y desarrolladores de todo el mundo. Hace que AJAX, la gestión de eventos, la manipulación de documentos, y mucho más, sea más fácil y rápido.
+
+Debido a que jQuery es una librería de JavaScript debes [aprender JavaScript primero](https://learnxinyminutes.com/docs/es-es/javascript-es/)
+
+```js
+
+
+///////////////////////////////////
+// 1. Selectores
+
+// Los selectores en jQuery son usados para seleccionar un elemento
+var page = $(window); // Selecciona toda la ventana gráfica
+
+// Los selectores también pueden ser selectores CSS
+var paragraph = $('p'); // Selecciona todos los elementos de párrafo
+var table1 = $('#table1'); // Selecciona el elemento con id 'tabla1'
+var squares = $('.square'); // Selecciona todos los elementos con la clase "square"
+var square_p = $('p.square') // Selecciona los párrafos con la clase "square"
+
+
+///////////////////////////////////
+// 2. Eventos y efectos
+
+// Un evento muy común que se utiliza es el evento 'ready' en el documento
+// Se puede utilizar el método de 'ready' para esperar hasta que el elemento haya terminado de cargar
+$(document).ready(function(){
+ // El código no se ejecutará hasta que el documento haya terminado de cargar
+});
+
+// jQuery es muy bueno activando eventos
+// Y también en el manejo de lo que ocurre cuando se activa un evento
+$('#button').click(); // Dispara un evento click en $ ('# botón')
+$('#button').click(function(){
+ // El código es ejecutado cuando se hace clic en el elemento de botón #
+});
+
+function onAction() {
+ // Esto se ejecuta cuando se activa el evento
+}
+
+// Algunos otros eventos comunes son:
+$('#btn').dblclick(onAction); //Doble clic
+$('#btn').hover(onAction); // Pasar el cursor por encima
+$('#btn').focus(onAction); // Enfocado
+$('#btn').blur(onAction); // Pierde enfoque
+$('#btn').submit(onAction); // Enviado
+$('#btn').select(onAction); // Cuando se selecciona un elemento
+$('#btn').keydown(onAction); // Cuando una tecla es empujada hacia abajo
+$('#btn').keyup(onAction); // Cuando se suelta una tecla
+$('#btn').keypress(onAction); // Cuando se pulsa una tecla
+$('#btn').mousemove(onAction); // Cuando se mueve el mouse
+$('#btn').mouseenter(onAction); // El mouse entra en el elemento
+$('#btn').mouseleave(onAction); // El mouse sale en el elemento
+
+// También se puede utilizar una función anónima
+$('#btn').hover(function(){
+ // Se ejecuta al pasar por encima
+});
+
+// Todos estos pueden también desencadenar el evento en lugar de manejarlo
+// Simplemente no pasando ningún parámetro
+$('#btn').dblclick(); // Dispara el evento de doble clic sobre el elemento
+
+// Se puede manejar múltiples eventos, usando el selector una vez
+$('#btn').on(
+ {dblclick: myFunction1} // Activado con doble clic
+ {blur: myFunction1} // Activo en la perdida de enfoque
+);
+
+// Puede mover y ocultar elementos con algunos métodos de efecto
+$('.table').hide(); # Oculta el(los) elemento(s)
+
+// Nota: llamar a una función en estos métodos aún oculta el elemento
+$('.table').hide(function(){
+ // El elemento se oculta entonces función ejecutada
+});
+
+// Puedes almacenar los selectores en las variables
+var tables = $('.table');
+
+// Algunos métodos básicos de manipulación de documento son:
+tables.hide(); // Oculta elemento(s)
+tables.show(); // Muestra elemento(s)
+tables.toggle(); // Cambia el estado de ocultar / mostrar
+tables.fadeOut(); // Desvanece
+tables.fadeIn(); // Fundirse
+tables.fadeToggle(); // Desvanece dentro o fuera
+tables.fadeTo(0.5); // Desvanece a una opacidad (entre 0 y 1)
+tables.slideUp(); // Desliza hacia arriba
+tables.slideDown(); // Desliza hacia abajo
+tables.slideToggle(); // Desliza hacia arriba o hacia abajo
+
+// Todo lo anterior toma una velocidad (milisegundos) y la función de devolución de llamada
+tables.hide(1000, myFunction); // Animación de ocultar elemento a 1 segundo y luego la funcion de devolución
+
+// 'fadeTo' requiere de una opacidad como su segundo parámetro
+tables.fadeTo(2000, 0.1, myFunction); // 2 segundos. decolorar a opacidad de 0.1 luego la función
+
+// Puede conseguir un efecto un poco más avanzado con el método 'animate'
+tables.animate({margin-top:"+=50", height: "100px"}, 500, myFunction);
+// El método 'animate' toma un objeto de CSS y los valores finales,
+// Parámetro opcional de opciones para afinar la animación,
+// Y por supuesto la función de devolución de llamada
+
+///////////////////////////////////
+// 3. Manipulación
+
+// Estos son similares a los efectos, pero pueden hacer más
+$('div').addClass('div') // Añade la clase div a todos los divs
+
+// Métodos comunes de manipulación
+$('p').append('Hola mundo'); // Añade al final del elemento
+$('p').attr('class'); // Obtiene atributo
+$('p').attr('class', 'content'); // Configura atributos
+$('p').hasClass('div'); //Devuelve verdadero si tiene la clase
+$('p').height(); // Obtiene la altura del elemento o define la altura
+
+
+// Para muchos métodos de manipulación, obtener información sobre un elemento
+// consigue solamente el primer elemento coincidente
+$('p').height(); // Obtiene sólo la altura de la primera etiqueta 'p'
+
+// Puedes utilizar 'each' para recorrer todos los elementos
+var heights = [];
+$('p').each(function() {
+ heights.push($(this.height)); // Añade todas las alturas "p" de la etiqueta a la matriz
+});
+
+
+``` \ No newline at end of file
diff --git a/es-es/kotlin-es.html.markdown b/es-es/kotlin-es.html.markdown
new file mode 100644
index 00000000..5d2f165a
--- /dev/null
+++ b/es-es/kotlin-es.html.markdown
@@ -0,0 +1,361 @@
+---
+language: kotlin
+contributors:
+- ["S Webber", "https://github.com/s-webber"]
+translators:
+- ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+filename: LearnKotlin-es.kt
+---
+
+Kotlin es un lenguaje estático tipado para la JVM, Android y el navegador. Es
+100% interoperable con Java.
+[Leer mas aqui.](https://kotlinlang.org/)
+
+```java
+// Los comentarios de una sóla línea comienzan con //
+
+/*
+ Los comentarios multilínea lucen así
+*/
+
+// La palabra clave "package" funciona de la misma manera que Java.
+
+/*
+El punto de entrada para un programa de Kotlin es una función llamada "main".
+A dicha función se le pasa un arreglo que contiene los argumentos de la linea de comando.
+*/
+fun main(args: Array<String>) {
+ /*
+ La declaración de valores se realiza utilizando tanto "var" como "val".
+ Las declaraciones "val" no pueden ser reasignadas, mientras que "var" sí.
+ */
+ val fooVal = 10 // más adelante no podremos reasignar fooVal con un valor distinto.
+ var fooVar = 10
+ fooVar = 20 // fooVar puede ser reasignado
+
+ /*
+ En la mayoría de los casos, Kotlin puede determinar cuál es el tipo de una variable,
+ de tal manera que no tenemos que especificarlo explícitamente cada vez.
+    Podemos declarar explícitamente el tipo de una variable así:
+ */
+ val foo : Int = 7
+
+ /*
+ Las cadenas pueden ser representadas de la misma manera que Java.
+ El escape de caracteres se realiza con una barra invertida.
+ */
+ val fooString = "Mi Cadena está aquí!";
+ val barString = "¿Imprimiendo en una nueva línea?\nNo hay problema!";
+ val bazString = "¿Quíeres agregar una tabulación?\tNo hay problema!";
+ println(fooString);
+ println(barString);
+ println(bazString);
+
+ /*
+ Una cadena está delimitada por comillas triple (""").
+    Estas cadenas pueden contener saltos de línea y otros caracteres.
+ */
+ val fooRawString = """
+ fun helloWorld(val name : String) {
+ println("Hola, mundo!")
+ }
+ """
+ println(fooRawString)
+
+ /*
+ Las cadenas pueden contener interpolación de cadenas.
+    La interpolación de cadenas comienza con un signo de dólar ($).
+ */
+ val fooTemplateString = "$fooString tiene ${fooString.length} caracteres"
+ println(fooTemplateString)
+
+ /*
+ Para que una variable pueda aceptar valor nulo se debe especificar
+ explícitamente como anulable añadiendole ? a su tipo.
+    Podemos acceder a una variable anulable mediante el uso del operador ?.
+    Podemos utilizar el operador ?: para especificar un valor alternativo
+ a usar si una variable es nula.
+ */
+ var fooNullable: String? = "abc"
+ println(fooNullable?.length) // => 3
+ println(fooNullable?.length ?: -1) // => 3
+ fooNullable = null
+ println(fooNullable?.length) // => null
+ println(fooNullable?.length ?: -1) // => -1
+
+
+ /*
+ Las funciones pueden ser declaras usando la palabra clave "fun".
+ Los argumentos de las funciones son especificados entre corchetes despues del nombre de la función.
+ Los argumentos de las funciones pueden tener opcionalmente un valor por defecto.
+ El tipo de retorno de las funciones, de ser requerido, es especificado despues del argumento.
+ */
+ fun hello(name: String = "mundo") : String {
+ return "Hola, $name!"
+ }
+ println(hello("foo")) // => Hola, foo!
+ println(hello(name = "bar")) // => Hola, bar!
+ println(hello()) // => Hola, mundo!
+
+ /*
+ Un parametro de la función puede ser marcado con la palabra clave "vararg"
+ que permite que una función acepte un numero variable de argumentos.
+ */
+ fun varargExample(vararg names: Int) {
+ println("Argument tiene ${names.size} elementos")
+ }
+ varargExample() // => Argument tiene 0 elementos
+ varargExample(1) // => Argument tiene 1 elementos
+ varargExample(1, 2, 3) // => Argument tiene 3 elementos
+
+ /*
+ Cuando una función consiste de una sola expresión entonces las llaves
+ pueden ser omitidas. El cuerpo es especificado despues del símbolo =
+ */
+ fun odd(x: Int): Boolean = x % 2 == 1
+ println(odd(6)) // => false
+ println(odd(7)) // => true
+
+ // Si el tipo de retorno puede ser inferido entonces no se necesita
+ // especificarlo.
+ fun even(x: Int) = x % 2 == 0
+ println(even(6)) // => true
+ println(even(7)) // => false
+
+ // Las funciones pueden tomar funciones como argumentos y
+ // retornar funciones.
+ fun not(f: (Int) -> Boolean) : (Int) -> Boolean {
+ return {n -> !f.invoke(n)}
+ }
+
+ // Las funciones con nombre pueden ser especificadas como argumentos
+ // utilizando el operador ::.
+ val notOdd = not(::odd)
+ val notEven = not(::even)
+ // Las funciones anónimas pueden ser especificadas como argumentos.
+ val notZero = not {n -> n == 0}
+ /*
+ Si una función anónima tiene un solo parametro entonces la declaración
+ puede ser omitida (junto con ->). El nombre del único parametro será "it".
+ */
+ val notPositive = not {it > 0}
+ for (i in 0..4) {
+ println("${notOdd(i)} ${notEven(i)} ${notZero(i)} ${notPositive(i)}")
+ }
+
+ // La palabra clave "class" es usada para declarar clases.
+ class ExampleClass(val x: Int) {
+ fun memberFunction(y: Int) : Int {
+ return x + y
+ }
+
+ infix fun infixMemberFunction(y: Int) : Int {
+ return x * y
+ }
+ }
+ /*
+ Para crear una nueva instancia llamamos al constructor.
+ Nótese que Kotlin no usa la palabra clave "new".
+ */
+ val fooExampleClass = ExampleClass(7)
+ // Las funciones miembros pueden ser llamadas usando la notación de punto (.)
+ println(fooExampleClass.memberFunction(4)) // => 11
+ /*
+ Si una función ha sido marcada con la palabra clave "infix" entonces
+ esta puede ser invocada usando la notación infija.
+ */
+ println(fooExampleClass infixMemberFunction 4) // => 28
+
+ /*
+ Las clases "data" son una manera concisa de crear clases que solo contengan datos.
+ Los metodos "hashCode"/"equals" y "toString" son generados automáticamente.
+ */
+ data class DataClassExample (val x: Int, val y: Int, val z: Int)
+ val fooData = DataClassExample(1, 2, 4)
+ println(fooData) // => DataClassExample(x=1, y=2, z=4)
+
+ // las clases de datos tienen una función "copy".
+ val fooCopy = fooData.copy(y = 100)
+ println(fooCopy) // => DataClassExample(x=1, y=100, z=4)
+
+ // Los objetos pueden ser estructurados en múltiples variables.
+ val (a, b, c) = fooCopy
+ println("$a $b $c") // => 1 100 4
+
+ // La función "with" es similar a la expresión de JavaScript "with".
+ data class MutableDataClassExample (var x: Int, var y: Int, var z: Int)
+ val fooMutableDate = MutableDataClassExample(7, 4, 9)
+ with (fooMutableDate) {
+ x -= 2
+ y += 2
+ z--
+ }
+ println(fooMutableDate) // => MutableDataClassExample(x=5, y=6, z=8)
+
+ /*
+ Podemos crear una lista utilizando la función "listOf".
+ La lista será inmutable - los elementos no pueden ser añadidos o eliminados.
+ */
+ val fooList = listOf("a", "b", "c")
+ println(fooList.size) // => 3
+ println(fooList.first()) // => a
+ println(fooList.last()) // => c
+ // Los elementos de una lista se pueden acceder a través de su índice.
+ println(fooList[1]) // => b
+
+ // Una lista mutable puede ser creada usando la función "mutableListOf".
+ val fooMutableList = mutableListOf("a", "b", "c")
+ fooMutableList.add("d")
+ println(fooMutableList.last()) // => d
+ println(fooMutableList.size) // => 4
+
+ // Podemos crear un set usando la función "setOf".
+ val fooSet = setOf("a", "b", "c")
+ println(fooSet.contains("a")) // => true
+ println(fooSet.contains("z")) // => false
+
+ // Podemos crear un mapa usando la función "mapOf".
+ val fooMap = mapOf("a" to 8, "b" to 7, "c" to 9)
+ // Se puede acceder a los valores del mapa por su llave.
+ println(fooMap["a"]) // => 8
+
+ /*
+ Las secuencias representan colecciones evaluadas diferidamente.
+ Podemos crear una secuencia con la función "generateSequence".
+ */
+ val fooSequence = generateSequence(1, {it + 1})
+ val x = fooSequence.take(10).toList()
+ println(x) // => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+
+ // Un ejemplo usando las secuencias para generar los números de Fibonacci:
+ fun fibonacciSequence() : Sequence<Long> {
+ var a = 0L
+ var b = 1L
+
+ fun next() : Long {
+ val result = a + b
+ a = b
+ b = result
+ return a
+ }
+
+ return generateSequence(::next)
+ }
+ val y = fibonacciSequence().take(10).toList()
+ println(y) // => [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+
+ // Kotlin provee funciones de Orden-Mayor para trabajar con colecciones.
+ val z = (1..9).map {it * 3}
+ .filter {it < 20}
+ .groupBy {it % 2 == 0}
+ .mapKeys {if (it.key) "even" else "odd"}
+ println(z) // => {odd=[3, 9, 15], even=[6, 12, 18]}
+
+ // Un bucle "for" puede ser usado con cualquier cosa que provea un iterador.
+ for (c in "hello") {
+ println(c)
+ }
+
+ // El bucle "while" funciona de la misma manera que en los demás lenguajes.
+ var ctr = 0
+ while (ctr < 5) {
+ println(ctr)
+ ctr++
+ }
+ do {
+ println(ctr)
+ ctr++
+ } while (ctr < 10)
+
+ /*
+ "if" puede ser usado como una expresión que retorna un valor.
+ Por esta razón el operador ternario ?: no es necesario en Kotlin.
+ */
+ val num = 5
+ val message = if (num % 2 == 0) "even" else "odd"
+ println("$num is $message") // => 5 is odd
+
+ // "when" puede ser usado como alternativa a cadenas de "if-else if".
+ val i = 10
+ when {
+ i < 7 -> println("primer bloque")
+ fooString.startsWith("hello") -> println("segundo bloque")
+ else -> println("else bloque")
+ }
+
+ // "when" puede ser usado con argumentos.
+ when (i) {
+ 0, 21 -> println("0 or 21")
+ in 1..20 -> println("in the range 1 to 20")
+ else -> println("none of the above")
+ }
+
+ // "when" puede ser usado como una función que retorna un valor.
+ var result = when (i) {
+ 0, 21 -> "0 or 21"
+ in 1..20 -> "in the range 1 to 20"
+ else -> "none of the above"
+ }
+ println(result)
+
+ /*
+ Podemos analizar si un objeto es de un tipo particular usando el operador "is".
+ Si un objeto pasa un chequeo de tipo entonces éste se puede utilizar como
+ ese tipo sin convertido de forma explícita.
+ */
+ fun smartCastExample(x: Any) : Boolean {
+ if (x is Boolean) {
+ // x es automaticamente convertido a Boolean
+ return x
+ } else if (x is Int) {
+ // x es automaticamente convertido a Int
+ return x > 0
+ } else if (x is String) {
+ // x es automaticamente convertido a String
+ return x.isNotEmpty()
+ } else {
+ return false
+ }
+ }
+ println(smartCastExample("Hola, mundo!")) // => true
+ println(smartCastExample("")) // => false
+ println(smartCastExample(5)) // => true
+ println(smartCastExample(0)) // => false
+ println(smartCastExample(true)) // => true
+
+ /*
+ Las extensiones son una manera de añadir nuevas funcionalidades a una clase.
+ Estas son similares a la extensión de métodos en C#.
+ */
+ fun String.remove(c: Char): String {
+ return this.filter {it != c}
+ }
+ println("Hola, mundo!".remove('l')) // => Hoa, mundo!
+
+ println(EnumExample.A) // => A
+ println(ObjectExample.hello()) // => hola
+}
+
+// Las clases "enum" son similares a los tipos "enum" de Java.
+enum class EnumExample {
+ A, B, C
+}
+
+/*
+La palabra clave "object" se puede utilizar para crear objetos únicos.
+No podemos asignarlo a una variable, pero podemos hacer referencia a ella por su nombre.
+Esto es similar a los objetos únicos de Scala
+*/
+object ObjectExample {
+ fun hello() : String {
+ return "hola"
+ }
+}
+```
+
+### Lectura Adicional
+
+* [Kotlin tutorials (EN)](https://kotlinlang.org/docs/tutorials/)
+* [Try Kotlin in your browser (EN)](http://try.kotlinlang.org/)
+* [A list of Kotlin resources (EN)](http://kotlin.link/)
diff --git a/es-es/php-composer-es.html.markdown b/es-es/php-composer-es.html.markdown
new file mode 100644
index 00000000..3add3e31
--- /dev/null
+++ b/es-es/php-composer-es.html.markdown
@@ -0,0 +1,176 @@
+---
+category: tool
+tool: composer
+contributors:
+ - ["Brett Taylor", "https://github.com/glutnix"]
+translators:
+ - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+filename: LearnComposer-es.sh
+---
+
+[Composer](https://getcomposer.org/) es una herramienta para manejar las dependencias en PHP. Nos permite declarar las librerías de las cuales el proyecto depende y las maneja automáticamente (instala/actualiza) por ti.
+
+# Instalando
+
+```sh
+# Instala el binario 'composer.phar' en el directorio actual
+curl -sS https://getcomposer.org/installer | php
+# Si utiliza este método, tendrá que invocar a 'composer' de esta manera:
+php composer.phar about
+
+# Instala el binario en ~/bin/composer
+# Nota: asegúrese de que ~/bin está en la variable de entorno PATH del shell
+curl -sS https://getcomposer.org/installer | php -- --install-dir=~/bin --filename=composer
+```
+
+Los usuarios de Windows deben seguir las [instrucciones de instalación de Windows (EN)](https://getcomposer.org/doc/00-intro.md#installation-windows)
+
+## Confirmación de la instalación
+
+```sh
+# Comprobar la versión y lista las opciones
+composer
+
+# Obtener más ayuda para las opciones
+composer help require
+
+# Comprueba si composer es capaz hacer las cosas que necesita y si está actualizado
+composer diagnose
+composer diag # versión corta
+
+# Actualiza el binario composer a la última versión
+composer self-update
+composer self # versión corta
+```
+
+# Uso
+
+Composer almacena sus dependencias del proyecto en `composer.json`. Usted puede editar este archivo, pero lo mejor es dejar que composer lo gestione por usted.
+
+```sh
+# Crear un nuevo proyecto en la carpeta actual
+composer init
+# Este corre un cuestionario interactivo que le pide detalles sobre su proyecto.
+# Dejándolos en blanco está bien a menos que usted está haciendo otros proyectos que dependen de éste.
+
+# Si un archivo 'composer.json' ya existe, descargar las dependencias
+composer install
+
+# Para descargar solo las dependencias de producción, es decir, excluyendo las
+# dependencias de desarrollo
+composer install --no-dev
+
+# Añadir una dependencia de producción a este proyecto
+composer require guzzlehttp/guzzle
+# Composer buscará cuál es la última versión de guzzlehttp/Guzzle, lo descarga,
+# y finalmente añade la nueva dependencia al campo requerido en 'composer.json'.
+
+composer require guzzlehttp/guzzle:6.0.*
+# Composer descargará la versión más reciente que coincida con el patrón
+# (ej 6.0.2) y añade la dependencia al campo requerido en 'composer.json'.
+
+composer require --dev phpunit/phpunit:~4.5.0
+# Se requerirá como una dependencia de desarrollo. Se usará la última
+# versión >= 4.5.0 y < 4.6.0
+
+composer require-dev phpunit/phpunit:^4.5.0
+# Se requerirá como una dependencia de desarrollo. Se usará la última versión >= 4.5.0 y < 5.0
+
+# Para obtener más información sobre las coincidencias de versiones de Composer,
+ver [La Documentación de Composer\'s Sobre Versiones (EN)](https://getcomposer.org/doc/articles/versions.md)
+
+# Para ver qué opciones están disponibles para instalar y los paquetes instalados actualmente
+composer show
+
+# Para ver qué paquetes están instalados actualmente
+composer show --installed
+
+# Para encontrar un paquete con 'mailgun' en su nombre o descripción
+composer search mailgun
+```
+
+[Packagist.org (EN)](https://packagist.org/) es el repositorio principal de paquetes de Composer. Busca allí para paquetes existentes de terceros.
+
+## `composer.json` vs `composer.lock`
+
+El archivo `composer.json` almacena las preferencias de versión flotantes de su proyecto para cada dependencia, junto con otra información.
+
+El archivo `composer.lock` almacena exactamente cuál es la versión que ha descargado para cada dependencia. Nunca editar este archivo.
+
+Si se incluye el archivo `composer.lock` en su repositorio git, todos los desarrolladores instalarán la versión utilizada actualmente de la dependencia. Incluso cuando se libera una nueva versión de una dependencia, Composer continuará para descargar la versión grabada en el archivo '.lock'.
+
+```sh
+# Si desea actualizar todas las dependencias a su versión más reciente aún que coincidan con sus preferencias versión
+composer update
+
+# Si desea la nueva versión de una dependencia particular:
+composer update phpunit/phpunit
+
+# Si desea migrar la preferencia de un paquete a una versión más reciente, puede que tenga que quitar primero el paquete de más antiguo y sus dependencias.
+composer remove --dev phpunit/phpunit
+composer require --dev phpunit/phpunit:^5.0
+
+```
+
+## Autocargador
+
+Composer crea una clase de cargador automático que puede requerir su aplicación. Se puede hacer instancias de clases a través de su espacio de nombres.
+
+```php
+require __DIR__ . '/vendor/autoload.php';
+
+$mailgun = new Mailgun\Mailgun("key");
+```
+
+### PSR-4 Autocargador
+
+Usted puede añadir sus propios espacios de nombres para el cargador automático.
+
+En `composer.json`, añadir el campo 'autoload':
+
+```json
+{
+ "autoload": {
+ "psr-4": {"Acme\\": "src/"}
+ }
+}
+```
+Esto le indicará al cargador automático que busque cualquier cosa en el espacio de nombres `\Acme\` dentro de la carpeta src`.
+
+También puedes usar [usar PSR-0, un mapa de clase o simplemente una lista de archivos para incluir (EN)](https://getcomposer.org/doc/04-schema.md#autoload). También está el campo `autoload-dev` para espacios de nombres de sólo desarrollo.
+
+Al añadir o modificar la clave de carga automática, tendrá que reconstruir el cargador automático:
+
+```sh
+composer dump-autoload
+composer dump # shorthand
+
+# Optimiza los paquetes PSR0 y PSR4 a ser cargados con classmaps también. Es lento para correr, pero mejora el rendimiento en producción.
+composer dump-autoload --optimize --no-dev
+```
+
+# El Cache de Composer
+
+```sh
+# Composer retendrá los paquetes descargados para su uso en el futuro. Puede removerlos con:
+composer clear-cache
+```
+
+# Solución de problemas
+
+```sh
+composer diagnose
+composer self-update
+composer clear-cache
+```
+
+## Temas (todavía) no cubiertos en este tutorial
+
+* Crear y distribuir tus propios paquetes en Packagist.org o en otra parte
+* Pre- y post- script: ejecutar tareas cuando ciertos eventos tienen lugar composer
+
+### Referencias
+
+* [Composer - Dependency Manager for PHP (EN)](https://getcomposer.org/)
+* [Packagist.org (EN)](https://packagist.org/) \ No newline at end of file
diff --git a/es-es/racket-es.html.markdown b/es-es/racket-es.html.markdown
new file mode 100644
index 00000000..a49509c7
--- /dev/null
+++ b/es-es/racket-es.html.markdown
@@ -0,0 +1,683 @@
+---
+language: racket
+filename: learnracket-es.rkt
+contributors:
+ - ["th3rac25", "https://github.com/voila"]
+ - ["Eli Barzilay", "https://github.com/elibarzilay"]
+ - ["Gustavo Schmidt", "https://github.com/gustavoschmidt"]
+ - ["Duong H. Nguyen", "https://github.com/cmpitg"]
+ - ["Keyan Zhang", "https://github.com/keyanzhang"]
+translators:
+ - ["Carlos Roman", "https://github.com/carlochess"]
+lang: es-es
+---
+Racket es un lenguaje de propósito general, multiparadigma que hace parte de la familia Lisp/Scheme.
+
+```racket
+#lang racket ; Define el lenguaje que usas
+
+;;; Comentarios
+
+;; Los comentarios de una sola línea inician con un punto y coma
+
+#| Un bloque de comentarios
+ puede distribuirse en varias líneas...
+ #|
+ ¡Incluso puede estar anidado!
+ |#
+|#
+
+;; Los comentarios descartan la siguiente expresión,
+;; pero son útiles para comentar expresiones al momento de depurar el código
+#; (Esta expresión es descartada)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 1. Tipos de datos primitivos y operadores
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Numeros
+9999999999999999999999 ; Enteros
+#b111 ; binario => 7
+#o111 ; octal => 73
+#x111 ; hexadecimal => 273
+3.14 ; reales
+6.02e+23
+1/2 ; racionaless
+1+2i ; numeros complejos
+
+;; La aplicación de funciones es escrita de la siguiente forma: (f x y z ...)
+;; donde f es una función y “x, y, z” son sus operandos
+;; Si quieres crear una lista de literales debes agregar ' al inicio
+;; para que no sean evaluados
+'(+ 1 2) ; => (+ 1 2)
+;; Ahora algunas operaciones aritméticas
+(+ 1 1) ; => 2
+(- 8 1) ; => 7
+(* 10 2) ; => 20
+(expt 2 3) ; => 8
+(quotient 5 2) ; => 2
+(remainder 5 2) ; => 1
+(/ 35 5) ; => 7
+(/ 1 3) ; => 1/3
+(exact->inexact 1/3) ; => 0.3333333333333333
+(+ 1+2i 2-3i) ; => 3-1i
+
+;;; Booleanos
+#t ; Para verdadero (true)
+#f ; Para falso (false) -- cualquier valor distinto de #f es verdadero
+(not #t) ; => #f
+(and 0 #f (error "No entra aquí")) ; => #f
+(or #f 0 (error "No entra aquí")) ; => 0
+
+;;; Caracteres
+#\A ; => #\A
+#\λ ; => #\λ
+#\u03BB ; => #\λ
+
+;;; Los Strings tienen una longitud fija
+"Hello, world!"
+"Benjamin \"Bugsy\" Siegel" ; backslash es un caracter de escape
+"Foo\tbar\41\x21\u0021\a\r\n" ; incluye escape para C, Unicode
+"λx:(μα.α→α).xx" ; Puedes incluir caracteres Unicode
+
+;; ¡Los tipos de dato Strings pueden unirse tambien!
+(string-append "Hello " "world!") ; => "Hello world!"
+
+;; Un string puede ser tratado como una lista de caracteres
+(string-ref "Apple" 0) ; => #\A
+
+;; la función format puede usarse para darle formato a un string:
+(format "~a can be ~a" "strings" "formatted")
+
+;; Imprimir en consola es muy simple
+(printf "I'm Racket. Nice to meet you!\n")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 2. Variables
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; Puedes crear una variable usando define
+;; el nombre de una variable puede contener cualquier nombre excepto: ()[]{}",'`;#|\
+(define some-var 5)
+some-var ; => 5
+
+;; También puedes usar caracteres unicode
+(define ⊆ subset?)
+(⊆ (set 3 2) (set 1 2 3)) ; => #t
+
+;; Acceder a una variable no definida con anterioridad resulta en una excepción
+; x ; => x: undefined ...
+
+;; Local binding: La variable 'me' esta limitada a tomar el valor "Bob" dentro del ambiente (let ...)
+(let ([me "Bob"])
+ "Alice"
+ me) ; => "Bob"
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Estructuras y colecciones
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Estructuras
+(struct dog (name breed age))
+(define my-pet
+ (dog "lassie" "collie" 5))
+my-pet ; => #<dog>
+(dog? my-pet) ; => #t
+(dog-name my-pet) ; => "lassie"
+
+;;; Parejas (Inmutables)
+;; 'cons' construye parejas, 'car' y 'cdr' extraen el primer
+;; y segundo elemento respectivamente de una pareja
+(cons 1 2) ; => '(1 . 2)
+(car (cons 1 2)) ; => 1
+(cdr (cons 1 2)) ; => 2
+
+;;; Listas
+
+;; Las Listas son estructuras secuenciales no indexadas, hechas con ‘cons’ y
+;; con un 'null' (o '()) para denotar el final de la lista
+(cons 1 (cons 2 (cons 3 null))) ; => '(1 2 3)
+;; 'list' es otro constructor apropiado para las listas
+(list 1 2 3) ; => '(1 2 3)
+;; y el simbolo comilla (') puede ser usado en una lista de valores literales
+'(1 2 3) ; => '(1 2 3)
+
+;; Aquí aun se puede usar 'cons' para agregar un elemento al comienzo de la lista
+(cons 4 '(1 2 3)) ; => '(4 1 2 3)
+
+;; El uso de 'append' para unir un par de listas
+(append '(1 2) '(3 4)) ; => '(1 2 3 4)
+
+;; Las listas son un tipo de dato básico, por lo cual proveen numerosas funcionalidades;
+;; algunos ejemplos son:
+(map add1 '(1 2 3)) ; => '(2 3 4)
+(map + '(1 2 3) '(10 20 30)) ; => '(11 22 33)
+(filter even? '(1 2 3 4)) ; => '(2 4)
+(count even? '(1 2 3 4)) ; => 2
+(take '(1 2 3 4) 2) ; => '(1 2)
+(drop '(1 2 3 4) 2) ; => '(3 4)
+
+;;; Vectores
+
+;; Los Vectores son arreglos de longitud fija
+#(1 2 3) ; => '#(1 2 3)
+
+;; Se usa 'vector-append' para unir dos vectores
+(vector-append #(1 2 3) #(4 5 6)) ; => #(1 2 3 4 5 6)
+
+;;; Conjuntos
+
+;; Crear un conjunto a partir de una lista
+(list->set '(1 2 3 1 2 3 3 2 1 3 2 1)) ; => (set 1 2 3)
+
+;; Agregar/Asignar un nuevo elemento 'set-add'
+;; (Funcional: retorna un conjunto extendido en vez de una mutar la entrada)
+(set-add (set 1 2 3) 4) ; => (set 1 2 3 4)
+
+;; Remueve el elemento agregado anteriormente 'set-remove'
+(set-remove (set 1 2 3) 1) ; => (set 2 3)
+
+;; Prueba la existencia de un elemento con la funcion 'set-member?'
+(set-member? (set 1 2 3) 1) ; => #t
+(set-member? (set 1 2 3) 4) ; => #f
+
+;;; Tablas Hashs
+
+;; Crea una tabla hash inmutable (Abajo presentamos un ejemplo)
+(define m (hash 'a 1 'b 2 'c 3))
+
+;; Conseguir un valor
+(hash-ref m 'a) ; => 1
+
+;; Conseguir un valor que no está presente es una excepción
+; (hash-ref m 'd) => no value found
+
+;; Puedes proveer un valor por defecto si el valor para la llave no se encuentra
+(hash-ref m 'd 0) ; => 0
+
+;; Usa 'hash-set' para ampliar un tabla hash “inmutable”
+;; (Retorna la tabla hash extendida en vez de una mutarla)
+(define m2 (hash-set m 'd 4))
+m2 ; => '#hash((b . 2) (a . 1) (d . 4) (c . 3))
+
+;; ¡Recuerde que estas tablas hash son inmutables!
+m ; => '#hash((b . 2) (a . 1) (c . 3)) <-- no 'd'
+
+;; Usa 'hash-remove' para quitar las llaves de la tabla hash (functional tambien)
+(hash-remove m 'a) ; => '#hash((b . 2) (c . 3))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 3. Funciones
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Usa 'lambda' para crear funciones.
+;; Una función siempre retorna el valor de su última expresión
+(lambda () "Hello World") ; => #<procedure>
+;; También se puede usar el caracter Unicode 'λ'
+(λ () "Hello World") ; => same function
+
+;; Usa los paréntesis exteriores para llamar la función
+((lambda () "Hello World")) ; => "Hello World"
+((λ () "Hello World")) ; => "Hello World"
+
+;; Asigna una función a una variable
+(define hello-world (lambda () "Hello World"))
+(hello-world) ; => "Hello World"
+
+;; Puede acortar esto usando el azúcar sintáctico para la definición de una función:
+(define (hello-world2) "Hello World")
+
+;; El paréntesis () del ejemplo anterior denota la lista de argumentos para la función
+(define hello
+ (lambda (name)
+ (string-append "Hello " name)))
+(hello "Steve") ; => "Hello Steve"
+;; ... O de forma similar, usando el azúcar sintáctico para una definición:
+(define (hello2 name)
+ (string-append "Hello " name))
+
+;; Puedes tener una función con parametros variables, using 'case-lambda'
+(define hello3
+ (case-lambda
+ [() "Hello World"]
+ [(name) (string-append "Hello " name)]))
+(hello3 "Jake") ; => "Hello Jake"
+(hello3) ; => "Hello World"
+;; ... o especificar los argumentos opcionales junto con su valor por defecto
+(define (hello4 [name "World"])
+ (string-append "Hello " name))
+
+;; Las funciones pueden tener argumentos extra empaquetados como una lista
+(define (count-args . args)
+ (format "You passed ~a args: ~a" (length args) args))
+(count-args 1 2 3) ; => "You passed 3 args: (1 2 3)"
+;; ... o sin usar el azúcar sintáctico:
+(define count-args2
+ (lambda args
+ (format "You passed ~a args: ~a" (length args) args)))
+
+;; Puedes combinar argumentos regulares y empaquetados
+(define (hello-count name . args)
+ (format "Hello ~a, you passed ~a extra args" name (length args)))
+(hello-count "Finn" 1 2 3)
+; => "Hello Finn, you passed 3 extra args"
+;; ... Sin usar azúcar sintáctica:
+(define hello-count2
+ (lambda (name . args)
+ (format "Hello ~a, you passed ~a extra args" name (length args))))
+
+;; Y con keywords
+(define (hello-k #:name [name "World"] #:greeting [g "Hello"] . args)
+ (format "~a ~a, ~a extra args" g name (length args)))
+(hello-k) ; => "Hello World, 0 extra args"
+(hello-k 1 2 3) ; => "Hello World, 3 extra args"
+(hello-k #:greeting "Hi") ; => "Hi World, 0 extra args"
+(hello-k #:name "Finn" #:greeting "Hey") ; => "Hey Finn, 0 extra args"
+(hello-k 1 2 3 #:greeting "Hi" #:name "Finn" 4 5 6)
+ ; => "Hi Finn, 6 extra args"
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 4. Comparando
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Para números usa '='
+(= 3 3.0) ; => #t
+(= 2 1) ; => #f
+
+;; 'eq?' retorna #t si 2 argumentos refieren al mismo objeto en memoria
+;; #f de lo contrario.
+;; En otras palabras, es una simple comparación de punteros.
+(eq? '() '()) ; => #t, Debido a que existe solo una lista vacia en memoria
+(let ([x '()] [y '()])
+ (eq? x y)) ; => #t, igual que arriba
+
+(eq? (list 3) (list 3)) ; => #f
+(let ([x (list 3)] [y (list 3)])
+ (eq? x y)) ; => #f — ¡No es la misma lista en memoria!
+
+(let* ([x (list 3)] [y x])
+ (eq? x y)) ; => #t, debido a que ‘x’ y ‘y’ ahora apuntan a la misma posición en memoria
+
+(eq? 'yes 'yes) ; => #t
+(eq? 'yes 'no) ; => #f
+
+(eq? 3 3) ; => #t — Te cuidado aqui
+ ; es mejor usar '=' para comparacion de numeros.
+(eq? 3 3.0) ; => #f
+
+(eq? (expt 2 100) (expt 2 100)) ; => #f
+(eq? (integer->char 955) (integer->char 955)) ; => #f
+
+(eq? (string-append "foo" "bar") (string-append "foo" "bar")) ; => #f
+
+;; 'eqv?' permite comparar números y caracteres..
+;; for other datatypes, 'eqv?' and 'eq?' return the same result.
+(eqv? 3 3.0) ; => #f
+(eqv? (expt 2 100) (expt 2 100)) ; => #t
+(eqv? (integer->char 955) (integer->char 955)) ; => #t
+
+(eqv? (string-append "foo" "bar") (string-append "foo" "bar")) ; => #f
+
+;; 'equal?' permite comparar los siguientes tipos de datos:
+;; strings, byte strings, pairs, mutable pairs, vectors, boxes,
+;; hash tables, and inspectable estructuras.
+;; para otros tipos de datos, 'equal?' y 'eqv?' devuelven el mismo resultado.
+(equal? 3 3.0) ; => #f
+(equal? (string-append "foo" "bar") (string-append "foo" "bar")) ; => #t
+(equal? (list 3) (list 3)) ; => #t
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 5. Control de flujo
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Condicionales
+
+(if #t ; expresión de prueba
+ "this is true" ; expresión si la expresión de prueba es verdadera
+ "this is false") ; de lo contrario expression
+; => "this is true"
+
+;; En condicionales, todos los valores que no son #f son tratados como verdadero
+(member 'Groucho '(Harpo Groucho Zeppo)) ; => '(Groucho Zeppo)
+(if (member 'Groucho '(Harpo Groucho Zeppo))
+ 'yep
+ 'nope)
+; => 'yep
+
+;; Las expresiones 'cond' son una serie de pruebas para seleccionar el resultado
+(cond [(> 2 2) (error "wrong!")]
+ [(< 2 2) (error "wrong again!")]
+ [else 'ok]) ; => 'ok
+
+;;; Coincidencia de patrones (Pattern Matching)
+
+(define (fizzbuzz? n)
+ (match (list (remainder n 3) (remainder n 5))
+ [(list 0 0) 'fizzbuzz]
+ [(list 0 _) 'fizz]
+ [(list _ 0) 'buzz]
+ [_ #f]))
+
+(fizzbuzz? 15) ; => 'fizzbuzz
+(fizzbuzz? 37) ; => #f
+
+;;; Ciclos
+
+;; Los ciclos pueden expresarse a través de recursión (de cola)
+(define (loop i)
+ (when (< i 10)
+ (printf "i=~a\n" i)
+ (loop (add1 i))))
+(loop 5) ; => i=5, i=6, ...
+
+;; De igual forma, con un let
+(let loop ((i 0))
+ (when (< i 10)
+ (printf "i=~a\n" i)
+ (loop (add1 i)))) ; => i=0, i=1, ...
+
+;; El siguiente ejemplo muestra cómo expresar un ciclo for, pero Racket tiene
+;; otra forma aún más flexible de expresarlos:
+(for ([i 10])
+ (printf "i=~a\n" i)) ; => i=0, i=1, ...
+(for ([i (in-range 5 10)])
+ (printf "i=~a\n" i)) ; => i=5, i=6, ...
+
+;;; Iterando sobre otras secuencias
+;; 'for' permite iterar sobre varios tipos de secuencias:
+;; lists, vectors, strings, sets, hash tables, etc...
+
+(for ([i (in-list '(l i s t))])
+ (displayln i))
+
+(for ([i (in-vector #(v e c t o r))])
+ (displayln i))
+
+(for ([i (in-string "string")])
+ (displayln i))
+
+(for ([i (in-set (set 'x 'y 'z))])
+ (displayln i))
+
+(for ([(k v) (in-hash (hash 'a 1 'b 2 'c 3 ))])
+ (printf "key:~a value:~a\n" k v))
+
+;;; Iteradores mas sofisticados
+
+;; Escaneo paralelo de múltiples secuencias (se detiene en la más pequeña)
+(for ([i 10] [j '(x y z)]) (printf "~a:~a\n" i j))
+; => 0:x 1:y 2:z
+
+;; Loops anidados
+(for* ([i 2] [j '(x y z)]) (printf "~a:~a\n" i j))
+; => 0:x, 0:y, 0:z, 1:x, 1:y, 1:z
+
+;; Condicionales
+(for ([i 1000]
+ #:when (> i 5)
+ #:unless (odd? i)
+ #:break (> i 10))
+ (printf "i=~a\n" i))
+; => i=6, i=8, i=10
+
+;;; Secuncias por compresión
+;; Muy similar a los ciclos 'for' -- solo recolectando los resultados
+
+(for/list ([i '(1 2 3)])
+ (add1 i)) ; => '(2 3 4)
+
+(for/list ([i '(1 2 3)] #:when (even? i))
+ i) ; => '(2)
+
+(for/list ([i 10] [j '(x y z)])
+ (list i j)) ; => '((0 x) (1 y) (2 z))
+
+(for/list ([i 1000] #:when (> i 5) #:unless (odd? i) #:break (> i 10))
+ i) ; => '(6 8 10)
+
+(for/hash ([i '(1 2 3)])
+ (values i (number->string i)))
+; => '#hash((1 . "1") (2 . "2") (3 . "3"))
+
+;; Existen otras formas de recolectar los valores usando otras expresiones:
+(for/sum ([i 10]) (* i i)) ; => 285
+(for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000
+(for/and ([i 10] [j (in-range 10 20)]) (< i j)) ; => #t
+(for/or ([i 10] [j (in-range 0 20 2)]) (= i j)) ; => #t
+;; Y para usar cualquier combinación arbitraria, use 'for/fold'
+(for/fold ([sum 0]) ([i '(1 2 3 4)]) (+ sum i)) ; => 10
+;; (Esto frecuentemente reemplaza los ciclos en los lenguajes imperativos)
+
+;;; Excepciones
+
+;; Para atrapar excepciones, usa las funciones 'with-handlers'
+(with-handlers ([exn:fail? (lambda (exn) 999)])
+ (+ 1 "2")) ; => 999
+(with-handlers ([exn:break? (lambda (exn) "no time")])
+ (sleep 3)
+ "phew") ; => "phew", pero si usa un break => "no time"
+
+;; Usa 'raise' para lanzar una excepción o cualquier otro valor
+(with-handlers ([number? ; atrapa valores numericos lanzados
+ identity]) ; los retorna como valores
+ (+ 1 (raise 2))) ; => 2
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 6. Mutación
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Usa 'set!' para asignar un nuevo valor a una variable existente
+(define n 5)
+(set! n (add1 n))
+n ; => 6
+
+;; Usa boxes para valores explícitamente mutables (similar a punteros o
+;; referencias en otros lenguajes)
+(define n* (box 5))
+(set-box! n* (add1 (unbox n*)))
+(unbox n*) ; => 6
+
+;; Muchos tipos de datos en Racket son inmutables (pairs, lists, etc), algunos poseen
+;; ambos sabores mutable e immutable (strings, vectors, hash tables,
+;; etc...)
+
+;; Usa 'vector' o 'make-vector' para crear vectores mutables
+(define vec (vector 2 2 3 4))
+(define wall (make-vector 100 'bottle-of-beer))
+;; Usa vector-set! para actualizar una posición
+(vector-set! vec 0 1)
+(vector-set! wall 99 'down)
+vec ; => #(1 2 3 4)
+
+;; Crea una tabla hash vacía y manipulata
+(define m3 (make-hash))
+(hash-set! m3 'a 1)
+(hash-set! m3 'b 2)
+(hash-set! m3 'c 3)
+(hash-ref m3 'a) ; => 1
+(hash-ref m3 'd 0) ; => 0
+(hash-remove! m3 'a)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 7. Modulos
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Los Modulos permiten organizar el código en multiples archivos para reusarlos
+;; en bibliotecas; Aquí usamos sub-modules, anidados en todo el modulo que
+;; este texto hace (empezando desde la línea "#lang")
+
+(module cake racket/base ; definimos un modulo llamado 'cake' basado en racket/base
+
+ (provide print-cake) ; function exportada por el modulo
+
+ (define (print-cake n)
+ (show " ~a " n #\.)
+ (show " .-~a-. " n #\|)
+ (show " | ~a | " n #\space)
+ (show "---~a---" n #\-))
+
+ (define (show fmt n ch) ; función interna
+ (printf fmt (make-string n ch))
+ (newline)))
+
+;; Usa 'require' para obtener todos los nombre que provee un modulo
+(require 'cake) ; el apostrofe ' indica que es un submódulo local
+(print-cake 3)
+; (show "~a" 1 #\A) ; => error, la función 'show' no fue exportada
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 8. Clases y objectos
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Crea una clase llamada fish% (-% Es un una forma de indicar los límites de la clase)
+(define fish%
+ (class object%
+ (init size) ; inicialización del argumento
+ (super-new) ; inicialización de la superclase
+ ;; Campo
+ (define current-size size)
+ ;; Metodos públicos
+ (define/public (get-size)
+ current-size)
+ (define/public (grow amt)
+ (set! current-size (+ amt current-size)))
+ (define/public (eat other-fish)
+ (grow (send other-fish get-size)))))
+
+;; Crea una instancia de la clase fish%
+(define charlie
+ (new fish% [size 10]))
+
+;; Usa 'send' para llamar un método de un objeto
+(send charlie get-size) ; => 10
+(send charlie grow 6)
+(send charlie get-size) ; => 16
+
+;; 'fish%' is a plain "first class" value, which can get us mixins
+(define (add-color c%)
+ (class c%
+ (init color)
+ (super-new)
+ (define my-color color)
+ (define/public (get-color) my-color)))
+(define colored-fish% (add-color fish%))
+(define charlie2 (new colored-fish% [size 10] [color 'red]))
+(send charlie2 get-color)
+;; o, sin nombres:
+(send (new (add-color fish%) [size 10] [color 'red]) get-color)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 9. Macros
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Las Macros te permite extender la sintaxis del lenguaje
+
+;; Agreguemos un ciclo while
+(define-syntax-rule (while condition body ...)
+ (let loop ()
+ (when condition
+ body ...
+ (loop))))
+
+(let ([i 0])
+ (while (< i 10)
+ (displayln i)
+ (set! i (add1 i))))
+
+;; Las Macros son higienicas, ¡no puedes aplastar las variables existentes!
+(define-syntax-rule (swap! x y) ; -! es un caracter que indica mutación
+ (let ([tmp x])
+ (set! x y)
+ (set! y tmp)))
+
+(define tmp 2)
+(define other 3)
+(swap! tmp other)
+(printf "tmp = ~a; other = ~a\n" tmp other)
+;; La variable 'tmp' es renombrada a 'tmp_1'
+;; Para evitar el conflicto de nombres
+;; (let ([tmp_1 tmp])
+;; (set! tmp other)
+;; (set! other tmp_1))
+
+;; Pero aun hay algunas transfromaciones de código, por ejemplo:
+(define-syntax-rule (bad-while condition body ...)
+ (when condition
+ body ...
+ (bad-while condition body ...)))
+;; Esta macro es incorrecta: genera código infinitamente, si tratas de usarla
+;; el compilador entrará en un ciclo infinito
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 10. Contratos
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Los Contratos imponen restricciones a los valores exportados desde los módulos
+
+(module bank-account racket
+ (provide (contract-out
+ [deposit (-> positive? any)] ; Los montos siempre son positivos
+ [balance (-> positive?)]))
+
+ (define amount 0)
+ (define (deposit a) (set! amount (+ amount a)))
+ (define (balance) amount)
+ )
+
+(require 'bank-account)
+(deposit 5)
+
+(balance) ; => 5
+
+;; El cliente intenta depositar un monto negativo por lo cual es rechazado
+;; (deposit -5) ; => depósito: violación del contrato
+;; expected: positive?
+;; given: -5
+;; more details....
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; 11. Entrada y salida
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; Racket tiene el concepto de "port", el cual es muy similar al de descriptores
+;; de ficheros en otros lenguajes
+
+;; Abre "/tmp/tmp.txt" y escribe "Hello World"
+;; Esto lanzará un error si el archivo existe
+(define out-port (open-output-file "/tmp/tmp.txt"))
+(displayln "Hello World" out-port)
+(close-output-port out-port)
+
+;; Agregar información a "/tmp/tmp.txt" (incluso si el archivo existe)
+(define out-port (open-output-file "/tmp/tmp.txt"
+ #:exists 'append))
+(displayln "Hola mundo" out-port)
+(close-output-port out-port)
+
+;; Lee del archivo de nuevo
+(define in-port (open-input-file "/tmp/tmp.txt"))
+(displayln (read-line in-port))
+; => "Hello World"
+(displayln (read-line in-port))
+; => "Hola mundo"
+(close-input-port in-port)
+
+;; Alternativamente, haciendo uso de call-with-output-file no necesitas expresamente
+;; cerrar el archivo
+(call-with-output-file "/tmp/tmp.txt"
+ #:exists 'update ; Rewrite the content
+ (λ (out-port)
+ (displayln "World Hello!" out-port)))
+
+;; Y usar la función call-with-input-file hace lo mismo para la entrada
+(call-with-input-file "/tmp/tmp.txt"
+ (λ (in-port)
+ (displayln (read-line in-port))))
+```
+
+## Mas información
+
+¿Quieres saber mas? Prueba en [Empezando con Racket](http://docs.racket-lang.org/getting-started/)
+
+
+
+
diff --git a/es-es/ruby-ecosystem-es.html.markdown b/es-es/ruby-ecosystem-es.html.markdown
new file mode 100644
index 00000000..9ce62ef5
--- /dev/null
+++ b/es-es/ruby-ecosystem-es.html.markdown
@@ -0,0 +1,157 @@
+---
+category: tool
+tool: ruby ecosystem
+contributors:
+ - ["Jon Smock", "http://github.com/jonsmock"]
+ - ["Rafal Chmiel", "http://github.com/rafalchmiel"]
+translators:
+ - ["Ale Mohamad", "http://twitter.com/alemohamad"]
+lang: es-es
+---
+
+Las personas que usan Ruby en general tienen una tendencia a instalar diferentes
+versiones de Ruby, administrar sus paquetes (o gemas), y gestionar las
+dependencias de sus gemas.
+
+## Gestores de Ruby
+
+Algunas plataformas ya tienen Ruby pre-instalado o disponible como un paquete
+propio. Muchos rubystas no utilizan estas versiones, o si lo hacen, solo lo
+utilizan para preparar otra instalación o implementación de Ruby. En lugar de
+eso, los rubystas tienden a instalar un gestor de Ruby para poder instalar
+diferentes versiones y poder cambiar dependiendo del entorno de cada proyecto.
+
+Los siguientes son gestores populares de entorno de Ruby:
+
+* [RVM](https://rvm.io/) - Instala y cambia versiones de Ruby. Además RVM tiene
+ el concepto de gemsets para aislar complemtante entornos de proyectos.
+* [ruby-build](https://github.com/sstephenson/ruby-build) - Solo instala
+ versiones de Ruby. Se utiliza para tener un control más fino sobre las
+ versiones instaladas de Ruby.
+* [rbenv](https://github.com/sstephenson/rbenv) - Solo se utiliza para cambiar
+ la versión de Ruby. Se utiliza junto con ruby-build. Se utiliza para tener un
+ control más fino sobre cómo se carga Ruby en el sistema.
+* [chruby](https://github.com/postmodern/chruby) - Solo se utiliza para cambiar
+ la versión de Ruby. En espíritu es similar a rbenv. No le es tan importante
+ como son instaladas las versiones de Ruby.
+
+## Versiones de Ruby
+
+Ruby fue creado por Yukihiro "Matz" Matsumoto, quien se mantiene como una
+especie de [BDFL](https://en.wikipedia.org/wiki/Benevolent_Dictator_for_Life),
+aunque recientemente está cambiando. Como resultado, la implementación de
+referencia de Ruby es llamada MRI (Matz' Reference Implementation), y cuando se
+habla de una versión de Ruby, se está haciendo referencia a la versión inicial
+de MRI.
+
+Las tres versiones mayores en uso de Ruby son:
+
+* 2.0.0 - Lanzada en Febrero de 2013. La mayoría de las librerías importantes y
+ frameworks soportan 2.0.0.
+* 1.9.3 - Lanzada en Octubre de 2011. Es la versión que actualmente usan más
+ rubystas. Además fue
+ [retirada](https://www.ruby-lang.org/en/news/2015/02/23/support-for-ruby-1-9-3-has-ended/)
+* 1.8.7 - Ruby 1.8.7 fue
+ [retirada](http://www.ruby-lang.org/en/news/2013/06/30/we-retire-1-8-7/).
+
+El cambio de 1.8.7 a 1.9.x es un cambio mucho mayor que de 1.9.3 a 2.0.0. Por
+ejemplo, la serie 1.9 presentó codificaciones (encodings) y un bytecode VM.
+Todavía hay proyectos que utilizan 1.8.7, pero se están convirtiendo en una
+pequeña minoría, debido a que la mayor parte de la comunidad está utilizando
+como mínimo 1.9.2 o 1.9.3.
+
+## Implementaciones de Ruby
+
+El ecosistema de Ruby disfruta de muchas diferentes implementaciones de Ruby,
+cada una con fortalezas únicas y estados de compatibilidad. Para ser claros, las
+diferentes implementaciones están escritas en diferentes lenguajes, pero *todas
+son Ruby*. Cada implementación tiene hooks especiales y características extra,
+pero todas interpretan archivos Ruby de forma normal. Por ejemplo, JRuby está
+escrito en Java, pero no necesitás saber de Java para poder utilizarla.
+
+Muy maduras/compatibles:
+
+* [MRI](https://github.com/ruby/ruby) - Escrita en C, es la implementación de
+ referencia de Ruby. Por definición es 100% compatible (consigo misma). Las
+ otras implementaciones de Ruby mantienen compatibilidad con MRI (ver
+ [RubySpec](#rubyspec) más abajo).
+* [JRuby](http://jruby.org/) - Escrita en Java y Ruby, esta implementación es
+ robusta y bastante veloz. Más importante, la fortaleza de JRuby reside en la
+ interoperabilidad con JVM/Java, pudiendo utilizar herramientas, proyectos y
+ lenguajes ya existentes en JVM.
+* [Rubinius](http://rubini.us/) - Escrita principalmente en Ruby junto con un
+ bytecode VM de C++. Además es bastante madura y veloz. Debido a que está
+ implementada de forma directa en Ruby, expone varias funcionalidades de VM en
+ rubyland.
+
+Medianamente maduras/compatibles:
+
+* [Maglev](http://maglev.github.io/) - Construida sobre Gemstone, una VM de
+ Smalltalk. Smalltalk tiene herramientas que son impresionantes, y este
+ proyecto intenta llevar eso dentro del desarrollo con Ruby.
+* [RubyMotion](http://www.rubymotion.com/) - Lleva Ruby al desarrollo en iOS.
+
+No tan maduras/compatibles:
+
+* [Topaz](http://topazruby.com/) - Escrito en RPython (usando el intérprete
+ PyPy), Topaz es bastante joven y no tan compatible. Se muestra prometedor para
+ ser una implementación de Ruby de alta performance.
+* [IronRuby](http://ironruby.net/) - Escrita en C#, apuntando a la plataforma
+ .NET. El trabajo en IronRuby parece haberse detenido desde que Microsoft
+ retiró su soporte.
+
+Las implementaciones de Ruby pueden tener su propio número de versión de
+release, pero siempre apuntan a una versión específica de MRI para poder tener
+compatibilidad. Muchas implementaciones tienen la habilidad de trabajar en
+diferentes modos (por ejemplo, modo 1.8 o 1.9) para especificar a qué versión de
+MRI están apuntando.
+
+## RubySpec
+
+Muchas implementaciones de Ruby dependen en gran medida de
+[RubySpec](http://rubyspec.org/). Ruby no tiene una especificación oficial, por
+lo que la comunidad ha escrito especificaciones ejecutables en Ruby para poder
+testear la compatibilidad de sus implementaciones con MRI.
+
+## RubyGems
+
+[RubyGems](http://rubygems.org/) es un manejador de paquetes/comunidad de Ruby.
+RubyGems viene incluido con Ruby, por lo que no hay necesidad de instalarlo por
+separado.
+
+Los paquetes de Ruby son llamados "gemas" ("gems"), y pueden ser alojados por la
+comunidad en RubyGems.org. Cada gema contiene su código fuente y algo de
+metadata, incluyendo cosas como la versión, dependencias, autor(es), y
+licencia(s).
+
+## Bundler
+
+[Bundler](http://bundler.io/) es una herramienta para resolución de dependencias
+de gemas. Utiliza un archivo llamado Gemfile en cada proyecto para poder
+organizar sus dependencias, y luego poder agregar dichas dependencias y sus
+dependencias de forma recursiva. Hace esta acción hasta que resuelve y descarga
+todas las dependencias, o se detiene si es que un conflicto aparece.
+
+Bundler eleva un error si encuentra dependencias conflictivas. Por ejemplo, si
+la gema A requiere la versión 3 o mayor de la gema Z, pero la gema B requiere la
+versión 2, Bundler va a notificarte sobre dicho conflicto. Esto es
+extremadamente útil ya que varias gemas hacen referencia a otras gemas (de las
+cuales puede referenciar a otras gemas), lo cual puede formar un gran grafo de
+dependencias para resolver.
+
+# Testing
+
+Testing es una parte grande dentro de la cultura de Ruby. Ruby incluye su propio
+framework de testing llamado minitest (o TestUnit para la versión 1.8.x de
+Ruby). Hay varias librerías de testing con diferentes objetivos.
+
+* [TestUnit](http://ruby-doc.org/stdlib-1.8.7/libdoc/test/unit/rdoc/Test/Unit.html) - Framework de testing de Ruby 1.8
+* [minitest](http://ruby-doc.org/stdlib-2.0.0/libdoc/minitest/rdoc/MiniTest.html) - Framework de testing de Ruby 1.9/2.0
+* [RSpec](http://rspec.info/) - Un framework de testing que se focaliza en expresividad
+* [Cucumber](http://cukes.info/) - Un framework de testing que utiliza BDD, que parsea tests con formato Gherkin
+
+## Se Amable
+
+La comunidad de Ruby se enorgullece de ser una comunidad abierta, diversa y
+acogedora. Matz mismo es extremadamente amigable, y en general la generosidad de
+los rubystas es increíble.
diff --git a/es-es/sass-es.html.markdown b/es-es/sass-es.html.markdown
new file mode 100644
index 00000000..89e56ba5
--- /dev/null
+++ b/es-es/sass-es.html.markdown
@@ -0,0 +1,585 @@
+---
+language: sass
+filename: learnsass.scss
+contributors:
+ - ["Laura Kyle", "https://github.com/LauraNK"]
+ - ["Sean Corrales", "https://github.com/droidenator"]
+ - ["Kyle Mendes", "https://github.com/pink401k"]
+ - ["Keith Miyake", "https://github.com/kaymmm"]
+translators:
+ - ["César Suárez", "https://github.com/csuarez"]
+lang: es-es
+---
+
+Sass es un lenguaje que extiende CSS y que añade características tales como variables, anidación, mixins y más. Sass (y otros preprocesadores tales como [Less](http://lesscess.org/)) ayudan a los desarrolladores a escribir código mantenible y DRY (Don't Repeat Yourself).
+
+Sass tiene dos sintaxis para elegir: SCSS, que usa la misma que CSS pero con las características añadidas de Sass, y Sass (la sintaxis original) que usa identación en vez de llaves y puntos y comas. Este tutorial está escrito en SCSS.
+
+Si ya estás familiarizado con CSS3, vas a entender Sass relativamente rápido. Sass no ofrece nuevas propiedades de estilo, si no que añade herramientas para escribir tus CSS de manera más eficiente, haciendo su mantenimiento mucho más sencillo.
+
+```scss
+
+
+//Los comentarios en una sola línea son eliminados cuando Sass es compilado a CSS.
+
+/* Los comentarios multi-línea se mantienen. */
+
+
+
+/* Variables
+============================== */
+
+
+/* Puedes almacenar valores CSS (como un color) en una variable.
+Usa el símbolo '$' para crear una variable */
+
+$primary-color: #A3A4FF;
+$secondary-color: #51527F;
+$body-font: 'Roboto', sans-serif;
+
+/* Puedes usar las variables a lo largo de tu hoja de estilos.
+Ahora, si quieres cambiar el color, sólo lo tienes que hacer una vez. */
+
+body {
+ background-color: $primary-color;
+ color: $secondary-color;
+ font-family: $body-font;
+}
+
+/* Este código compilará en: */
+body {
+ background-color: #A3A4FF;
+ color: #51527F;
+ font-family: 'Roboto', sans-serif;
+}
+
+/* El resultado es mucho más mantenible que tener que cambiar el color
+cada vez que aparece en la hoja de estilos. */
+
+
+
+/* Directivas de control
+============================== */
+
+
+/* Sass permite usar @if, @else, @for, @while, y @each para controlar la
+ compilación de tu código en CSS. */
+
+/* Los bloques @if/@else se comportan tal como es de esperar */
+
+$debug: true !default;
+
+@mixin debugmode {
+ @if $debug {
+ @debug "Modo debug activado";
+
+ display: inline-block;
+ }
+ @else {
+ display: none;
+ }
+}
+
+.info {
+ @include debugmode;
+}
+
+/* Si $debug es true, .info es mostrado; si es false entonces
+no se muestra.
+
+Nota: @debug mostrará información de depuración en la consola.
+Es muy útil para ver el contenido de tus variables cuando estás depurando. */
+
+.info {
+ display: inline-block;
+}
+
+/* @for es un bucle que itera un conjunto de valores.
+Es particularmente útil para dar estilos a una colección de objetos.
+Hay dos formas "through" y "to". El primero incluye el último valor
+mientras que el segundo para antes del último valor. */
+
+@for $c from 1 to 4 {
+ div:nth-of-type(#{$c}) {
+ left: ($c - 1) * 900 / 3;
+ }
+}
+
+@for $c from 1 through 3 {
+ .myclass-#{$c} {
+ color: rgb($c * 255 / 3, $c * 255 / 3, $c * 255 / 3);
+ }
+}
+
+/* Esto compila en: */
+
+div:nth-of-type(1) {
+ left: 0;
+}
+
+div:nth-of-type(2) {
+ left: 300;
+}
+
+div:nth-of-type(3) {
+ left: 600;
+}
+
+.myclass-1 {
+ color: #555555;
+}
+
+.myclass-2 {
+ color: #aaaaaa;
+}
+
+.myclass-3 {
+ color: white;
+// SASS convierte automáticamente #FFFFFF a white
+}
+
+/* @while es bastante sencillo: */
+
+$columns: 4;
+$column-width: 80px;
+
+@while $columns > 0 {
+ .col-#{$columns} {
+ width: $column-width;
+ left: $column-width * ($columns - 1);
+ }
+
+ $columns: $columns - 1;
+}
+
+/* Esto se convierte en el siguiente CSS: */
+
+.col-4 {
+ width: 80px;
+ left: 240px;
+}
+
+.col-3 {
+ width: 80px;
+ left: 160px;
+}
+
+.col-2 {
+ width: 80px;
+ left: 80px;
+}
+
+.col-1 {
+ width: 80px;
+ left: 0px;
+}
+
+/* @each funciona parecido a @for, pero usa una lista en ver del valor ordinal
+Nota: puedes especificar listas como cualquier otra variable usando espacios
+como delimitadores. */
+
+$social-links: facebook twitter linkedin reddit;
+
+.social-links {
+ @each $sm in $social-links {
+ .icon-#{$sm} {
+ background-image: url("images/#{$sm}.png");
+ }
+ }
+}
+
+/* Esto resultará en: */
+
+.social-links .icon-facebook {
+ background-image: url("images/facebook.png");
+}
+
+.social-links .icon-twitter {
+ background-image: url("images/twitter.png");
+}
+
+.social-links .icon-linkedin {
+ background-image: url("images/linkedin.png");
+}
+
+.social-links .icon-reddit {
+ background-image: url("images/reddit.png");
+}
+
+
+
+/* Mixins
+==============================*/
+
+
+/* Si te encuentras con que estás escribiendo el mismo código en más de un
+elemento, puede que quieras almacenarlo en un mixin.
+
+Usa la directiva '@mixin', más un nombre para tu mixin. */
+
+@mixin center {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+ left: 0;
+ right: 0;
+}
+
+/* Puedes usarlo con '@include' y el nombre del mixin. */
+
+div {
+ @include center;
+ background-color: $primary-color;
+}
+
+/* Esto compilará en: */
+div {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+ left: 0;
+ right: 0;
+ background-color: #A3A4FF;
+}
+
+/* Puedes usar mixins para crear una propiedad shorthand. */
+
+@mixin size($width, $height) {
+ width: $width;
+ height: $height;
+}
+
+/* La que puedes invocar pasándole los argumentos width y height. */
+
+.rectangle {
+ @include size(100px, 60px);
+}
+
+.square {
+ @include size(40px, 40px);
+}
+
+/* Compila en: */
+.rectangle {
+ width: 100px;
+ height: 60px;
+}
+
+.square {
+ width: 40px;
+ height: 40px;
+}
+
+
+
+/* Funciones
+============================== */
+
+
+/* Sass ofrece funciones que pueden ser usadas para realizar una gran variedad
+ de tareas. Por ejemplo: */
+
+/* Se pueden invocar funciones usando su nombre y pasándole los
+ argumentos requeridos. */
+body {
+ width: round(10.25px);
+}
+
+.footer {
+ background-color: fade_out(#000000, 0.25);
+}
+
+/* Compila en: */
+
+body {
+ width: 10px;
+}
+
+.footer {
+ background-color: rgba(0, 0, 0, 0.75);
+}
+
+/* Puedes definir tus propias funciones. Las funciones son muy similares a
+ los mixins. Cuando tengas que elegir entre una función y un mixin, recuerda
+ que los mixins son mejores para generar CSS, mientras que las funciones son
+ mejores para la lógica que puedas necesitar en tu código Sass. Los ejemplos
+ de la sección 'Operadores matemáticos' son candidatos ideales para ser
+ usados como una función reusable. */
+
+/* Esta función toma un tamaño objetivo y el tamaño de un padre y
+ devuelve el porcentaje. */
+
+@function calculate-percentage($target-size, $parent-size) {
+ @return $target-size / $parent-size * 100%;
+}
+
+$main-content: calculate-percentage(600px, 960px);
+
+.main-content {
+ width: $main-content;
+}
+
+.sidebar {
+ width: calculate-percentage(300px, 960px);
+}
+
+/* Compila en: */
+
+.main-content {
+ width: 62.5%;
+}
+
+.sidebar {
+ width: 31.25%;
+}
+
+
+
+/* Extender (Herencia)
+============================== */
+
+
+/* Extend es una manera de compartir propiedades de un selector con otro. */
+
+.display {
+ @include size(5em, 5em);
+ border: 5px solid $secondary-color;
+}
+
+.display-success {
+ @extend .display;
+ border-color: #22df56;
+}
+
+/* Compila en: */
+.display, .display-success {
+ width: 5em;
+ height: 5em;
+ border: 5px solid #51527F;
+}
+
+.display-success {
+ border-color: #22df56;
+}
+
+/* Extender una declaración CSS es preferible a crear un mixin
+ debido a la manera en la que Sass agrupa las clases que comparten
+ los mismos estilos base. Si esto fuese hecho con un mixin, el ancho,
+ alto y el borden aparecerían duplicados para cada una de las declaraciones
+ que usasen el mixin. Esto no afectará a tu workflow, pero infla
+ innecesariamente los ficheros generados por el compilador Sass. */
+
+
+
+/* Anidación
+============================== */
+
+
+/* Sass permite anidar selectores dentro de otros selectores. */
+
+ul {
+ list-style-type: none;
+ margin-top: 2em;
+
+ li {
+ background-color: #FF0000;
+ }
+}
+
+/* '&' será reemplazado por el selector del padre. */
+
+/* También puedes anidar seudo clases. */
+
+/* Ten en cuenta que anidar demasiado hará tu código menos mantenible.
+Como buena práctica, se recomienda no tener más de 3 niveles de anidación.
+Por ejemplo: */
+
+ul {
+ list-style-type: none;
+ margin-top: 2em;
+
+ li {
+ background-color: red;
+
+ &:hover {
+ background-color: blue;
+ }
+
+ a {
+ color: white;
+ }
+ }
+}
+
+/* Compila en: */
+
+ul {
+ list-style-type: none;
+ margin-top: 2em;
+}
+
+ul li {
+ background-color: red;
+}
+
+ul li:hover {
+ background-color: blue;
+}
+
+ul li a {
+ color: white;
+}
+
+
+
+/* Parciales e importaciones
+============================== */
+
+
+/* Sass permite que crees ficheros parciales. Esto te puede ayudar a mantener
+ tu código Sass modularizado. Los ficheros parciales deben comenzar por '_',
+ p.e. _reset.css.
+ Los parciales no son convertidos en CSS. */
+
+/* Mira este al que vamos a añadir un fichero llamado _reset.css */
+
+html,
+body,
+ul,
+ol {
+ margin: 0;
+ padding: 0;
+}
+
+/* Con @import puedes importar parciales a un fichero. Este se diferencia del
+ @import de CSS en que no hace otra petición HTTP para importar el fichero.
+ Sass, sino que combina el código importado en el código compilado. */
+
+@import 'reset';
+
+body {
+ font-size: 16px;
+ font-family: Helvetica, Arial, Sans-serif;
+}
+
+/* Compila en: */
+
+html, body, ul, ol {
+ margin: 0;
+ padding: 0;
+}
+
+body {
+ font-size: 16px;
+ font-family: Helvetica, Arial, Sans-serif;
+}
+
+
+
+/* Placeholders
+============================== */
+
+
+/* Los placeholders son útiles cuando estás creando una declaración CSS a
+ extender. Si quieres crear una declaración que sólo va a ser usada con @extend,
+ puedes hacerlo mediante un placeholder. Los placeholders comienzan con '%'
+ en vez de '.' o '#'. Esto no aparecen en el código CSS compilado. */
+
+%content-window {
+ font-size: 14px;
+ padding: 10px;
+ color: #000;
+ border-radius: 4px;
+}
+
+.message-window {
+ @extend %content-window;
+ background-color: #0000ff;
+}
+
+/* Compila en: */
+
+.message-window {
+ font-size: 14px;
+ padding: 10px;
+ color: #000;
+ border-radius: 4px;
+}
+
+.message-window {
+ background-color: #0000ff;
+}
+
+
+
+/* Operaciones matemáticas
+============================== */
+
+
+/* Sass provee los siguientes operadores: +, -, *, / y %. Estos son útiles
+ para calcular valores directamente en tu código Sass en vez de usar valores
+ calculados a mano. Mira el siguiente ejemplo que prepara un sencillo diseño
+ de dos columnas. */
+
+$content-area: 960px;
+$main-content: 600px;
+$sidebar-content: 300px;
+
+$main-size: $main-content / $content-area * 100%;
+$sidebar-size: $sidebar-content / $content-area * 100%;
+$gutter: 100% - ($main-size + $sidebar-size);
+
+body {
+ width: 100%;
+}
+
+.main-content {
+ width: $main-size;
+}
+
+.sidebar {
+ width: $sidebar-size;
+}
+
+.gutter {
+ width: $gutter;
+}
+
+/* Compila en: */
+
+body {
+ width: 100%;
+}
+
+.main-content {
+ width: 62.5%;
+}
+
+.sidebar {
+ width: 31.25%;
+}
+
+.gutter {
+ width: 6.25%;
+}
+
+```
+
+## ¿SASS o Sass?
+¿Alguna vez has pensado si Sass es un acrónimo o no? Seguramente no, pero te lo vamos a explicar de todas maneras. "Sass" es una palabra, no un acrónimo.
+Como todo el mundo lo escribe como "SASS", el creador del lenguaje lo ha llamado de broma "Syntactically Awesome StyleSheets" (Hojas de estilo sintácticamente increíbles).
+
+
+## Practica Sass
+Si quieres probar Sass en tu navegador, prueba [SassMeister](http://sassmeister.com/).
+Puedes usar cualquier sintaxis, o elegir en la configuración entre Sass y SCSS.
+
+## Compatibilidad
+Sass puede ser usado en cualquier proyecto mientras tengas un programa que lo compile en CSS. Quizás quieras comprobar si el CSS que estás usando es compatible con tus navegadores objetivo.
+
+[QuirksMode CSS](http://www.quirksmode.org/css/) y [CanIUse](http://caniuse.com) son buenos recursos para comprobar la compatibilidad de navegadores.
+
+
+## Más información
+* [Documentación oficial (EN)](http://sass-lang.com/documentation/file.SASS_REFERENCE.html)
+* [The Sass Way (EN)](http://thesassway.com/) tiene tutoriales (para principiantes y avanzandos) and artículos.
diff --git a/es-es/swift-es.html.markdown b/es-es/swift-es.html.markdown
index c04ab02b..8f63517a 100644
--- a/es-es/swift-es.html.markdown
+++ b/es-es/swift-es.html.markdown
@@ -12,7 +12,7 @@ filename: learnswift-es.swift
---
Swift es un lenguaje de programación para el desarrollo en iOS y OS X creado
-por Apple. Diseñado para coexistir con Objective-C y ser más resistente contra
+por Apple. Diseñado para coexistir con Objective-C y ser más resistente contra
el código erroneo, Swift fue introducido en el 2014 en el WWDC, la conferencia
de desarrolladores de Apple.
@@ -27,13 +27,13 @@ import UIKit
// MARK: Básicos
//
-// XCode soporta referencias para anotar tu código y agregarlos a lista de la
+// XCode soporta referencias para anotar tu código y agregarlos a lista de la
// barra de saltos.
// MARK: Marca de sección
// TODO: Hacer algo pronto
// FIXME: Arreglar este código
-// En Swift 2, println y print fueron combinados en un solo método print.
+// En Swift 2, println y print fueron combinados en un solo método print.
// Print añade una nueva línea automáticamente.
print("Hola, mundo") // println ahora es print
print("Hola, mundo", appendNewLine: false) // print sin agregar nueva línea
@@ -46,18 +46,18 @@ let øπΩ = "value" // nombres de variable unicode
let π = 3.1415926
let convenience = "keyword" // nombre de variable contextual
// Las declaraciones pueden ser separadas por punto y coma (;)
-let weak = "keyword"; let override = "another keyword"
-// Los acentos abiertos (``) permiten utilizar palabras clave como nombres de
+let weak = "keyword"; let override = "another keyword"
+// Los acentos abiertos (``) permiten utilizar palabras clave como nombres de
// variable
-let `class` = "keyword"
+let `class` = "keyword"
let explicitDouble: Double = 70
let intValue = 0007 // 7
let largeIntValue = 77_000 // 77000
let label = "some text " + String(myVariable) // Conversión (casting)
-let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Interpolación de string
+let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Interpolación de string
// Valores específicos de la compilación (build)
-// utiliza la configuración -D
+// utiliza la configuración -D
#if false
print("No impreso")
let buildValue = 3
@@ -67,13 +67,13 @@ let piText = "Pi = \(π), Pi 2 = \(π * 2)" // Interpolación de string
print("Build value: \(buildValue)") // Build value: 7
/*
- Las opcionales son un aspecto del lenguaje Swift que permite el
+ Las opcionales son un aspecto del lenguaje Swift que permite el
almacenamiento de un valor `Some` (algo) o `None` (nada).
-
- Debido a que Swift requiere que cada propiedad tenga un valor,
- hasta un valor 'nil' debe de ser explicitamente almacenado como un
+
+ Debido a que Swift requiere que cada propiedad tenga un valor,
+ hasta un valor 'nil' debe de ser explicitamente almacenado como un
valor opcional.
-
+
Optional<T> es un enum.
*/
var someOptionalString: String? = "opcional" // Puede ser nil
@@ -85,7 +85,7 @@ if someOptionalString != nil {
if someOptionalString!.hasPrefix("opt") {
print("Tiene el prefijo")
}
-
+
let empty = someOptionalString?.isEmpty
}
someOptionalString = nil
@@ -104,14 +104,14 @@ if let someOptionalStringConstant = someOptionalString {
// Swift tiene soporte de almacenamiento para cualquier tipo de valor.
// AnyObject == id
-// A diferencia de Objective-C `id`, AnyObject funciona con cualquier
+// A diferencia de Objective-C `id`, AnyObject funciona con cualquier
// valor (Class, Int, struct, etc)
var anyObjectVar: AnyObject = 7
anyObjectVar = "Cambiado a un valor string, no es buena práctica, pero posible."
/*
Comentar aquí
-
+
/*
Comentarios anidados también son soportados
*/
@@ -122,8 +122,8 @@ anyObjectVar = "Cambiado a un valor string, no es buena práctica, pero posible.
//
/*
- Tipos Array (arreglo) y Dictionary (diccionario) son structs (estructuras).
- Así que `let` y `var` también indican si son mudables (var) o
+ Tipos Array (arreglo) y Dictionary (diccionario) son structs (estructuras).
+ Así que `let` y `var` también indican si son mudables (var) o
inmutables (let) durante la declaración de sus tipos.
*/
@@ -173,7 +173,7 @@ for i in -1...shoppingList.count {
shoppingList[1...2] = ["steak", "peacons"]
// Utilizar ..< para excluir el último valor
-// Ciclo while
+// Ciclo while
var i = 1
while i < 1000 {
i *= 2
@@ -224,7 +224,7 @@ func greet(name: String, day: String) -> String {
}
greet("Bob", "Martes")
-// Similar a lo anterior, a excepción del compartamiento de los parámetros
+// Similar a lo anterior, a excepción del compartamiento de los parámetros
// de la función
func greet2(requiredName: String, externalParamName localParamName: String) -> String {
return "Hola \(requiredName), hoy es el día \(localParamName)"
@@ -312,7 +312,7 @@ print(numbers) // [3, 6, 18]
// Las estructuras y las clases tienen capacidades similares
struct NamesTable {
let names = [String]()
-
+
// Subscript personalizado
subscript(index: Int) -> String {
return names[index]
@@ -343,7 +343,7 @@ public class Shape {
internal class Rect: Shape {
var sideLength: Int = 1
-
+
// Getter y setter personalizado
private var perimeter: Int {
get {
@@ -354,13 +354,13 @@ internal class Rect: Shape {
sideLength = newValue / 4
}
}
-
- // Lazily loading (inicialización bajo demanda) a una propiedad
+
+ // Lazily loading (inicialización bajo demanda) a una propiedad
// subShape queda como nil (sin inicializar) hasta que getter es llamado
lazy var subShape = Rect(sideLength: 4)
-
+
// Si no necesitas un getter y setter personalizado
- // pero aún quieres ejecutar código antes y después de hacer get o set
+ // pero aún quieres ejecutar código antes y después de hacer get o set
// a una propiedad, puedes utilizar `willSet` y `didSet`
var identifier: String = "defaultID" {
// El argumento `willSet` será el nombre de variable para el nuevo valor
@@ -368,20 +368,20 @@ internal class Rect: Shape {
print(someIdentifier)
}
}
-
+
init(sideLength: Int) {
self.sideLength = sideLength
- // Siempre poner super.init de último al momento de inicializar propiedades
+ // Siempre poner super.init de último al momento de inicializar propiedades
// personalizadas
super.init()
}
-
+
func shrink() {
if sideLength > 0 {
- --sideLength
+ sideLength -= 1
}
}
-
+
override func getArea() -> Int {
return sideLength * sideLength
}
@@ -413,13 +413,13 @@ class Circle: Shape {
override func getArea() -> Int {
return 3 * radius * radius
}
-
+
// Un signo de interrogación como sufijo después de `init` es un init opcional
// que puede devolver nil
init?(radius: Int) {
self.radius = radius
super.init()
-
+
if radius <= 0 {
return nil
}
@@ -457,11 +457,11 @@ enum Suit {
}
}
-// Los valores de enum permite la sintaxis corta, sin necesidad de poner
+// Los valores de enum permite la sintaxis corta, sin necesidad de poner
// el tipo del enum cuando la variable es declarada de manera explícita
var suitValue: Suit = .Hearts
-// Enums de tipo no-entero requiere asignaciones de valores crudas directas
+// Enums de tipo no-entero requiere asignaciones de valores crudas directas
enum BookName: String {
case John = "John"
case Luke = "Luke"
@@ -474,7 +474,7 @@ enum Furniture {
case Desk(height: Int)
// Asociación con String e Int
case Chair(String, Int)
-
+
func description() -> String {
switch self {
case .Desk(let height):
@@ -496,7 +496,7 @@ print(chair.description()) // "Chair of Foo with 40 cm"
//
// `protocol` puede requerir que los tipos tengan propiedades
-// de instancia específicas, métodos de instancia, métodos de tipo,
+// de instancia específicas, métodos de instancia, métodos de tipo,
// operadores, y subscripts
@@ -514,13 +514,13 @@ protocol ShapeGenerator {
class MyShape: Rect {
var delegate: TransformShape?
-
+
func grow() {
sideLength += 2
- // Pon un signo de interrogación después de la propiedad opcional,
- // método, o subscript para ignorar un valor nil y devolver nil
- // en lugar de tirar un error de tiempo de ejecución
+ // Pon un signo de interrogación después de la propiedad opcional,
+ // método, o subscript para ignorar un valor nil y devolver nil
+ // en lugar de tirar un error de tiempo de ejecución
// ("optional chaining")
if let allow = self.delegate?.canReshape?() {
// test for delegate then for method
@@ -536,7 +536,7 @@ class MyShape: Rect {
// `extension`: Agrega funcionalidades a tipos existentes
-// Square ahora se "conforma" al protocolo `Printable`
+// Square ahora se "conforma" al protocolo `Printable`
extension Square: Printable {
var description: String {
return "Area: \(self.getArea()) - ID: \(self.identifier)"
@@ -550,7 +550,7 @@ extension Int {
var customProperty: String {
return "This is \(self)"
}
-
+
func multiplyBy(num: Int) -> Int {
return num * self
}
@@ -589,7 +589,7 @@ prefix func !!! (inout shape: Square) -> Square {
// Valor actual
print(mySquare.sideLength) // 4
-// Cambiar la longitud del lado utilizando el operador !!!,
+// Cambiar la longitud del lado utilizando el operador !!!,
// incrementa el tamaño por 3
!!!mySquare
print(mySquare.sideLength) // 12
diff --git a/es-es/tmux.html.markdown b/es-es/tmux.html.markdown
new file mode 100644
index 00000000..aaa4cb59
--- /dev/null
+++ b/es-es/tmux.html.markdown
@@ -0,0 +1,242 @@
+---
+category: tool
+tool: tmux
+contributors:
+ - ["mdln", "https://github.com/mdln"]
+translators:
+ - ["Ferran Pelayo", "https://github.com/ferranpm"]
+filename: LearnTmux-es.txt
+lang: es-es
+---
+
+[tmux](http://tmux.sourceforge.net) permite crear, controlar y acceder a
+multiples terminales desde una sola ventana. Puede desconectarse una sesión de
+la ventana, seguir corriendo en segundo plano y volver a conectar otra ventana
+más tarde.
+
+
+```
+
+ tmux [command] # Correr un comando de tmux
+ # 'tmux' sin comando crea una nueva sesión.
+
+ new # Crear una nueva sesión
+ -s "Session" # Crear una sesión con nombre
+ -n "Window" # Crear una ventana con nombre
+ -c "/dir" # Empezar en el directorio "/dir"
+
+ attach # Atar la ventana a la ultima sesión iniciada
+ -t "#" # Atar la ventana a la sesión "#"
+ -d # Desatar la ventana de la sesión
+
+ ls # Listar las sesiones abiertas
+ -a # Listar todas las sesiones abiertas
+
+ lsw # Listar ventanas
+ -a # Listar todas las ventanas
+ -s # Listar todas las ventanas de la sesión
+
+ lsp # Listar paneles
+ -a # Listar todos los paneles
+ -s # Listar todos los paneles de la sesión
+ -t # Listar paneles de la aplicación en el target
+
+ kill-window # Eliminar la ventana actual
+ -t "#" # Eliminar la ventana "#"
+ -a # Eliminar todas las ventanas
+ -a -t "#" # Eliminar todas las ventanas menos la "#"
+
+ kill-session # Eliminar la sesión actual
+ -t "#" # Eliminar la sesión "#"
+ -a # Eliminar todas las sessiones
+ -a -t "#" # Eliminar todas las sessiones menos la "#"
+
+```
+
+
+### Atajos de teclado
+
+Para controlar una sesión atada se usa la combinación llamada 'Prefijo' + atajo.
+
+```
+----------------------------------------------------------------------
+ (C-b) = Ctrl + b # 'Prefijo' por defecto requerido para usar los atajos
+
+ (M-1) = Meta + 1 -o- Alt + 1
+----------------------------------------------------------------------
+
+ ? # Listar todos los atajos de teclado
+ : # Insertar un comando de tmux
+ r # Forzar refresco gráfico del cliente
+ c # Crear una nueva ventana
+
+ ! # Quitar el panel actual de la ventana
+ % # Dividir el panel actual en dos (derecha e izquierda)
+ " # Dividir el panel actual en dos (arriba y abajo)
+
+ n # Cambiar a la siguiente ventana
+ p # Cambiar a la ventana anterior
+ { # Cambiar el panel por el panel anterior
+ } # Cambiar el panel por el siguiente panel
+
+ s # Seleccionar y atar el cliente a una sesión distinta
+ de forma interactiva
+ w # Seleccionar una ventana de forma interactiva
+ 0 to 9 # Seleccionar una ventana (del 0 al 9)
+
+ d # Desatar el cliente actual de la sesión
+ D # Escojer un cliente a desatar
+
+ & # Eliminar la ventana actual
+ x # Eliminar el panel actual
+
+ Up, Down # Cambiar al panel de arriba, debajo, izquierda o derecha
+ Left, Right
+
+ M-1 to M-5 # Ordenar los paneles
+
+ C-Up, C-Down # Dimensionar el panel actual en pasos de una celda
+ C-Left, C-Right
+
+ M-Up, M-Down # Dimensionar el panel actual en pasos de cinco celdas
+ M-Left, M-Right
+
+```
+
+
+### Configurar ~/.tmux.conf
+
+El fichero tmux.conf se puede configurar para establecer unas opciones por
+defecto, igual que .vimrc o init.el para vim o emacs.
+
+```
+# Ejemplo tmux.conf
+# 2014.10
+
+
+### General
+###########################################################################
+
+# Activar UTF-8
+setw -g utf8 on
+set-option -g status-utf8 on
+
+# Limite del historico de comandos
+set -g history-limit 2048
+
+# Index Start
+set -g base-index 1
+
+# Ratón
+set-option -g mouse-select-pane on
+
+# Forzar volver a cargar el fichero de configuración
+unbind r
+bind r source-file ~/.tmux.conf
+
+
+### Atajos de teclado
+###########################################################################
+
+# Quitar C-b como prefijo por defecto
+unbind C-b
+
+# Establecer ` como nuevo prefijo
+set-option -g prefix `
+
+# Volver a la ventana anterior cuando el prefijo se pulsa dos veces
+bind C-a last-window
+bind ` last-window
+
+# Intercambiar entre C-a y ` como prefijo pulsando F11/F12
+bind F11 set-option -g prefix C-a
+bind F12 set-option -g prefix `
+
+# Preferencias de los atajos
+setw -g mode-keys vi
+set-option -g status-keys vi
+
+# Mover entre paneles con atajos de vim
+bind h select-pane -L
+bind j select-pane -D
+bind k select-pane -U
+bind l select-pane -R
+
+# Cambiar/Saltar de ventana
+bind e previous-window
+bind f next-window
+bind E swap-window -t -1
+bind F swap-window -t +1
+
+# Divisiones de paneles
+bind = split-window -h
+bind - split-window -v
+unbind '"'
+unbind %
+
+### Tema de colores
+###########################################################################
+
+# Barra de estado
+set-option -g status-justify left
+set-option -g status-bg black
+set-option -g status-fg white
+set-option -g status-left-length 40
+set-option -g status-right-length 80
+
+# Bordes de paneles
+set-option -g pane-active-border-fg green
+set-option -g pane-active-border-bg black
+set-option -g pane-border-fg white
+set-option -g pane-border-bg black
+
+# Color de los mensajes
+set-option -g message-fg black
+set-option -g message-bg green
+
+# Colores del estado de las ventanas
+setw -g window-status-bg black
+setw -g window-status-current-fg green
+setw -g window-status-bell-attr default
+setw -g window-status-bell-fg red
+setw -g window-status-content-attr default
+setw -g window-status-content-fg yellow
+setw -g window-status-activity-attr default
+setw -g window-status-activity-fg yellow
+
+
+### UI
+###########################################################################
+
+# Notificaciones
+setw -g monitor-activity on
+set -g visual-activity on
+set-option -g bell-action any
+set-option -g visual-bell off
+
+# Titulos de las ventanas
+set-option -g set-titles on
+set-option -g set-titles-string '#H:#S.#I.#P #W #T' # window number,program name,active (or not)
+
+# Formato de la barra de estado
+set -g status-left "#[fg=red] #H#[fg=green]:#[fg=white]#S#[fg=green] |#[default]"
+
+# Mostrar estadisticas de rendimiento en la barra de estado
+# Requiere https://github.com/thewtex/tmux-mem-cpu-load/
+set -g status-interval 4
+set -g status-right "#[fg=green] | #[fg=white]#(tmux-mem-cpu-load)#[fg=green] | #[fg=cyan]%H:%M #[default]"
+
+```
+
+
+### Referencias
+
+[Tmux | Home](http://tmux.sourceforge.net)
+
+[Tmux Manual page](http://www.openbsd.org/cgi-bin/man.cgi/OpenBSD-current/man1/tmux.1?query=tmux)
+
+[Gentoo Wiki](http://wiki.gentoo.org/wiki/Tmux)
+
+[Archlinux Wiki](https://wiki.archlinux.org/index.php/Tmux)
+
+[Display CPU/MEM % in statusbar](https://stackoverflow.com/questions/11558907/is-there-a-better-way-to-display-cpu-usage-in-tmux)
diff --git a/es-es/vim-es.html.markdown b/es-es/vim-es.html.markdown
new file mode 100644
index 00000000..df97aa3d
--- /dev/null
+++ b/es-es/vim-es.html.markdown
@@ -0,0 +1,242 @@
+---
+category: tool
+tool: vim
+contributors:
+ - ["RadhikaG", "https://github.com/RadhikaG"]
+translators:
+ - ["Ivan Alburquerque", "https://github.com/AlburIvan"]
+lang: es-es
+filename: LearnVim-es.txt
+---
+
+
+[Vim](http://www.vim.org)
+(Vi IMproved) es un clón del popular editor vi para UNIX. Es un editor de texto
+diseñado para ser veloz e incrementar la productividad, es ubicuo en la mayoría
+de los sistemas basados en UNIX. Cuenta con numerosas combinaciones de teclas
+para la navegación rápida a puntos especificos en un archivo y para rápida edición.
+
+
+
+## Fundamentos de la navegación en Vim
+
+```
+ vim <archivo> # Abre <archivo> en vim
+ :q # Salir de vim
+ :w # Guardar archivo actual
+ :wq # Guardar archivo y salir de vim
+ :q! # Salir de vim sin guardar el archivo
+ # ! *forza* :q a ejecutarse, por lo tanto sale de vim sin guardar
+ :x # Guardar el archivo y salir de vim, versión corta de :wq
+
+ u # Deshacer
+ CTRL+R # Rehacer
+
+ h # Desplazarse un carácter hacía la izquierda
+ j # Desplazarse una línea hacía abajo
+ k # Desplazarse una línea hacía arriba
+ l # Desplazarse un carácter hacía la derecha
+
+ # Desplazarse dentro de la línea
+
+ 0 # Desplazarse hacia el inicio de la línea
+ $ # Desplazarse al final de la línea
+ ^ # Desplazarse al primer carácter no blanco en la línea
+
+ # Buscando en el texto
+
+ /word # Resalta todas las ocurrencias de la palabra después del cursor
+ ?word # Resalta todas las ocurrencias de la palabra antes del cursor
+ n # Desplaza el cursor a la siguiente ocurrencia de la palabra después de una búsqueda
+ N # Desplaza el cursor a la anterior ocurrencia de la palabra
+
+ :%s/foo/bar/g # Cambia 'foo' a 'bar' en cada línea en el archivo
+ :s/foo/bar/g # Cambia 'foo' a 'bar' en la línea actual
+
+ # Saltando caracteres
+
+ f<carácter> # Salta adelante y aterriza en <carácter>
+ t<carácter> # Salta adelante y aterriza antes de <carácter>
+
+ # Por ejemplo,
+ f< # Salta adelante y aterriza en <
+ t< # Salta adelante y aterriza justo antes de <
+
+ # Desplazarse por palabras
+
+ w # Desplazarse hacia adelante por una palabra
+ b # Desplazarse hacia atrás por una palabra
+ e # Desplazarse al final de la palabra actual
+
+ # Otros caracteres para desplazarse
+
+ gg # Ir al principio del archivo
+ G # Ir al final del archivo
+ :NUM # Ir a la línea número NUM (NUM es cualquier número)
+ H # Desplazarse al principio de la pantalla
+ M # Desplazarse a la mitad de la pantalla
+ L # Desplazarse al final de la pantalla
+```
+
+## Modos:
+
+Vim se basa en el concepto de **modos**.
+
+
+Modo Comando - Vim se pone en marcha en éste modo, se usa para navegar y escribir comandos
+Modo Inserción - Utilizado para realizar cambios en el archivo
+Modo Visual - Utilizado para resaltar texto y operar en ellos
+Modo Ex - Utilizado para ir hacia la parte inferior con ':' para introducir comandos
+
+
+```
+ i # Pone a Vim en modo de inserción, antes de la posición del cursor
+ a # Pone a Vim en modo de inserción, después de la posición del cursor
+ v # Pone a Vim en modo de visual
+ : # Pone a Vim en modo Ex
+ <esc> # Sale de cualquier modo en que se encuentre, al modo comando
+
+ # Copiando y pegando texto
+
+ y # Copia lo que se encuentre seleccionado
+ yy # Copia la linea actual
+ d # Elimina lo que se encuentre seleccionado
+ dd # Elimina la linea actual
+ p # Pega el texto copiado después de la posición del cursor
+ P # Pega el texto copiado antes de la posición del cursor
+ x # Elimina el carácter debajo de la posición del cursor
+```
+
+## La "Gramática" de vim
+
+Vim puede ser pensado como un conjunto de comandos en un
+formato "verbo-sustantivo-modificador ', donde:
+
+Verbo - La acción a realizar
+Modificador - Como vas hacer la acción
+Sustantivo - el objeto al que se le va a aplicar la acción
+
+Algunos ejemplos importantes de "Verbos", "Modificadores" y "Sustantivos":
+
+```
+ # 'Verbos'
+
+ d # Eliminar
+ c # Cambiar
+ y # Copiar
+ v # Seleccionar visualmente
+
+ # 'Modificadores'
+
+ i # Dentro
+ a # Alrededor
+ NUM # Número (NUM es cualquier número)
+ f # Busca algo y aterriza sobre el
+ t # Busca algo y se detiene antes de
+ / # Encuentra una cadena desde el cursor en adelante
+ ? # Encuentra una cadena antes del cursor
+
+ # 'Sustantivos'
+
+ w # Palabra
+ s # Oración
+ p # Párrafo
+ b # Bloque
+
+ # "Frases" de ejemplo o comandos
+
+ d2w # Elimina 2 palabras
+ cis # Cambia dentro de una oración
+ yip # Copia dentro de un párrafo (copia el párrafo donde estás)
+ ct< # Cambia para abrir un paréntesis
+ # Cambie el texto desde donde está a la siguiente paréntesis abierto
+ d$ # Eliminar hasta el final de la línea
+```
+
+## Algunos accesos directos y trucos
+
+```
+ > # Sangrar la selección por un bloque
+ < # Desangrar la selección por un bloque
+ :earlier 15m # Devuelve el documento de nuevo a como era hace 15 minutos
+ :later 15m # Deshace el comando anterior
+ ddp # Intercambia la posición de las lineas consecutivas, dd después p
+ . # Repite la acción previa
+```
+
+## Macros
+
+Las macros son, básicamente, las acciones que se pueden grabar.
+Cuando comienzas a grabar un macro, registra **todas** las acciones y comandos
+que se utilizan hasta que detenga la grabación. En la invocación de un macro,
+se aplica exactamente la misma secuencia de acciones y comandos de nuevo
+en la selección de texto.
+
+```
+ qa # Comienza a grabar un macro llamada 'a'
+ q # Detiene la grabación
+ @a # Comienza la reproducción del macro
+```
+
+### Configurando ~/.vimrc
+
+El archivo .vimrc puede ser usado para configurar Vim en el arranque.
+
+Aquí está un ejemplo de un archivo ~ / .vimrc:
+
+```
+" Ejemplo ~/.vimrc
+" 2015.10
+
+" Se requiere para que vim sea 'mejor'
+set nocompatible
+
+" Determina la extensión del archivo por el nombre para permitir el auto-indentado inteligente, etc...
+filetype indent plugin on
+
+" Habilita el resaltado de sintaxis
+syntax on
+
+" Mejor terminación de línea de comandos
+set wildmenu
+
+" Usa búsqueda sensible a mayúsculas excepto cuando se utilizan letras mayúsculas
+set ignorecase
+set smartcase
+
+" Al abrir una nueva línea, si la sangría especifica del archivo no está habilitada,
+" mantén la misma sangría que la línea que estás actualmente
+set autoindent
+
+" Despliega el número de línea a la izquierda
+set number
+
+" Opciones de sangría, cambialas de acuerdo a tus preferencias personales
+
+" Número de espacios visuales por tabulación
+set tabstop=4
+
+" Número de espacios de las tabulaciones al editar
+set softtabstop=4
+
+" Número de espacios sangrados cuando las operaciones de resangrado (>> y <<) son usadas
+set shiftwidth=4
+
+" Convertir tabulaciones en espacios
+set expandtab
+
+" Habilitar la tabulación inteligente y el espaciamiento para el sangrado y la alineación
+set smarttab
+```
+
+### Referencias
+
+[Vim | Home (EN)](http://www.vim.org/index.php)
+
+`$ vimtutor` Command
+
+[A vim Tutorial and Primer (EN)](https://danielmiessler.com/study/vim/)
+
+[What are the dark corners of Vim your mom never told you about? (Stack Overflow thread) (EN)](http://stackoverflow.com/questions/726894/what-are-the-dark-corners-of-vim-your-mom-never-told-you-about)
+
+[Arch Linux Wiki (EN)](https://wiki.archlinux.org/index.php/Vim) \ No newline at end of file