8 files changed, 1186 insertions, 9 deletions
diff --git a/es-es/asymptotic-notation-es.html.markdown b/es-es/asymptotic-notation-es.html.markdown
new file mode 100644
index 00000000..f3fe1614
--- /dev/null
+++ b/es-es/asymptotic-notation-es.html.markdown
@@ -0,0 +1,170 @@
+---
+category: Algorithms & Data Structures
+name: Asymptotic Notation
+contributors:
+    - ["Jake Prather", "http://github.com/JakeHP"]
+translators:
+    - ["Gerson Lázaro", "https://gersonlazaro.com"]
+lang: es-es
+---
+
+# Notaciones asintóticas
+
+## ¿Qué son?
+
+Las notaciones asintóticas son lenguajes que nos permitan analizar el tiempo de 
+ejecución de un algoritmo identificando su comportamiento si el tamaño de 
+entrada para el algoritmo aumenta. Esto también se conoce como la tasa de 
+crecimiento de un algoritmo. ¿El algoritmo de repente se vuelve increíblemente 
+lento cuando el tamaño de entrada crece? ¿Tiende a mantener un rápido tiempo de 
+ejecución a medida que el tamaño de entrada aumenta? La notación asintótica nos 
+da la capacidad para responder a estas preguntas.
+
+## ¿Hay alternativas que respondan a estas preguntas?
+
+Una manera sería contar el número de operaciones primitivas en diferentes 
+tamaños de entrada. Aunque esta es una solución válida, la cantidad de trabajo 
+que esto conlleva, incluso para los algoritmos simples, no justifica su uso.
+
+Otra manera es medir físicamente la cantidad de tiempo que un algoritmo toma 
+para completar su ejecución dados diferentes tamaños de entrada. Sin embargo, 
+la exactitud y la relatividad (los tiempos obtenidos sólo serían relativos a la 
+máquina sobre la cual se calcularon) de este método está ligado a variables 
+ambientales tales como especificaciones de hardware, capacidad de procesamiento,
+etc.
+
+## Tipos de Notación Asintótica
+
+En la primera sección de este documento hemos descrito cómo una notación 
+asintótica identifica el comportamiento de un algoritmo ante los cambios en el 
+tamaño de la entrada. Imaginemos un algoritmo como una función f, con tamaño de 
+entrada n, y f(n) siendo el tiempo de ejecución. Así que para un algoritmo f 
+dado, con el tamaño de entrada n obtenemos algún tiempo de ejecución resultante 
+f(n). Esto resulta en un gráfico donde el eje Y es el tiempo de ejecución, el 
+eje X es el tamaño de la entrada y los puntos en el gráfico son los resultantes 
+de la cantidad de tiempo para un tamaño de entrada dado.
+
+Puedes etiquetar una función, o un algoritmo, con una notación asintótica de 
+muchas maneras diferentes. Algunos ejemplos son describir un algoritmo por su 
+mejor caso, su peor caso, o el caso promedio. Lo más común es analizar un 
+algoritmo por su peor caso. Por lo general, no se evalúa el mejor caso, porque 
+no planeas el algoritmo para estas condiciones. Un muy buen ejemplo de esto son
+los algoritmos de ordenamiento; específicamente, añadir elementos a un árbol. 
+El mejor caso para la mayoría de los algoritmos podría ser tan bajo como una 
+sola operación. Sin embargo, en la mayoría de los casos, el elemento que está 
+añadiendo tendrá que ser ordenado adecuadamente a través del árbol, lo que 
+podría significar examinar toda una rama. Este es el peor de los casos, y 
+para estos casos es que planeamos el algoritmo.
+
+
+### Tipos de funciones, límites, y simplificación
+
+```
+Función logarítmica - log n
+Función lineal - an + b
+Función cuadrática - an^2 + bn + c
+Función polinomicas - an^z + . . . + an^2 + a*n^1 + a*n^0, donde z es constante
+Función exponencial - a^n, donde a es constante
+```
+
+Estas son algunas clasificaciones de funciones de crecimiento básicos utilizados
+en varias notaciones. La lista comienza en la función de crecimiento menor
+(logarítmica, el tiempo de ejecución mas rápido) y pasa a la de mayor 
+crecimiento  (exponencial, el tiempo de ejecución mas lento). Observe como al 
+crecer 'n', o la entrada, en cada una de estas funciones, el resultado aumenta 
+claramente mucho más rápido en las cuadráticas, polinómicas y exponenciales, 
+en comparación con las logarítmicas y lineales.
+
+Una anotación muy importante es que en las notaciones que se discutirán debes 
+hacer tu mejor esfuerzo por utilizar los términos más simples. Esto significa 
+hacer caso omiso de las constantes y terminos de orden inferior, porque a medida
+que el tamaño de entrada (o n en f(n)) aumenta hacia el infinito (límites 
+matemáticos), los términos y constantes de orden inferior se vuelven de poca o 
+ninguna importancia. Dicho esto, si tienes constantes que son 2^9001, 
+o alguna otra cantidad ridícula, inimaginable, te daras cuenta de que la 
+simplificación sesgará la exactitud de la notación.
+
+Como queremos algo simplificado, vamos a modificarlo un poco...
+
+```
+Logarítmico - log n
+Lineal - n
+Cuandrático - n^2
+Polinómico - n^z, donde z es constante
+Exponencial - a^n, donde a es constante
+```
+
+### O-grande (Big-O)
+O-grande (Big-O), comúnmente escrito como O, es una notación asintótica para el 
+peor caso, o el techo de crecimiento para una función determinada. Si `f (n)` 
+es el tiempo de ejecución del algoritmo, y `g (n)` es un tiempo de complejidad 
+arbitraria que relacionas con el algoritmo, entonces `f (n)` es O(g(n)), si por 
+cualquier constante real c (c > 0), `f (n)` <= `c g(n)` para cada tamaño de 
+entrada n (n > 0 ).
+
+
+*Ejemplo 1*  
+
+```
+f(n) = 3log n + 100  
+g(n) = log n
+```
+
+`f(n)` es O(g(n))?  
+`3 log n + 100` es O(log n)?  
+Echemos un vistazo a la definición de O-grande.
+
+```
+3log n + 100 <= c * log n  
+```
+¿Hay alguna constante c que satisface esto para todo n? 
+
+```
+3log n + 100 <= 150 * log n, n > 2 (indefinido en n = 1)  
+```
+
+¡Sí! La definición de O-grande se cumple, por lo tanto `f (n)` es O(g(n)).
+
+*Ejemplo 2*  
+
+```
+f(n) = 3*n^2  
+g(n) = n
+```
+
+`f(n)` es O(g(n))?  
+`3 * n^2` es O(n)?  
+Echemos un vistazo a la definición de O-grande.
+
+```
+3 * n^2 <= c * n  
+```
+
+¿Hay alguna constante c que satisface esto para todo n? 
+No, no la hay. `f(n)` no es O(g(n)).
+
+### Big-Omega
+Big-Omega, comunmente escrito como Ω, es una notación asintótica para el mejor
+caso, o el piso en el crecimiento para una función dada.
+
+`f(n)` es Ω(g(n)), si para cualquier constante real c (c > 0), 
+`f(n)` es >= `c g(n)` para cualquier tamaño de entrada n (n > 0).
+
+No dudes en dirigirte a los recursos adicionales para ejemplos sobre esto. 
+O-grande es la notación principal utilizada para la complejidad general de
+tiempo algoritmico.
+
+### Notas finales
+Es difícil mantener este tipo de tema corto, y sin duda deberias revisar los 
+libros y recursos en línea en la lista. Entran en mucha mayor profundidad con 
+definiciones y ejemplos. 
+
+## Libros
+
+* [Algoritmos (Algorithms)](http://www.amazon.com/Algorithms-4th-Robert-Sedgewick/dp/032157351X)
+* [Diseño de algoritmos (Algorithm Design)](http://www.amazon.com/Algorithm-Design-Foundations-Analysis-Internet/dp/0471383651)
+
+## Recursos Online
+
+* [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)
diff --git a/es-es/c++-es.html.markdown b/es-es/c++-es.html.markdown
index bcc775e5..07c8bc03 100644
--- a/es-es/c++-es.html.markdown
+++ b/es-es/c++-es.html.markdown
@@ -1,6 +1,6 @@
 ---
 language: c++
-filename: learncpp.cpp
+filename: learncpp-es.cpp
 contributors:
     - ["Steven Basart", "http://github.com/xksteven"]
     - ["Matt Kline", "https://github.com/mrkline"]
diff --git a/es-es/forth-es.html.markdown b/es-es/forth-es.html.markdown
index 05dc0cc5..edc5d38c 100644
--- a/es-es/forth-es.html.markdown
+++ b/es-es/forth-es.html.markdown
@@ -1,4 +1,4 @@
----
+---
 language: forth
 contributors:
     - ["Horse M.D.", "http://github.com/HorseMD/"]
diff --git a/es-es/groovy-es.html.markdown b/es-es/groovy-es.html.markdown
new file mode 100644
index 00000000..799fc609
--- /dev/null
+++ b/es-es/groovy-es.html.markdown
@@ -0,0 +1,434 @@
+---
+language: Groovy
+contributors:
+    - ["Roberto Pérez Alcolea", "http://github.com/rpalcolea"]
+translators:
+    - ["Jhoon Saravia", "https://github.com/jhoon"]
+lang: es-es
+filename: groovy-es.html
+---
+
+Groovy - Un lenguaje dinámico para la plataforma Java [Leer más aquí.](http://www.groovy-lang.org/)
+
+```groovy
+
+/*
+  Hora de configurar:
+
+  1) Instala GVM - http://gvmtool.net/
+  2) Instala Groovy: gvm install groovy
+  3) Inicia la consola de groovy escribiendo: groovyConsole
+
+*/
+
+//  Los comentarios de una sola línea inician con dos barras inclinadas
+/*
+Los comentarios multilínea se ven así.
+*/
+
+// Hola Mundo
+println "Hola mundo!"
+
+/*
+  Variables:
+
+  Puedes asignar valores a variables para usarlas después
+*/
+
+def x = 1
+println x
+
+x = new java.util.Date()
+println x
+
+x = -3.1499392
+println x
+
+x = false
+println x
+
+x = "Groovy!"
+println x
+
+/*
+  Mapas y Colecciones
+*/
+
+// Creando una lista vacía
+def technologies = []
+
+/*** Agregando elementos a la lista ***/
+
+// Como si fuera Java
+technologies.add("Grails")
+
+// Doble símbolo de menor agrega un elemento y, además, retorna la lista
+technologies << "Groovy"
+
+// Agregando múltiples elementos
+technologies.addAll(["Gradle","Griffon"])
+
+/*** Quitando elementos de la lista ***/
+
+// Como si fuera Java
+technologies.remove("Griffon")
+
+// La resta también funciona
+technologies = technologies - 'Grails'
+
+/*** Iterando Listas ***/
+
+// Para iterar sobre los elementos de una Lista
+technologies.each { println "Technology: $it"}
+technologies.eachWithIndex { it, i -> println "$i: $it"}
+
+/*** Revisando los contenidos de una Lista ***/
+
+// Evaluar si la lista contiene elemento(s) (boolean)
+contained = technologies.contains( 'Groovy' )
+
+// O
+contained = 'Groovy' in technologies
+
+// Evaluar por múltiples contenidos
+technologies.containsAll(['Groovy','Grails'])
+
+/*** Ordenando Listas ***/
+
+// Para ordenar una Lista (modifica la lista original)
+technologies.sort()
+
+// Para ordenarla sin modificar la original, se puede hacer:
+sortedTechnologies = technologies.sort( false )
+
+/*** Manipulando Listas ***/
+
+// Reemplazar todos los elementos en la lista
+Collections.replaceAll(technologies, 'Gradle', 'gradle')
+
+// Mezclar una lista
+Collections.shuffle(technologies, new Random())
+
+// Limpiar una lista
+technologies.clear()
+
+// Creando un mapa vacío
+def devMap = [:]
+
+// Agregando valores
+devMap = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
+devMap.put('lastName','Perez')
+
+// Iterar sobre los elementos del mapa
+devMap.each { println "$it.key: $it.value" }
+devMap.eachWithIndex { it, i -> println "$i: $it"}
+
+// Evaluar si el mapa contiene una llave
+assert devMap.containsKey('name')
+
+// Evaluar si el mapa contiene un valor
+assert devMap.containsValue('Roberto')
+
+// Para obtener las llaves del mapa
+println devMap.keySet()
+
+// Para obtener los valores del mapa
+println devMap.values()
+
+/*
+  Groovy Beans
+
+  GroovyBeans son JavaBeans pero usando una sintaxis mucho más simple
+
+  Cuando Groovy es compilado a código de bytes, las siguientes reglas son usadas:
+
+    * Si el nombre es declarado con un modificador de acceso (public, private o
+      protected), entonces se genera un campo.
+
+    * Un nombre declarado sin modificador de acceso genera un campo privado con
+      un getter y un setter públicos (ej: una propiedad)
+
+    * Si una propiedad es declarada como final, entonces el campo privado es creado
+      como final y no se genera un setter.
+
+    * Puedes declarar una propiedad y también sus propios getter y setter.
+
+    * Puedes declarar una propiedad y un campo del mismo nombre, en ese caso, la
+      propiedad usará ese campo.
+
+    * Si quieres una propiedad private o proteceted, tienes que proveer tus propios
+      getter y setter, los cuales deben ser declarados private o protected.
+
+    * Si accedes a una propiedad desde dentro de la clase, la propiedad es definida
+      en tiempo de compilación con this implícito o explícito (por ejemplo, this.foo
+      o simplemente foo), Groovy accederá al campo directamente en vez de usar el 
+      getter y setter.
+
+    * Si accedes a una propiedad que no existe usando foo explícito o implícito, entonces
+      Groovy accederá a la propiedad a través de la clase meta, que puede fallar en
+      tiempo de ejecución.
+
+*/
+
+class Foo {
+    // propiedad de solo lectura
+    final String name = "Roberto"
+
+    // propiedad de solo lectura, con getter público y setter como protected
+    String language
+    protected void setLanguage(String language) { this.language = language }
+
+    // propiedad de tipo dinámico
+    def lastName
+}
+
+/*
+  Derivación Lógica e Iteraciones
+*/
+
+// Groovy soporta la clásica sintaxis de if - else
+def x = 3
+
+if(x==1) {
+    println "One"
+} else if(x==2) {
+    println "Two"
+} else {
+    println "X greater than Two"
+}
+
+// Groovy también soporta el uso del operador ternario:
+def y = 10
+def x = (y > 1) ? "worked" : "failed"
+assert x == "worked"
+
+// ¡Groovy también soporta 'El Operador Elvis'!
+// En lugar de usar el operador ternario:
+
+displayName = user.name ? user.name : 'Anonymous'
+
+// Podemos escribirlo así:
+displayName = user.name ?: 'Anonymous'
+
+// Iteración con For
+// Iterando en un rango numérico
+def x = 0
+for (i in 0 .. 30) {
+    x += i
+}
+
+// Iterando sobre una lista
+x = 0
+for( i in [5,3,2,1] ) {
+    x += i
+}
+
+// Iterando sobre un arreglo
+array = (0..20).toArray()
+x = 0
+for (i in array) {
+    x += i
+}
+
+// Iterando sobre un mapa
+def map = ['name':'Roberto', 'framework':'Grails', 'language':'Groovy']
+x = 0
+for ( e in map ) {
+    x += e.value
+}
+
+/*
+  Operadores
+
+  Para la lista de los operadores que Groovy soporta, visita:
+  http://www.groovy-lang.org/operators.html#Operator-Overloading
+
+  Operadores Groovy útiles
+*/
+// Operador de propagación:  invocar una acción en todos los elementos de un objeto agregado.
+def technologies = ['Groovy','Grails','Gradle']
+technologies*.toUpperCase() // equivale a: technologies.collect { it?.toUpperCase() }
+
+// Operador de navegación segura: usado para evitar un NullPointerException.
+def user = User.get(1)
+def username = user?.username
+
+
+/*
+  Closures
+  Un Closure en Groovy es como un "bloque de código" o un puntero a un método. Es una 
+  porci´øn de código que es definida y ejecutada en un punto futuro en el tiempo.
+
+  Más información en: http://www.groovy-lang.org/closures.html
+*/
+// Ejemplo:
+def clos = { println "Hello World!" }
+
+println "Executing the Closure:"
+clos()
+
+// Pasando parámetros a un closure
+def sum = { a, b -> println a+b }
+sum(2,4)
+
+// Los Closures pueden referir a variables no listadas en sus listas de parámetros
+def x = 5
+def multiplyBy = { num -> num * x }
+println multiplyBy(10)
+
+// Si tienes un Closure que toma un solo argumento, puedes omitir la
+// definición del parámetro en el Closure
+def clos = { print it }
+clos( "hi" )
+
+/*
+  Groovy puede memorizar los resultados de un Closure [1][2][3]
+*/
+def cl = {a, b ->
+    sleep(3000) // simula algún proceso que consume tiempo
+    a + b
+}
+
+mem = cl.memoize()
+
+def callClosure(a, b) {
+    def start = System.currentTimeMillis()
+    mem(a, b)
+    println "Inputs(a = $a, b = $b) - took ${System.currentTimeMillis() - start} msecs."
+}
+
+callClosure(1, 2)
+callClosure(1, 2)
+callClosure(2, 3)
+callClosure(2, 3)
+callClosure(3, 4)
+callClosure(3, 4)
+callClosure(1, 2)
+callClosure(2, 3)
+callClosure(3, 4)
+
+/*
+  Expando
+
+  La clase Expando es un bean dinámico para que podamos agregar propiedades y closures
+  como métodos a una instancia de esta clase
+
+  http://mrhaki.blogspot.mx/2009/10/groovy-goodness-expando-as-dynamic-bean.html
+*/
+  def user = new Expando(name:"Roberto")
+  assert 'Roberto' == user.name
+
+  user.lastName = 'Pérez'
+  assert 'Pérez' == user.lastName
+
+  user.showInfo = { out ->
+      out << "Name: $name"
+      out << ", Last name: $lastName"
+  }
+
+  def sw = new StringWriter()
+  println user.showInfo(sw)
+
+
+/*
+  Metaprogramación (MOP)
+*/
+
+// Usando ExpandoMetaClass para agregar comportamiento
+String.metaClass.testAdd = {
+    println "we added this"
+}
+
+String x = "test"
+x?.testAdd()
+
+// Interceptando llamadas a métodos
+class Test implements GroovyInterceptable {
+    def sum(Integer x, Integer y) { x + y }
+
+    def invokeMethod(String name, args) {
+        System.out.println "Invoke method $name with args: $args"
+    }
+}
+
+def test = new Test()
+test?.sum(2,3)
+test?.multiply(2,3)
+
+// Groovy soporta propertyMissing para lidiar con intentos de resolución de propiedades.
+class Foo {
+   def propertyMissing(String name) { name }
+}
+def f = new Foo()
+
+assertEquals "boo", f.boo
+
+/*
+  TypeChecked y CompileStatic
+  Groovy, por naturaleza, es y siempre será un lenguaje dinámico pero soporta
+  typechecked y compilestatic
+
+  Más información: http://www.infoq.com/articles/new-groovy-20
+*/
+// TypeChecked
+import groovy.transform.TypeChecked
+
+void testMethod() {}
+
+@TypeChecked
+void test() {
+    testMeethod()
+
+    def name = "Roberto"
+
+    println naameee
+
+}
+
+// Otro ejemplo:
+import groovy.transform.TypeChecked
+
+@TypeChecked
+Integer test() {
+    Integer num = "1"
+
+    Integer[] numbers = [1,2,3,4]
+
+    Date date = numbers[1]
+
+    return "Test"
+
+}
+
+// ejemplo de CompileStatic:
+import groovy.transform.CompileStatic
+
+@CompileStatic
+int sum(int x, int y) {
+    x + y
+}
+
+assert sum(2,5) == 7
+
+
+```
+
+## Más recursos
+
+[Documentación de Groovy](http://www.groovy-lang.org/documentation.html)
+
+[Consola Web de Groovy](http://groovyconsole.appspot.com/)
+
+Únete a un [Groovy user group](http://www.groovy-lang.org/usergroups.html)
+
+## Libros
+
+* [Groovy Goodness] (https://leanpub.com/groovy-goodness-notebook)
+
+* [Groovy in Action] (http://manning.com/koenig2/)
+
+* [Programming Groovy 2: Dynamic Productivity for the Java Developer] (http://shop.oreilly.com/product/9781937785307.do)
+
+[1] http://roshandawrani.wordpress.com/2010/10/18/groovy-new-feature-closures-can-now-memorize-their-results/
+[2] http://www.solutionsiq.com/resources/agileiq-blog/bid/72880/Programming-with-Groovy-Trampoline-and-Memoize
+[3] http://mrhaki.blogspot.mx/2011/05/groovy-goodness-cache-closure-results.html
diff --git a/es-es/javascript-es.html.markdown b/es-es/javascript-es.html.markdown
index 34428f42..31512dc4 100644
--- a/es-es/javascript-es.html.markdown
+++ b/es-es/javascript-es.html.markdown
@@ -16,7 +16,7 @@ con Java para aplicaciones más complejas. Debido a su integracion estrecha con
 web y soporte por defecto de los navegadores modernos se ha vuelto mucho más común 
 para front-end que Java.
 
-Aunque JavaScript no sólo se limita a los navegadores web: Node.js, Un proyecto que proporciona un entorno de ejecución independiente para el motor V8 de Google Chrome, se está volviendo más y más popular.
+Sin embargo, JavaScript no sólo se limita a los navegadores web: Node.js, un proyecto que proporciona un entorno de ejecución independiente para el motor V8 de Google Chrome, se está volviendo más y más popular.
 
 ¡La retroalimentación es bienvenida! Puedes encontrarme en: 
 [@adambrenecki](https://twitter.com/adambrenecki), o
@@ -82,13 +82,13 @@ false;
 !true; // = false
 !false; // = true
 
-// Para comprobar una igualdad se usa ==
-1 == 1; // = true
-2 == 1; // = false
+// Para comprobar una igualdad se usa ===
+1 === 1; // = true
+2 === 1; // = false
 
-// Para comprobar una desigualdad se usa !=
-1 != 1; // = false
-2 != 1; // = true
+// Para comprobar una desigualdad se usa !==
+1 !== 1; // = false
+2 !== 1; // = true
 
 // Más comparaciones
 1 < 10; // = true
diff --git a/es-es/pythonstatcomp-es.html.markdown b/es-es/pythonstatcomp-es.html.markdown
new file mode 100644
index 00000000..0130b72a
--- /dev/null
+++ b/es-es/pythonstatcomp-es.html.markdown
@@ -0,0 +1,238 @@
+---
+language: Statistical computing with Python
+contributors:
+    - ["e99n09", "https://github.com/e99n09"]
+filename: pythonstatcomp-es.py
+translators:
+    - ["Damaso Sanoja", "https://github.com/damasosanoja"]
+lang: es-es
+---
+
+Este es un tutorial de como realizar tareas típicas de programación estadística usando Python. Está destinado a personas con cierta familiaridad con Python y con experiencia en programación estadística en lenguajes como R, Stata, SAS, SPSS, or MATLAB.
+
+```python
+
+# 0. Cómo configurar ====
+
+""" Configurar con IPython y pip install lo siguiente: numpy, scipy, pandas,
+    matplotlib, seaborn, requests.
+        Asegúrese de realizar este tutorial con el IPython notebook para tener fácil
+    acceso a las ayudas en tiempo real y la documentación respectiva.
+"""
+
+# 1. Captura de datos ====
+
+""" Muchos prefieren Python sobre R ya que quieren interactuar mucho
+    con la web, bien sea haciendo webscraping o solicitando datos mediante
+    un API. Esto se puede hacer en R, pero en el contexto de un proyecto
+    que ya usa Python, existen beneficios al mantener un solo lenguaje.
+"""
+
+import requests # para llamados HTTP (webscraping, APIs)
+import os
+
+# webscraping
+r = requests.get("https://github.com/adambard/learnxinyminutes-docs")
+r.status_code # si es 200, el llamado ha sido exitoso
+r.text # código fuente de la página
+print(r.text) # formateado y embellecido
+# graba el código fuente en un fichero:
+os.getcwd() # verifica cual es el directorio de trabajo
+f = open("learnxinyminutes.html","wb")
+f.write(r.text.encode("UTF-8"))
+f.close()
+
+# descargando un csv
+fp = "https://raw.githubusercontent.com/adambard/learnxinyminutes-docs/master/"
+fn = "pets.csv"
+r = requests.get(fp + fn)
+print(r.text)
+f = open(fn,"wb")
+f.write(r.text.encode("UTF-8"))
+f.close()
+
+""" para saber más del módulo de peticiones, incluyendo APIs, ver
+    http://docs.python-requests.org/en/latest/user/quickstart/
+"""
+
+# 2. Leyendo un fichero CSV ====
+
+""" El paquete pandas de Wes McKinney brinda objetos 'DataFrame' en Python. Si
+    has usado R, ya estarás familiarizado con la idea de "data.frame".
+"""
+
+import pandas as pd, numpy as np, scipy as sp
+pets = pd.read_csv(fn)
+pets
+#       nombre edad  peso especies
+# 0    fluffy     3    14      cat
+# 1  vesuvius     6    23     fish
+# 2       rex     5    34      dog
+
+""" Usuarios de R: notar que Python, al igual que otros lenguajes de programación
+    normales, comienza indexando desde 0. R de forma inusual comienza desde 1.
+"""
+
+# dos formas distintas de imprimir una columna
+pets.age
+pets["age"]
+
+pets.head(2) # imprime las primeras dos filas
+pets.tail(1) # imprime la última fila
+
+pets.name[1] # 'vesuvius'
+pets.species[0] # 'cat'
+pets["weight"][2] # 34
+
+# en R, puedes esperar obtener 3 filas haciendo esto, pero aquí obtienes 2:
+pets.age[0:2]
+# 0    3
+# 1    6
+
+sum(pets.age)*2 # 28
+max(pets.weight) - min(pets.weight) # 20
+
+""" Si estás procesando grandes cantidades de cálculos de álgebra lineal, podrías
+    querer usar matrices, no DataFrames. Los DataFrames son ideales para combinar
+    columnas de diferentes tipos.
+"""
+
+# 3. Gráficas ====
+
+import matplotlib as mpl, matplotlib.pyplot as plt
+%matplotlib inline
+
+# Para hacer virtualización de datos en Python, usa matplotlib
+
+plt.hist(pets.age);
+
+plt.boxplot(pets.weight);
+
+plt.scatter(pets.age, pets.weight); plt.xlabel("age"); plt.ylabel("weight");
+
+# seaborn está por encima de matplotlib y logra mejores gráficos
+
+import seaborn as sns
+
+plt.scatter(pets.age, pets.weight); plt.xlabel("age"); plt.ylabel("weight");
+
+# también hay algunas funciones gráficas específicas de seaborn
+# nota como seaborn etiqueta automáticamente el eje x en este gráfico de barras
+sns.barplot(pets["age"])
+
+# los veteranos de R pueden seguir usando ggplot
+from ggplot import *
+ggplot(aes(x="age",y="weight"), data=pets) + geom_point() + labs(title="pets")
+# fuente: https://pypi.python.org/pypi/ggplot
+
+# incluso hay un porteo d3.js: https://github.com/mikedewar/d3py
+
+# 4. Limpieza simple de datos y análisis exploratorio ====
+
+""" Tenemos ahora un ejemplo más complicado que demuestra un flujo básico para
+    limpieza de datos que lleva a la creación de algunos gráficos exploratorios
+    y la ejecución de una regresión lineal.
+        El conjunto de datos fue transcrito de Wikipedia a mano. Contiene
+    todos los Emperadores Romanos Sagrados y fechas claves en sus vidas
+    (nacimiento, muerte, coronación, etc.).
+        El objetivo del análisis es explorar si existe alguna relación
+    entre el año de nacimiento del Emperador y su tiempo de vida.
+    fuente de datos: https://en.wikipedia.org/wiki/Holy_Roman_Emperor
+"""
+
+# cargar algunos datos de los Emperadores Romanos Sagrados
+url = "https://raw.githubusercontent.com/e99n09/R-notes/master/data/hre.csv"
+r = requests.get(url)
+fp = "hre.csv"
+f = open(fp,"wb")
+f.write(r.text.encode("UTF-8"))
+f.close()
+
+hre = pd.read_csv(fp)
+
+hre.head()
+"""
+   Ix      Dynasty        Name        Birth             Death Election 1  
+0 NaN  Carolingian   Charles I  2 April 742    28 January 814        NaN   
+1 NaN  Carolingian     Louis I          778       20 June 840        NaN   
+2 NaN  Carolingian   Lothair I          795  29 September 855        NaN   
+3 NaN  Carolingian    Louis II          825     12 August 875        NaN   
+4 NaN  Carolingian  Charles II  13 June 823     6 October 877        NaN   
+
+  Election 2      Coronation 1   Coronation 2 Ceased to be Emperor  
+0        NaN   25 December 800            NaN       28 January 814   
+1        NaN  11 September 813  5 October 816          20 June 840   
+2        NaN       5 April 823            NaN     29 September 855   
+3        NaN        Easter 850     18 May 872        12 August 875   
+4        NaN   29 December 875            NaN        6 October 877   
+
+  Descent from whom 1 Descent how 1 Descent from whom 2 Descent how 2  
+0                 NaN           NaN                 NaN           NaN  
+1           Charles I           son                 NaN           NaN  
+2             Louis I           son                 NaN           NaN  
+3           Lothair I           son                 NaN           NaN  
+4             Louis I           son                 NaN           NaN  
+"""
+
+# limpiar las columnas de Nacimiento y Muerte
+
+import re # módulo para expresiones regulares
+
+rx = re.compile(r'\d+$') # coincidencia de últimos dígitos
+
+""" Esta función aplica una expresión regular a una columna de entrada (Birth,
+    Death), nivela la lista resultante, la convierte en un objeto Series, y
+    finalmente convierte el tipo del objeto Series de string a entero. Para
+    más información sobre que hace cada parte del código, ver:
+      - https://docs.python.org/2/howto/regex.html
+      - http://stackoverflow.com/questions/11860476/how-to-unlist-a-python-list
+      - http://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.html
+"""
+def extractYear(v):
+    return(pd.Series(reduce(lambda x,y: x+y,map(rx.findall,v),[])).astype(int))
+
+hre["BirthY"] = extractYear(hre.Birth)
+hre["DeathY"] = extractYear(hre.Death)
+
+# hacer una columna decir la edad estimada
+hre["EstAge"] = hre.DeathY.astype(int) - hre.BirthY.astype(int)
+
+# gráfica de dispersión simple, sin línea de tendencia, el color representa dinastía
+sns.lmplot("BirthY", "EstAge", data=hre, hue="Dynasty", fit_reg=False);
+
+# usa scipy para hacer regresiones lineales
+from scipy import stats
+(slope,intercept,rval,pval,stderr)=stats.linregress(hre.BirthY,hre.EstAge)
+# código fuente: http://wiki.scipy.org/Cookbook/LinearRegression
+
+# verifica la pendiente (slope)
+slope # 0.0057672618839073328
+
+# verifica el valor R^2 :
+rval**2 # 0.020363950027333586
+
+# verifica el valor p
+pval # 0.34971812581498452
+
+# usa seaborn para hacer un gráfico de dispersión y dibujar una regresión lineal
+# de la tendencia
+sns.lmplot("BirthY", "EstAge", data=hre);
+
+""" Para más información sobre seaborn, ver
+      - http://web.stanford.edu/~mwaskom/software/seaborn/
+      - https://github.com/mwaskom/seaborn
+    Para más información sobre SciPy, ver
+      - http://wiki.scipy.org/SciPy
+      - http://wiki.scipy.org/Cookbook/
+    Para ver una versión del análisis de los Emperadores Romanos usando R, ver
+      - http://github.com/e99n09/R-notes/blob/master/holy_roman_emperors_dates.R
+"""
+```
+
+Si quieres aprender más, obtén _Python for Data Analysis_ por Wes McKinney. Es un extraordinario recurso usado como referencia para escribir este tutorial.
+
+También puedes encontrar gran cantidad de tutoriales interactivos de IPython en temas específicos a tus intereses, como Pilon de Cam Davidson <a href="http://camdavidsonpilon.github.io/Probabilistic-Programming-and-Bayesian-Methods-for-Hackers/" Title="Probabilistic Programming and Bayesian Methods for Hackers">Probabilistic Programming and Bayesian Methods for Hackers</a>.
+
+Ver más módulos para investigar:
+   - análisis de texto y procesamiento natural del lenguaje: nltk, http://www.nltk.org
+   - análisis de redes sociales: igraph, http://igraph.org/python/
diff --git a/es-es/self-es.html.markdown b/es-es/self-es.html.markdown
new file mode 100644
index 00000000..11972214
--- /dev/null
+++ b/es-es/self-es.html.markdown
@@ -0,0 +1,163 @@
+---
+language: self
+contributors:
+    - ["Russell Allen", "http://github.com/russellallen"]
+filename: learnself-es.self
+translators:
+    - ["Damaso Sanoja", "https://github.com/damasosanoja"]
+lang: es-es
+---
+
+Self es un lenguaje OO basado en prototipo rápido que corre en su propio vm JIT. La mayoría del desarrollo se hace a través de la interacción con objetos vivos en un entorno de desarrollo visual llamado *morphic* que tiene integrado navegador y depurador.
+
+Todo en Self es un objeto. Todos los cómputos son hechos enviando mensajes a los objetos. En Self se puede entender por Objetos a los conjuntos de pares clave-valor.
+
+# Construyendo objetos
+
+El intérprete incorporado de Self puede construir objetos, incluyendo objetos-métodos.
+
+```
+"Esto es un comentario"
+
+"Una cadena de caracteres (string):"
+'Esto es un string con \'caracteres\' escapados.\n'
+
+"Un entero de 30 bits"
+23
+
+"Un decimal de 30 bits"
+3.2
+
+"-20"
+-14r16
+
+"Un objeto que solo entiende un mensaje, 'x' que regresa 20"
+(|
+  x = 20.
+|)
+
+"Un objeto que además entiende 'x:' que establece la posición x"
+(|
+  x <- 20.
+|)
+
+"Un objeto que entiende el método 'doubleX' el cual
+duplica el valor de x y luego regresa el objeto"
+(|
+  x <- 20.
+  doubleX = (x: x * 2. self)
+|)
+
+"Un objeto que entiende todos los mensajes
+que 'traits point' entiende". El intérprete
+mira a 'traits point' enviando los mensajes
+'traits' y luego 'point' a un objeto conocido llamado
+el 'lobby'. El mira el objeto 'true' enviando
+también el mensaje 'true' al lobby."
+(|     parent* = traits point.
+       x = 7.
+       y <- 5.
+       isNice = true.
+|)
+```
+
+# Enviando mensajes a los objetos
+
+Los mensajes pueden ser unarios, binarios o palabras clave. La precedencia es en ese orden. A diferencia de Smalltalk, la precedencia de los mensajes binarios debe ser especificada, y todas las palabras clave después de la primera deben comenzar con una letra mayúscula. Los mensajes se separan de sus destinos mediante espacios en blanco.
+
+```
+"mensaje unario, envía 'printLine' al objeto '23'
+que imprime el string '23' en stdout y regresa el objeto recibido (ejem 23)"
+23 printLine
+
+"envía el mensaje '+' con '7' para '23', luego el mensaje '*' con '8' para el resultado"
+(23 + 7) * 8
+
+"envía 'power:' para '2' con '8' regresa 256"
+2 power: 8
+
+"envía 'keyOf:IfAbsent:' para 'hello' con los argumentos 'e' y '-1'.
+Regresa 1, el índice de 'e' en 'hello'."
+'hello' keyOf: 'e' IfAbsent: -1
+```
+
+# Bloques
+
+Self define el control de flujo como Smalltalk y Ruby mediante bloques Los bloques son cómputos demorados de la forma.:
+
+```
+[|:x. localVar| x doSomething with: localVar]
+```
+
+Ejemplos del uso de bloques:
+
+```
+"regresa 'HELLO'"
+'hello' copyMutable mapBy: [|:c| c capitalize]
+
+"regresa 'Nah'"
+'hello' size > 5 ifTrue: ['Yay'] False: ['Nah']
+
+"regresa 'HaLLO'"
+'hello' copyMutable mapBy: [|:c|
+   c = 'e' ifTrue: [c capitalize]
+            False: ['a']]
+```
+
+Las expresiones múltiples son separadas por un punto. ^ retorna inmediatamente.
+
+```
+"returns An 'E'! How icky!"
+'hello' copyMutable mapBy: [|:c. tmp <- ''|
+   tmp: c capitalize.
+   tmp = 'E' ifTrue: [^ 'An \'E\'! How icky!'].
+   c capitalize
+   ]
+```
+
+Los bloques son ejecutados al enviales el mensaje 'value' y son inherentes (delegados a) sus contextos:
+```
+"returns 0"
+[|x|
+    x: 15.
+    "Envía repetidamente 'value' al primer bloque mientras el resultado de enviar 'value' al segundo bloque es el objeto 'true'"
+    [x > 0] whileTrue: [x: x - 1].
+    x
+] value
+```
+
+# Métodos
+
+Los métodos son como los bloques pero no están dentro de un contexto sino que son almacenados como valores de ranuras. A diferencia de Smalltalk, los métodos no regresan por defecto 'self' sino su valor final.
+
+```
+"Aquí tenemos un objeto con una ranura asignable 'x' y un método 'reduceXTo: y'.
+Enviando el mensaje 'reduceXTo: 10' a este objeto pondrá
+el objeto '10' en la ranura 'x' y regresará el objeto original"
+(|
+    x <- 50.
+    reduceXTo: y = (
+        [x > y] whileTrue: [x: x - 1].
+        self)
+|)
+.
+```
+
+# Prototipos
+
+Self no posee clases. La forma de acceder a un objeto es encontrando un prototipo y copiándolo.
+
+```
+| d |
+d: dictionary copy.
+d at: 'hello' Put: 23 + 8.
+d at: 'goodbye' Put: 'No!.
+"Prints No!"
+( d at: 'goodbye' IfAbsent: 'Yes! ) printLine.
+"Prints 31"
+( d at: 'hello' IfAbsent: -1 ) printLine.
+```
+
+# Para mayor información
+
+El [Manual de Self](http://handbook.selflanguage.org) tiene mucha más información, y nada mejor que experiencia de primera mano con Self descargándolo de su [página web](http://www.selflanguage.org).
diff --git a/es-es/typescript-es.html.markdown b/es-es/typescript-es.html.markdown
new file mode 100644
index 00000000..c42da4a4
--- /dev/null
+++ b/es-es/typescript-es.html.markdown
@@ -0,0 +1,172 @@
+---
+language: TypeScript
+contributors:
+    - ["Philippe Vlérick", "https://github.com/pvlerick"]
+filename: learntypescript-es.ts
+translators:
+    - ["Damaso Sanoja", "https://github.com/damasosanoja"]
+lang: es-es
+---
+
+TypeScript es un lenguaje cuyo objetivo es facilitar el desarrollo de aplicaciones a gran escala escritas en JavaScript.
+TypeScript añade conceptos comunes como clases, módulos, interfaces, genéricos y (opcionalmente) tipeo estático a JavaScript.
+Es un superset de JavaScript: todo el código JavaScript es código válido en TypeScript de manera que se puede integrar fácilmente a cualquier proyecto . El compilador TypeScript emite JavaScript.
+
+Este artículo se enfocará solo en la sintáxis extra de TypeScript, y no en [JavaScript] (../javascript/).
+
+Para probar el compilador de TypeScript, diríjase al [Área de Pruebas] (http://www.typescriptlang.org/Playground) donde podrá tipear código, y ver como se auto-completa al tiempo que ve el código emitido JavaScript.
+
+```js
+// Existen 3 tipos básicos en TypeScript
+var isDone: boolean = false;
+var lines: number = 42;
+var name: string = "Anders";
+
+// Cuando es imposible de saber, tenemos el tipo "Any"
+var notSure: any = 4;
+notSure = "maybe a string instead";
+notSure = false; // okey, definitivamente un boolean
+
+// Para colecciones, hay matrices de tipos y matrices genéricas
+var list: number[] = [1, 2, 3];
+// Alternativamente, usando la matriz genérica
+var list: Array<number> = [1, 2, 3];
+
+// Para enumeradores:
+enum Color {Red, Green, Blue};
+var c: Color = Color.Green;
+
+// Finalmente, "void" es usado para el caso especial de una función que no retorna nada
+function bigHorribleAlert(): void {
+  alert("I'm a little annoying box!");
+}
+
+// Las funciones son ciudadanos de primera clase, soportan la sintáxis lambda "fat arrow" y
+// usan el tipo inferencia
+
+// Lo siguiente es equivalante, la misma firma será inferida por el
+// compilador, y el mismo JavaScript será emitido
+var f1 = function(i: number): number { return i * i; }
+// Retorna tipo inferido
+var f2 = function(i: number) { return i * i; }
+var f3 = (i: number): number => { return i * i; }
+// Retorna tipo inferido
+var f4 = (i: number) => { return i * i; }
+// Retorna tipo inferido, one-liner significa que no es necesario que regresen palabras claves
+var f5 = (i: number) =>  i * i;
+
+// Las interfaces son estructurales, todo lo que tenga las propiedades cumple con
+// la interfase
+interface Person {
+  name: string;
+  // Propiedades opcionales, marcadas con un "?"
+  age?: number;
+  // Y por supuesto funciones
+  move(): void;
+}
+
+// Objeto que implementa la interfase "Persona"
+// Puede ser tratada como Persona ya que posee las propiedades name y move
+var p: Persona = { name: "Bobby", move: () => {} };
+// Objetos que tienen propiedades opcionales:
+var validPersona: Persona = { name: "Bobby", age: 42, move: () => {} };
+// No es una persona porque su edad no es un número
+var invalidPersona: Persona = { name: "Bobby", age: true };
+
+// Las interfases también pueden describir un tipo de función
+interface SearchFunc {
+  (source: string, subString: string): boolean;
+}
+// Solo los tipos de parámetros son importantes, los nombres no son importantes.
+var mySearch: SearchFunc;
+mySearch = function(src: string, sub: string) {
+  return src.search(sub) != -1;
+}
+
+// Clases - los miembros son públicos por defecto
+class Point {
+  // Properties
+    x: number;
+
+    // Constructor - las palabras clave public/private en este contexto generarán
+    // un código boiler plate para la propiedad y la inicialización en el
+    // constructor.
+    // En este ejemplo, "y" debe ser definida al igual que "x" lo es, pero con menos código
+    // También son soportados valores por defecto
+
+    constructor(x: number, public y: number = 0) {
+        this.x = x;
+    }
+
+    // Funciones
+    dist() { return Math.sqrt(this.x * this.x + this.y * this.y); }
+
+    // Miembros estáticos
+    static origin = new Point(0, 0);
+}
+
+var p1 = new Point(10 ,20);
+var p2 = new Point(25); //y será 0
+
+// Herencia
+class Point3D extends Point {
+    constructor(x: number, y: number, public z: number = 0) {
+        super(x, y); // Un llamado explícito al constructor de la super clase es indispensable
+    }
+
+    // Sobrescribir
+    dist() {
+        var d = super.dist();
+        return Math.sqrt(d * d + this.z * this.z);
+    }
+}
+
+// Módulos, los "." pueden ser usados como separadores para los submódulos
+module Geometry {
+  export class Square {
+    constructor(public sideLength: number = 0) {
+    }
+    area() {
+      return Math.pow(this.sideLength, 2);
+    }
+  }
+}
+
+var s1 = new Geometry.Square(5);
+
+// Un alias local para referirse a un módulo
+import G = Geometry;
+
+var s2 = new G.Square(10);
+
+// Genéricos
+// Clases
+class Tuple<T1, T2> {
+    constructor(public item1: T1, public item2: T2) {
+    }
+}
+
+// Interfases
+interface Pair<T> {
+    item1: T;
+    item2: T;
+}
+
+// Y funciones
+var pairToTuple = function<T>(p: Pair<T>) {
+    return new Tuple(p.item1, p.item2);
+};
+
+var tuple = pairToTuple({ item1:"hello", item2:"world"});
+
+// Incluyendo referencias a un archivo de definición:
+/// <reference path="jquery.d.ts" />
+
+```
+
+## Para mayor información
+ * [Sitio Oficial de TypeScript] (http://www.typescriptlang.org/)
+ * [Especificaciones del lenguaje TypeScript (pdf)] (http://go.microsoft.com/fwlink/?LinkId=267238)
+ * [Anders Hejlsberg - Introduciendo TypeScript en Canal 9] (http://channel9.msdn.com/posts/Anders-Hejlsberg-Introducing-TypeScript)
+ * [Código fuente en GitHub] (https://github.com/Microsoft/TypeScript)
+ * [Definitely Typed - repositorio para definiciones de tipo] (http://definitelytyped.org/)