diff --git a/examples.txt b/examples.txt
index f39c33192..e899cdb79 100644
--- a/examples.txt
+++ b/examples.txt
@@ -10,10 +10,10 @@ Slices
 Mapas
 Range
 Funciones
-Multiples Valores de Retorno
-Funciones Variadicas
+Múltiples valores de retorno
+Funciones variadicas
 Closures
-Recursion
+Recursión
 Apuntadores
 Structs
 Métodos
@@ -21,9 +21,9 @@ Interfaces
 Errores
 Goroutines
 Canales
-Buffering de Canales
-Sincronizacion de Canales
-Direccion de Canales
+Buffering de canales
+Sincronizacion de canales
+Dirección de canales
 Select
 Tiempo de espera
 Operaciones sobre canales sin bloqueo
@@ -37,11 +37,11 @@ Contadores atómicos
 Mutexes
 Gorutinas con estado
 Ordenamiento
-Ordenamiento por Funciones
+Ordenamiento por funciones
 Panic
 Defer
 Funciones sobre colecciones
-Funciones de Cadenas
+Funciones de cadenas
 Formateo de cadenas
 Expresiones regulares
 JSON
diff --git a/examples/apuntadores/apuntadores.go b/examples/apuntadores/apuntadores.go
index 1f9532ecc..5af9015d2 100644
--- a/examples/apuntadores/apuntadores.go
+++ b/examples/apuntadores/apuntadores.go
@@ -6,7 +6,7 @@ package main
 
 import "fmt"
 
-// Veamos como los apuntadores funcionan en contraste con los valores directos
+// Veamos cómo los apuntadores funcionan en contraste con los valores directos
 // utilizando dos funciones: `zeroval` y `zeroptr`. `zeroval` recibe
 // un parametro `int`, así que los argumentos serán pasados por valor.
 // `zeroval` va a recibir una copia de `ival` distinta a la de la función
@@ -15,10 +15,10 @@ func zeroval(ival int) {
     ival = 0
 }
 
-// `zeroptr` recibe un parametro `*int`, lo que significa
+// `zeroptr` recibe un parámetro `*int`, lo que significa
 // que recibe un apuntador a un valor `int`. El código `*iptr` en el
 // cuerpo de la función _dereferencía_ el apuntador de su dirección de
-// memoria a el valor actual de esa dirección.
+// memoria al valor actual de esa dirección.
 // Si asignamos un valor a un apuntador dereferenciado se cambia el valor
 // que se está almacenando en dicha dirección de memoria.
 func zeroptr(iptr *int) {
diff --git a/examples/apuntadores/apuntadores.sh b/examples/apuntadores/apuntadores.sh
index 2f8aef450..d58694837 100644
--- a/examples/apuntadores/apuntadores.sh
+++ b/examples/apuntadores/apuntadores.sh
@@ -1,6 +1,6 @@
-# `zeroval` no cambia el valor de `i` en `main`.
-# `zeroptr` si porque tiene una referencia a la dirección
-# en memoria de esa variable.
+# `zeroval` no cambia el valor de `i` en `main`,
+# mientras que `zeroptr` sí ya que tiene una referencia 
+# a la dirección en memoria de esa variable.
 $ go run pointers.go
 initial: 1
 zeroval: 1
diff --git a/examples/buffering-de-canales/buffering-de-canales.go b/examples/buffering-de-canales/buffering-de-canales.go
index bb8aa3977..444e8e2a0 100644
--- a/examples/buffering-de-canales/buffering-de-canales.go
+++ b/examples/buffering-de-canales/buffering-de-canales.go
@@ -1,8 +1,8 @@
 // Por defecto, los canales no usan un buffer, lo que
-// signifca que solo aceptan envíos (`chan <-`) si hay un
+// signifca que sólo aceptan envíos (`chan <-`) si hay un
 // receptor correspondiente (`<- chan`) listo para recibir
 // el valor enviado. Los canales _con buffer_ pueden aceptar
-// un numero limitado de valores sin un receptor correspondiente
+// un número limitado de valores sin un receptor correspondiente
 // para esos valores.
 
 package main
diff --git a/examples/canales/canales.sh b/examples/canales/canales.sh
index 7fbe5fe68..0b8e73be0 100644
--- a/examples/canales/canales.sh
+++ b/examples/canales/canales.sh
@@ -1,11 +1,11 @@
-# Cuando corremos el programa el mensaje `"ping"` se
+# Cuando corremos el programa, el mensaje `"ping"` se
 # pasa de una goroutine a otra a través de nuestro
 # canal.
 $ go run channels.go
 ping
 
 # Por defecto la recepción y los envíos se bloquean hasta
-# que ambos receptor y transmisor están listos. Esta
-# propiedad nos permite esperar hasta el mensaje
+# que tanto receptor como transmisor están listos. Esta
+# propiedad nos permite esperar el mensaje
 # `"ping"` hasta el final del programa sin tener
 # que usar ningún otro tipo de sincronización.
diff --git a/examples/cerrando-canales/cerrando-canales.go b/examples/cerrando-canales/cerrando-canales.go
index eff0d77f4..1b0276712 100644
--- a/examples/cerrando-canales/cerrando-canales.go
+++ b/examples/cerrando-canales/cerrando-canales.go
@@ -1,13 +1,13 @@
 // Al _cerrar_ un canal, indicamos que ya no se enviarán
 // más valores por él. Esto puede ser útil para comunicar
 // a los canales receptores que el trabajo se ha
-//completado.
+// completado.
 package main
 
 import "fmt"
 
 // En este ejemplo vamos a usar el canal `jobs` para
-// comunicar el trabajo que debe de ser hecho desde la
+// comunicar el trabajo que debe ser realizado desde la
 // gorutina `main()` hacia la gorutina trabajadora. Cuando
 // no haya más trabajos cerraremos el canal `jobs` con la
 // llamada built-in `close`.
@@ -15,7 +15,7 @@ func main() {
     jobs := make(chan int, 5)
     done := make(chan bool)
 
-    // Aquí esta la gorutina trabajadora. Recibe
+    // Aquí está la gorutina trabajadora. Recibe
     // continuamente desde `jobs` con `j, more := <-
     // jobs`.  En esta variante de recepción de 2 valores,
     // el valor `more` será `false` si `jobs` ha sido
@@ -48,6 +48,6 @@ func main() {
 
     // Esperamos a que el trabajador termine usando la
     // [sincronización](sincronizacion-de-canales) de
-    // canales que vimos anteriormente
+    // canales que vimos anteriormente.
     <-done
 }
diff --git a/examples/contadores-atomicos/contadores-atomicos.go b/examples/contadores-atomicos/contadores-atomicos.go
index bd9181904..baaf7a898 100644
--- a/examples/contadores-atomicos/contadores-atomicos.go
+++ b/examples/contadores-atomicos/contadores-atomicos.go
@@ -1,7 +1,7 @@
 // El mecanismo principal para manejar estados en Go es la comunicación
 // mediante canales (channels).  Podemos ver esto, por ejemplo, con los
-// [_worker-pools_](worker-pools). Además de canales existen otras formas para
-// manejar estados.  En éste código conoceremos el uso del paquete
+// [_pools de trabajadores_](/pool-de-trabajadores). Además de canales existen otras formas para
+// manejar estados. En éste código conoceremos el uso del paquete
 // `sync/atomic` para _contadores atómicos_, los cuales pueden ser accedidos
 // por múltiples _goroutines_.
 
@@ -44,7 +44,7 @@ func main() {
     // por otras _goroutines_, hacemos una copia del valor actual en la
     // variable `opsFinal`, usando la función `atomic.LoadUint64`. Tal como en
     // el bloque anterior necesitamos pasar la dirección de la variable `ops`,
-    // es decir `&ops`, de donde se copiará el valor.
+    // es decir, `&ops`, de donde se copiará el valor.
     opsFinal := atomic.LoadUint64(&ops)
     fmt.Println("ops:", opsFinal)
 }
diff --git a/examples/direccion-de-canales/direccion-de-canales.go b/examples/direccion-de-canales/direccion-de-canales.go
index 6f7dddd51..5c4a817ea 100644
--- a/examples/direccion-de-canales/direccion-de-canales.go
+++ b/examples/direccion-de-canales/direccion-de-canales.go
@@ -1,5 +1,5 @@
 // Cuando utilizas un canal como parámetro de una función,
-// puedes especificar si el canal es solo para recibir o enviar
+// puedes especificar si el canal es sólo para recibir o enviar
 // valores. Esto nos permite incrementar la seguridad de tipos
 // del programa.
 
@@ -7,7 +7,7 @@ package main
 
 import "fmt"
 
-// Esta función `ping` solo acepta un canal para enviar valores.
+// Esta función `ping` sólo acepta un canal para enviar valores.
 // Se arrojaría un error de compilación si intentamos recibir
 // un valor en este canal.
 func ping(pings chan<- string, msg string) {
diff --git a/examples/errores/errores.go b/examples/errores/errores.go
index 907870e6a..a13066276 100644
--- a/examples/errores/errores.go
+++ b/examples/errores/errores.go
@@ -1,10 +1,10 @@
-// En Go es idiomatico comunicar errores a través de
+// En Go es idiomático comunicar errores a través de
 // un valor de retorno separado.
 // Esto contrasta con las excepciones usadas en lenguajes
 // como Java y Ruby y sobrecargar el resultado como en
 // ocasiones se hace en C.
 // Con la manera en que se hace en Go es más facil ver
-// cuales funciones regresan errores y manejarlos utilizando
+// qué funciones regresan errores y manejarlos utilizando
 // las mismas estructuras de control como lo hacemos con
 // todas las demás tareas.
 
@@ -32,7 +32,7 @@ func f1(arg int) (int, error) {
 
 // Es posible usar tipos personalizados como `error` simplemente
 // implementando el método `Error()` en ellos. Aquí una
-// variante de el ejemplo anterior que utiliza un tipo personalizado
+// variante del ejemplo anterior que utiliza un tipo personalizado
 // para representar explícitamente un error de argumentos.
 type argError struct {
     arg  int
@@ -58,8 +58,7 @@ func main() {
 
     // Estos dos ciclos prueban cada una de nuestras
     // funciones. Nota que el uso de la revisión de errores
-    // en una sola linea de `if` es un estilo común en
-    // código de Go.
+    // en una única línea de `if` es un estilo común en Go
     for _, i := range []int{7, 42} {
         if r, e := f1(i); e != nil {
             fmt.Println("f1 failed:", e)
@@ -77,7 +76,7 @@ func main() {
 
     // Si quieres usar la información que es parte de un error personalizado
     // programáticamente, vas a necesitar asignar el error a una
-    // una instancia de el tipo personalizado de error por medio de la
+    // una instancia del tipo personalizado de error por medio de la
     // aserción de tipo.
     _, e := f2(42)
     if ae, ok := e.(*argError); ok {
diff --git a/examples/funciones-variadicas/funciones-variadicas.go b/examples/funciones-variadicas/funciones-variadicas.go
index 8330b26eb..baa76c0fc 100644
--- a/examples/funciones-variadicas/funciones-variadicas.go
+++ b/examples/funciones-variadicas/funciones-variadicas.go
@@ -6,7 +6,7 @@ package main
 
 import "fmt"
 
-// Aquí declaramos una función que va a recibir un numero
+// Aquí declaramos una función que va a recibir un número
 // arbitrario de valores tipo `int` como argumentos.
 func sum(nums ...int) {
     fmt.Print(nums, " ")
diff --git a/examples/funciones/funciones.go b/examples/funciones/funciones.go
index 2539e348b..331828e06 100644
--- a/examples/funciones/funciones.go
+++ b/examples/funciones/funciones.go
@@ -1,15 +1,15 @@
 // Las _Funciones_ son una parte escencial de Go. Veamos algunos
-// ejemplos para entender como se utilizan.
+// ejemplos para entender cómo se utilizan.
 
 package main
 
 import "fmt"
 
-// Aquí tenemos una funcion que recibe dos valores `int`
+// Aquí tenemos una función que recibe dos valores `int`
 // y regresa la suma de los mismos como `int`.
 func plus(a int, b int) int {
 
-    // Go requiere retornos de valor explicitos, i.e. no regresa
+    // Go requiere retornos de valor explícitos, i.e. no regresa
     // automáticamente el valor de la última expresión.
     return a + b
 }
diff --git a/examples/interfaces/interfaces.go b/examples/interfaces/interfaces.go
index dc88d0942..1c787903b 100644
--- a/examples/interfaces/interfaces.go
+++ b/examples/interfaces/interfaces.go
@@ -22,8 +22,8 @@ type circulo struct {
     radio float64
 }
 
-// Para implementar una interfaz en Go, solo tenemos
-// que implementar todos los metodos de la misma.
+// Para implementar una interfaz en Go, sólo tenemos
+// que implementar todos los métodos de la misma.
 // Aquí implementamos `geometrica` en `cuadro`.
 func (s cuadro) area() float64 {
     return s.ancho * s.altura
@@ -55,7 +55,7 @@ func main() {
     c := circulo{radio: 5}
 
     // Los tipos `circulo` y `cuadro` implementan la
-    // interfaz `geometrica` asi que podemos usar instancias de ambas
+    // interfaz `geometrica` así que podemos usar instancias de ambas
     // como parámetro de `medida`.
     medida(s)
     medida(c)
diff --git a/examples/limitacion-de-transferencia/limitacion-de-transferencia.go b/examples/limitacion-de-transferencia/limitacion-de-transferencia.go
index f2dd6685a..6e418a374 100644
--- a/examples/limitacion-de-transferencia/limitacion-de-transferencia.go
+++ b/examples/limitacion-de-transferencia/limitacion-de-transferencia.go
@@ -1,7 +1,7 @@
 // La limitación de tasa de transferencia es un mecanísmo
 // importante para controlar la utilización de un
 // recurso y mantener la calidad del servicio. Go lo
-// soporta elegantemente usando gorutinas, canales y
+// soporta elegantemente usando [gorutinas](/goroutines), [canales](/canales) y
 // [tickers](/tickers).
 
 package main
@@ -12,7 +12,7 @@ import "fmt"
 func main() {
 
     // Primero veamos una limitación básica. Supongamos
-    // que queremos limirar el número de peticiones
+    // que queremos limitar el número de peticiones
     // entrantes que podemos manejar. Serviremos estas
     // peticiones desde un canal con el mismo nombre.
     requests := make(chan int, 5)
@@ -34,9 +34,9 @@ func main() {
         fmt.Println("peticiones", req, time.Now())
     }
 
-    // Podriamos permitir pequeños picos de peticiones
+    // Podríamos permitir pequeños picos de peticiones
     // en nuestro esquema de limitación y seguir
-    // conservando el limite general. Para lograrlo
+    // conservando el límite general. Para lograrlo
     // podemos bufferear nuestro canal `limiter`. Este
     // canal `burstyLimiter` nos permitirá tener picos
     // de hasta 3 eventos.
diff --git a/examples/limitacion-de-transferencia/limitacion-de-transferencia.sh b/examples/limitacion-de-transferencia/limitacion-de-transferencia.sh
index 8351a368a..641229c6e 100644
--- a/examples/limitacion-de-transferencia/limitacion-de-transferencia.sh
+++ b/examples/limitacion-de-transferencia/limitacion-de-transferencia.sh
@@ -8,9 +8,6 @@ peticiones 3 2014-07-16 17:58:37.133983308 +0000 UTC
 peticiones 4 2014-07-16 17:58:37.333995394 +0000 UTC
 peticiones 5 2014-07-16 17:58:37.534003928 +0000 UTC
 
-# For the second batch of requests we serve the first
-# 3 immediately because of the burstable rate limiting,
-# then serve the remaining 2 with ~200ms delays each.
 # Para el segundo bloque de peticiones, servimos los
 # primeros 3 inmediatamente usando el soporte de picos,
 # y luego servimos los 2 restantes con un retraso de 
diff --git a/examples/mapas/mapas.go b/examples/mapas/mapas.go
index 9558d8511..cf6ff30de 100644
--- a/examples/mapas/mapas.go
+++ b/examples/mapas/mapas.go
@@ -11,42 +11,36 @@ func main() {
     // `make(map[key-type]val-type)`.
     m := make(map[string]int)
 
-    // Se pueden establecer los pares de llaves/valores utilizando
+    // Se pueden establecer los pares de clave/valor utilizando
     // la sintaxis típica `name[key] = val`.
     m["k1"] = 7
     m["k2"] = 13
 
     // Si se presenta el mapa con e.g. `Println` se muestran
-    // todos sus pares de llaves/valores.
+    // todos sus pares de clave/valor.
     fmt.Println("map:", m)
 
-    // Se obtiene el valor de una llave con la sintaxis `name[key]`.
+    // Se obtiene el valor de una clave con la sintaxis `name[key]`.
     v1 := m["k1"]
     fmt.Println("v1: ", v1)
 
-    // La función `len` regresa el número de pares llave/valor cuando
+    // La función `len` regresa el número de pares clave/valor cuando
     // se utiliza con un mapa.
     fmt.Println("len:", len(m))
 
-    // La función `delete` elimina pares llave/valor de un mapa.
+    // La función `delete` elimina pares clave/valor de un mapa.
     delete(m, "k2")
     fmt.Println("map:", m)
-
-    // The optional second return value when getting a
-    // value from a map indicates if the key was present
-    // in the map. This can be used to disambiguate
-    // between missing keys and keys with zero values
-    // like `0` or `""`.
-
+    
     // El segundo valor de regreso (opcional) cuando obtienes un valor de
-    // el mapa indica si la llave etaba presente. Este valor puede
-    // ser usado para separar valores de llaves que no existen y
-    // valores de llaves con valor cero, como `0` o `""`.
+    // el mapa indica si la clave estaba presente. Este valor puede
+    // ser usado para separar valores de claves que no existen y
+    // valores de claves con valor cero, como `0` o `""`.
     _, prs := m["k2"]
     fmt.Println("prs:", prs)
 
     // También puedes declarar e inicializar un mapa nuevo
-    // en una sola línea con la sintaxis:
+    // en una única línea con la sintaxis:
     n := map[string]int{"foo": 1, "bar": 2}
     fmt.Println("map:", n)
 }
diff --git a/examples/multiples-valores-de-retorno/multiples-valores-de-retorno.go b/examples/multiples-valores-de-retorno/multiples-valores-de-retorno.go
index 364f8e1e0..aac89a089 100644
--- a/examples/multiples-valores-de-retorno/multiples-valores-de-retorno.go
+++ b/examples/multiples-valores-de-retorno/multiples-valores-de-retorno.go
@@ -21,7 +21,7 @@ func main() {
     fmt.Println(a)
     fmt.Println(b)
 
-    // Si solo quieres utilizar uno de los valores que regresa la
+    // Si sólo quieres utilizar uno de los valores que regresa la
     // función, puedes utilizar el identificador vacío `_`.
     _, c := vals()
     fmt.Println(c)
diff --git a/examples/mutexes/mutexes.go b/examples/mutexes/mutexes.go
index 9661d404f..fdca66b87 100644
--- a/examples/mutexes/mutexes.go
+++ b/examples/mutexes/mutexes.go
@@ -42,7 +42,7 @@ func main() {
                 // método `Lock()` del mutex, leemos
                 // el valor de la llave elegida,
                 // desbloqueamos el mutex llamando a `Unlock()`
-                // e incrementamos el contador `ops`
+                // e incrementamos el contador `ops`.
                 llave := rand.Intn(5)
                 mutex.Lock()
                 total += estado[llave]
@@ -50,9 +50,9 @@ func main() {
                 atomic.AddInt64(&ops, 1)
 
                 // Para asegurar que esta gorutina
-                // no asfixie al scheduler, vamos a ceder
-                // explicitamente después de cada operación
-                // llamando `runtime.Gosched()`. Este "ceder"
+                // no asfixie al [_scheduler_](https://es.wikipedia.org/wiki/Planificador), vamos a ceder
+                // explícitamente después de cada operación
+                // llamando `runtime.Gosched()`. Este "cede"
                 // es manejado automáticamente con operaciones
                 // en canales y al realizar llamadas
                 // bloqueantes como `time.Sleep`, pero en
@@ -86,7 +86,7 @@ func main() {
     opsFinal := atomic.LoadInt64(&ops)
     fmt.Println("ops:", opsFinal)
 
-    // Hacemo un bloqueo final del `estado` y mostramos como
+    // Hacemo un bloqueo final del `estado` y mostramos cómo
     // terminó
     mutex.Lock()
     fmt.Println("estado:", estado)
diff --git a/examples/mutexes/mutexes.sh b/examples/mutexes/mutexes.sh
index 705320463..0d9327a04 100644
--- a/examples/mutexes/mutexes.sh
+++ b/examples/mutexes/mutexes.sh
@@ -5,6 +5,6 @@ $ go run mutexes.go
 ops: 3598302
 state: map[1:38 4:98 2:23 3:85 0:44]
 
-# A continuación veremos como impleentar el mismo 
+# A continuación veremos cómo implementar el mismo 
 # manejo de estado usando solamente gorutinas y
 # canales.
diff --git a/examples/operaciones-sobre-canales-sin-bloqueo/operaciones-sobre-canales-sin-bloqueo.go b/examples/operaciones-sobre-canales-sin-bloqueo/operaciones-sobre-canales-sin-bloqueo.go
index 3a24ecbcc..5fc1da002 100644
--- a/examples/operaciones-sobre-canales-sin-bloqueo/operaciones-sobre-canales-sin-bloqueo.go
+++ b/examples/operaciones-sobre-canales-sin-bloqueo/operaciones-sobre-canales-sin-bloqueo.go
@@ -1,7 +1,7 @@
 // Los envíos y recepciones básicos sobre un canal lo
 // bloquean. Sin embargo, podemos usar la cláusula
 // `select` con un cláusula `default` para implementar
-// envios y recepciones sin bloqueo (non-blocking) e
+// envíos y recepciones sin bloqueo (non-blocking) e
 // incluso `select`s multi-vía sin bloqueo.
 package main
 
@@ -13,7 +13,7 @@ func main() {
 
     // Aquí hay un envío sin bloqueo. Si hay algún valor
     // disponible en `messages` entonces el `select`
-    // tomará el `case` `<-messages` con ese valor. Sino
+    // tomará el `case` `<-messages` con ese valor. Si no,
     // tomará inmediatamente el `case` `default`.
     select {
     case msg := <-messages:
@@ -32,8 +32,8 @@ func main() {
     }
 
     // Podemos usar múltiples `case` encima del `default`
-    // para implementar un `select` multi-via sin bloqueo.
-    // Aqui intentamos una recepción sin bloqueo
+    // para implementar un `select` multi-vía sin bloqueo.
+    // Aquí intentamos una recepción sin bloqueo
     // `messages` y `signals`.
     select {
     case msg := <-messages:
diff --git a/examples/pool-de-trabajadores/pool-de-trabajadores.go b/examples/pool-de-trabajadores/pool-de-trabajadores.go
index c8d61795c..17b88186f 100644
--- a/examples/pool-de-trabajadores/pool-de-trabajadores.go
+++ b/examples/pool-de-trabajadores/pool-de-trabajadores.go
@@ -1,5 +1,5 @@
-// En este ejemplo veremos como implementar un
-// _pool de trabajadores_  usando goroutines y canales.
+// En este ejemplo veremos cómo implementar un
+// _pool de trabajadores_ usando goroutines y canales.
 
 package main
 
@@ -25,7 +25,7 @@ func main() {
 
     // Para usar nuestro pool de trabajadores necesitamos
     // enviarles trabajo y recolectar sus resultados.
-    // Hacemos dos canales para esto.
+    // Creamos dos canales para esto.
     jobs := make(chan int, 100)
     results := make(chan int, 100)
 
@@ -36,7 +36,7 @@ func main() {
     }
 
     // Aquí envíamos 9 _trabajos_ por el canal `jobs` y
-    // luego lo cerramos para indicar que ya hay más
+    // luego lo cerramos para indicar que ya no hay más
     // trabajo por procesar.
     for j := 1; j <= 9; j++ {
         jobs <- j
diff --git a/examples/pool-de-trabajadores/pool-de-trabajadores.sh b/examples/pool-de-trabajadores/pool-de-trabajadores.sh
index 72e62e1fd..ce507c632 100644
--- a/examples/pool-de-trabajadores/pool-de-trabajadores.sh
+++ b/examples/pool-de-trabajadores/pool-de-trabajadores.sh
@@ -1,7 +1,7 @@
 # La salida de nuestro programa muestra que 9 trabajos
 # son ejecutados por varios trabajadores. El programa
-# solo toma cerca de 3 segundos a pesar de que 
-# realiza cerca de 9 segundos de trabajo total porque
+# solo necesita cerca de 3 segundos para realizar 
+# cerca de 9 segundos de trabajo total, ya que
 # hay 3 trabajadores operando de manera concurrente.
 $ time go run examples/worker-pools/worker-pools.go  
 trabajador 1 procesando trabajo 1
diff --git a/examples/range-sobre-canales/range-sobre-canales.go b/examples/range-sobre-canales/range-sobre-canales.go
index 820495a8e..03f81070e 100644
--- a/examples/range-sobre-canales/range-sobre-canales.go
+++ b/examples/range-sobre-canales/range-sobre-canales.go
@@ -16,7 +16,7 @@ func main() {
     // recibido desde `queue`. Debido a que llamamos a
     // `close` arriba, la iteración termina después de
     // recibir los 2 elementos. Si no lo cerramos
-    // entoneces bloqueariamos esperando por un tercer
+    // entonces bloquearíamos esperando por un tercer
     // elemento en la iteración.
     for elem := range queue {
         fmt.Println(elem)
diff --git a/examples/range-sobre-canales/range-sobre-canales.sh b/examples/range-sobre-canales/range-sobre-canales.sh
index d9ca9c72b..9ade3da41 100644
--- a/examples/range-sobre-canales/range-sobre-canales.sh
+++ b/examples/range-sobre-canales/range-sobre-canales.sh
@@ -2,6 +2,6 @@ $ go run range-sobre-canales.go
 uno
 dos
 
-# Este ejemplo también mostro como es posible cerrar
+# Este ejemplo también muestra cómo es posible cerrar
 # un canal que no está vacío y aún conservar los
 # valores que no se han recibido.
diff --git a/examples/range/range.go b/examples/range/range.go
index a2c175fb6..c16c85db4 100644
--- a/examples/range/range.go
+++ b/examples/range/range.go
@@ -8,7 +8,7 @@ import "fmt"
 
 func main() {
 
-    // Aquí utilizamos `range` para sumar los numeros de un slice.
+    // Aquí utilizamos `range` para sumar los números de un slice.
     // En los arreglos funciona de manera similar.
     nums := []int{2, 3, 4}
     sum := 0
@@ -20,8 +20,8 @@ func main() {
     // Cuando se usa `range` en un arreglo o slice, se obtiene
     // el valor del elemento y el índice donde se encuentra.
     // En el ejemplo anterior no utilizamos el índice, así que
-    // lo ignoramos asignandolo a un _identificador vacío_, `_`.
-    // Sin embargo, en algunas ocasiones si vamos a necesitar los índices.
+    // lo ignoramos asignándolo a un _identificador vacío_, `_`.
+    // Sin embargo, en algunas ocasiones sí vamos a necesitar los índices.
     for i, num := range nums {
         if num == 3 {
             fmt.Println("index:", i)
@@ -29,7 +29,7 @@ func main() {
     }
 
     // Al utilizar `range` en un mapa, este itera por
-    // los pares llave/valor.
+    // los pares clave/valor.
     kvs := map[string]string{"a": "apple", "b": "banana"}
     for k, v := range kvs {
         fmt.Printf("%s -> %s\n", k, v)
@@ -37,7 +37,7 @@ func main() {
 
     // Si se utiliza `range` en una cadena, se itera por los
     // caracteres Unicode de la misma. El primer valor es
-    // el índice del byte inicial de el primer símbolo y el
+    // el índice del byte inicial del primer símbolo y el
     // símbolo mismo.
     for i, c := range "go" {
         fmt.Println(i, c)
diff --git a/examples/recursion/recursion.go b/examples/recursion/recursion.go
index 36e8a82dd..1aba04241 100644
--- a/examples/recursion/recursion.go
+++ b/examples/recursion/recursion.go
@@ -4,7 +4,7 @@
 
 package main
 
-// Esta función `fact` se llama a si misma hasta que llega a la
+// Esta función `fact` se llama a sí misma hasta que llega a la
 // base de `fact(0)`.
 func fact(n int) int {
     if n == 0 {
diff --git a/examples/select/select.go b/examples/select/select.go
index 202d1e53a..806396a9d 100644
--- a/examples/select/select.go
+++ b/examples/select/select.go
@@ -14,7 +14,7 @@ func main() {
     c1 := make(chan string)
     c2 := make(chan string)
 
-    // Cada canal va a recibir un valor despues de cierto tiempo,
+    // Cada canal va a recibir un valor después de cierto tiempo,
     // para simular operaciónes bloqueadas de procesos externos
     // en goroutines concurrentes.
     go func() {
diff --git a/examples/sincronizacion-de-canales/sincronizacion-de-canales.go b/examples/sincronizacion-de-canales/sincronizacion-de-canales.go
index 59f1a88e7..1edbaf542 100644
--- a/examples/sincronizacion-de-canales/sincronizacion-de-canales.go
+++ b/examples/sincronizacion-de-canales/sincronizacion-de-canales.go
@@ -27,7 +27,7 @@ func main() {
     terminado := make(chan bool, 1)
     go trabajo(terminado)
 
-    // Hay un bloqueo hasta que recibimos la notificacion
+    // Hay un bloqueo hasta que recibimos la notificación
     // de trabajo en el canal.
     <-terminado
 }
diff --git a/examples/slices/slices.go b/examples/slices/slices.go
index 5dffd40e9..8035352ef 100644
--- a/examples/slices/slices.go
+++ b/examples/slices/slices.go
@@ -26,9 +26,9 @@ func main() {
     fmt.Println("len:", len(s))
 
     // Aparte de estas operaciones básicas, los slices
-    // soportan muchas mas que los hacen más funcionales
+    // soportan muchas más que los hacen más funcionales
     // que los arreglos. Una de ellas es `append`, la que
-    // regresa un slice que contiene uno o mas valores nuevos.
+    // regresa un slice que contiene uno o más valores nuevos.
     // Nota que necesitamos asignar el valor de regreso de
     // append tal como lo haríamos con el valor de un slice nuevo.
     s = append(s, "d")
diff --git a/examples/structs/structs.go b/examples/structs/structs.go
index 99f0eb3b5..dd7ab39f5 100644
--- a/examples/structs/structs.go
+++ b/examples/structs/structs.go
@@ -5,7 +5,7 @@ package main
 
 import "fmt"
 
-// El struct `persona` tiene los campos `nombre` y edad.
+// El struct `persona` tiene los campos `nombre` y `edad`.
 type persona struct {
     nombre string
     edad   int
@@ -16,7 +16,7 @@ func main() {
     // Esta sintaxis crea una instancia de un struct.
     fmt.Println(persona{"Bob", 20})
 
-    // Puedes nombrear los campos cuando inicializas un struct.
+    // Puedes definir los valores de los campos cuando inicializas un struct.
     fmt.Println(persona{name: "Alice", age: 30})
 
     // Los campos omitidos serán de valor cero.
@@ -34,7 +34,7 @@ func main() {
     sp := &s
     fmt.Println(sp.age)
 
-    // los Structs son inmutables.
+    // Los Structs son inmutables.
     sp.age = 51
     fmt.Println(sp.age)
 }
diff --git a/examples/temporizadores/temporizadores.go b/examples/temporizadores/temporizadores.go
index 5c77d24e1..5de1d16ce 100644
--- a/examples/temporizadores/temporizadores.go
+++ b/examples/temporizadores/temporizadores.go
@@ -12,8 +12,8 @@ import "fmt"
 func main() {
 
     // Los temporizadores representan un evento único en
-    // el futuro. Tu le dices al temporizador cuánto tiempo
-    // quieres esperar, y el te proporcionará un canal que
+    // el futuro. Tú le dices al temporizador cuánto tiempo
+    // quieres esperar, y él te proporcionará un canal que
     // será notificado en ese momento. Este temporizador
     // esperará 2 segundos.
     timer1 := time.NewTimer(time.Second * 2)
diff --git a/examples/tickers/tickers.go b/examples/tickers/tickers.go
index 5708a3cf2..c4b95cd0f 100644
--- a/examples/tickers/tickers.go
+++ b/examples/tickers/tickers.go
@@ -1,9 +1,9 @@
 // Los [temporizadores](temporizadores) se usan cuando
 // quieres hacer una cosa en el futuro - los _tickers_
-// ( por aquello de tic tac ) - se usan cuando se quiere
+// (por aquello de tic tac) - se usan cuando se quiere
 // hacer algo repetidamente en intervalos regulares.
 // Aquí hay un ejemplo de un ticker que hace tic
-// periodicamente hasta que lo detenemos.
+// periódicamente hasta que lo detenemos.
 
 package main
 
@@ -13,9 +13,9 @@ import "fmt"
 func main() {
 
     // Los tickers usan un mecanismo similar a los
-    // temporizadores: un canal el que se le envían
+    // temporizadores: un canal al que se le envían
     // valores. Aquí vamos a usar el builtin `range` en
-    // el canal para iterar cada 500ms. los valores
+    // el canal para iterar cada 500ms los valores
     // conforme van llegando.
     ticker := time.NewTicker(time.Millisecond * 500)
     go func() {
diff --git a/examples/tiempo-de-espera/timeouts.go b/examples/tiempo-de-espera/timeouts.go
index 62b18c578..285ed5f7f 100644
--- a/examples/tiempo-de-espera/timeouts.go
+++ b/examples/tiempo-de-espera/timeouts.go
@@ -22,10 +22,10 @@ func main() {
 
     // Aquí tenemos el `select` implementando un tiempo de espera.
     // `res := <-c1` espera el resultado y `<-Time.After`
-    // espera el valor que será enviado después de el tiempo de
+    // espera el valor que será enviado después del tiempo de
     // espera de 1s. Como `select` procede con el primer mensaje
     // recibido que esté listo, tomaremos el caso del tiempo de
-    // espera si la operación toma mas de el tiempo permitido (1s).
+    // espera si la operación toma más tiempo del permitido (1s).
     select {
     case res := <-c1:
         fmt.Println(res)
diff --git a/examples/tiempo-de-espera/timeouts.sh b/examples/tiempo-de-espera/timeouts.sh
index bd8cdb25f..e1e498981 100644
--- a/examples/tiempo-de-espera/timeouts.sh
+++ b/examples/tiempo-de-espera/timeouts.sh
@@ -5,7 +5,7 @@ $ go run tiempo-de-espera.go
 tiempo de espera 1
 resultado 2
 
-# Utilizar este patron de `select` requiere comunicar
+# Utilizar este patrón de `select` requiere comunicar
 # resultados a través de canales. Esta es una buena
 # idea en general porque otras características importantes
 # de Go están basadas en canales y `select`. Vamos a ver