Corregidas algunas faltas y tildes

examples.txt

@@ -10,20 +10,20 @@ 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
 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

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) {

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

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

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.

examples/cerrando-canales/cerrando-canales.go

@@ -1,21 +1,21 @@
 // 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`.
 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
 }

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)
 }

examples/direccion-de-canales/direccion-de-canales.go

@@ -1,13 +1,13 @@
 // 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.
 
 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) {

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 {

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, " ")

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
 }

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)

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.

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 

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)
 }

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)

examples/mutexes/mutexes.go

@@ -42,17 +42,17 @@ 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]
                 mutex.Unlock()
                 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)

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.