Merge pull request #1 from adambard/master

update

1 files changed, 371 insertions, 247 deletions

diff --git a/es-es/go-es.html.markdown b/es-es/go-es.html.markdown
index 86de33ec..78267695 100644
--- a/es-es/go-es.html.markdown
+++ b/es-es/go-es.html.markdown
@@ -1,326 +1,450 @@
 ---
+name: Go
+category: language
 language: Go
 lang: es-es
 filename: learngo-es.go
 contributors:
     - ["Sonia Keys", "https://github.com/soniakeys"]
+    - ["Christopher Bess", "https://github.com/cbess"]
+    - ["Jesse Johnson", "https://github.com/holocronweaver"]
+    - ["Quint Guvernator", "https://github.com/qguv"]
+    - ["Jose Donizetti", "https://github.com/josedonizetti"]
+    - ["Alexej Friesen", "https://github.com/heyalexej"]
 translators:
     - ["Adrian Espinosa", "http://www.adrianespinosa.com"]
     - ["Jesse Johnson", "https://github.com/holocronweaver"]
+    - ["Nacho Pacheco -- Feb/2015", "https://github.com/gitnacho"]
 ---
 
-Go fue creado por la necesidad de hacer el trabajo rápidamente.  No es
-la última tendencia en informática, pero es la forma nueva y más
-rápida de resolver problemas reales.
+Go fue creado por la necesidad de hacer el trabajo rápidamente. No es la
+última tendencia en informática, pero es la forma nueva y más rápida de
+resolver problemas reales.
 
-Tiene conceptos familiares de lenguajes imperativos con tipado
-estático.  Es rápido compilando y rápido al ejecutar, añade una
-concurrencia fácil de entender para las CPUs de varios núcleos de hoy
-en día, y tiene características que ayudan con la programación a gran
-escala.
+Tiene conceptos familiares de lenguajes imperativos con tipado estático.
+Es rápido compilando y rápido al ejecutar, añade una concurrencia fácil de
+entender para las CPUs de varios núcleos de hoy día, y tiene
+características que ayudan con la programación a gran escala.
 
-Go viene con una librería estándar muy buena y una comunidad entusiasta.
+Go viene con una biblioteca estándar muy buena y una comunidad entusiasta.
 
 ```go
 // Comentario de una sola línea
-/* Comentario 
-   multi línea */
+/* Comentario
+   multilínea */
 
-// La cláusula package aparece al comienzo de cada archivo fuente.
-// Main es un nombre especial que declara un ejecutable en vez de una librería.
+// La cláusula `package` aparece al comienzo de cada fichero fuente.
+// `main` es un nombre especial que declara un ejecutable en vez de una
+// biblioteca.
 package main
 
-// La declaración Import declara los paquetes de librerías
-// referenciados en este archivo.
+// La instrucción `import` declara los paquetes de bibliotecas referidos
+// en este fichero.
 import (
-    "fmt"      // Un paquete en la librería estándar de Go.
-    "net/http" // Sí, un servidor web!
-    "strconv"  // Conversiones de cadenas.
-    m "math"   // Librería matemáticas con alias local m.
+	"fmt"      // Un paquete en la biblioteca estándar de Go.
+	"io/ioutil" // Implementa algunas útiles funciones de E/S.
+	m "math"   // Biblioteca de matemáticas con alias local m.
+	"net/http" // Sí, ¡un servidor web!
+	"strconv"  // Conversiones de cadenas.
 )
 
-// Definición de una función. Main es especial.  Es el punto de
-// entrada para el ejecutable.  Te guste o no, Go utiliza llaves.
+// Definición de una función. `main` es especial. Es el punto de entrada
+// para el ejecutable. Te guste o no, Go utiliza llaves.
 func main() {
-    // Println imprime una línea a stdout.
-    // Cualificalo con el nombre del paquete, fmt.
-    fmt.Println("Hello world!")
+	// Println imprime una línea a stdout.
+	// Llámalo con el nombre del paquete, fmt.
+	fmt.Println("¡Hola mundo!")
 
-    // Llama a otra función de este paquete.
-    beyondHello()
+	// Llama a otra función de este paquete.
+	másAlláDelHola()
 }
 
 // Las funciones llevan parámetros entre paréntesis.
 // Si no hay parámetros, los paréntesis siguen siendo obligatorios.
-func beyondHello() {
-    var x int // Declaración de una variable.
-              // Las variables se deben declarar antes de utilizarlas.
-    x = 3     // Asignación de variables.
-    // Declaración "corta" con := para inferir el tipo, declarar y asignar.
-    y := 4
-    sum, prod := learnMultiple(x, y)        // Función devuelve dos valores.
-    fmt.Println("sum:", sum, "prod:", prod) // Simple salida.
-    learnTypes()                            // < y minutes, learn more!
+func másAlláDelHola() {
+	var x int // Declaración de una variable.
+ 	          // Las variables se deben declarar antes de utilizarlas.
+	x = 3     // Asignación de variable.
+	// Declaración "corta" con := para inferir el tipo, declarar y asignar.
+	y := 4
+	suma, producto := aprendeMúltiple(x, y) // La función devuelve dos
+											// valores.
+	fmt.Println("suma:", suma, "producto:", producto) // Simple salida.
+	aprendeTipos()                        // < y minutos, ¡aprende más!
 }
 
-// Las funciones pueden tener parámetros y (múltiples!) valores de retorno.
-func learnMultiple(x, y int) (sum, prod int) {
-    return x + y, x * y // Devolver dos valores.
+// Las funciones pueden tener parámetros y (¡múltiples!) valores de
+// retorno.
+func aprendeMúltiple(x, y int) (suma, producto int) {
+    return x + y, x * y // Devuelve dos valores.
 }
 
 // Algunos tipos incorporados y literales.
-func learnTypes() {
-    // La declaración corta suele darte lo que quieres.
-    s := "Learn Go!" // tipo cadena
-
-    s2 := ` Un tipo cadena "puro" puede incluir
+func aprendeTipos() {
+	// La declaración corta suele darte lo que quieres.
+	s := "¡Aprende Go!" // tipo cadena.
+	s2 := `Un tipo cadena "puro" puede incluir
 saltos de línea.` // mismo tipo cadena
 
-    // Literal no ASCII. Los fuentes de Go son UTF-8.
-    g := 'Σ' // Tipo rune, un alias de int32, alberga un punto unicode.
-    f := 3.14195 // float64, el estándar IEEE-754 de coma flotante 64-bit.
-    c := 3 + 4i  // complex128, representado internamente por dos float64.
-    // Sintaxis Var con inicializadores.
-    var u uint = 7 // Sin signo, pero la implementación depende del
-                   // tamaño como en int.
-    var pi float32 = 22. / 7
-
-    // Sintáxis de conversión con una declaración corta.
-    n := byte('\n') // byte es un alias de uint8.
-
-    // Los Arrays tienen un tamaño fijo a la hora de compilar.
-    var a4 [4]int           // Un array de 4 ints, inicializados a 0.
-    a3 := [...]int{3, 1, 5} // Un array de 3 ints, inicializados como se indica.
-
-    // Los Slices tienen tamaño dinámico. Los arrays y slices tienen sus ventajas
-    // y desventajas pero los casos de uso para los slices son más comunes.
-    s3 := []int{4, 5, 9}    // Comparar con a3. No hay puntos suspensivos.
-    s4 := make([]int, 4)    // Asigna slices de 4 ints, inicializados a 0.
-    var d2 [][]float64      // Solo declaración, sin asignación.
-    bs := []byte("a slice") // Sintaxis de conversión de tipo.
-
-    p, q := learnMemory() // Declara p, q para ser un tipo puntero a int.
-    fmt.Println(*p, *q)   // * sigue un puntero. Esto imprime dos ints.
-
-    // Los Maps son arrays asociativos dinámicos, como los hash o
-    // diccionarios de otros lenguajes.
-    m := map[string]int{"three": 3, "four": 4}
-    m["one"] = 1
-
-    // Las variables no utilizadas en Go producen error.
-    // El guión bajo permite "utilizar" una variable, pero descartar su valor.
-    _, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs
-    // Esto cuenta como utilización de variables.
-    fmt.Println(s, c, a4, s3, d2, m)
-
-    learnFlowControl() // Vuelta al flujo.
+	// Literal no ASCII. Los ficheros fuente de Go son UTF-8.
+	g := 'Σ' // Tipo rune, un alias de int32, alberga un carácter unicode.
+	f := 3.14195 // float64, el estándar IEEE-754 de coma flotante 64-bit.
+	c := 3 + 4i  // complex128, representado internamente por dos float64.
+	// Sintaxis var con iniciadores.
+	var u uint = 7 // Sin signo, pero la implementación depende del tamaño
+	               // como en int.
+	var pi float32 = 22. / 7
+
+	// Sintaxis de conversión con una declaración corta.
+	n := byte('\n') // byte es un alias para uint8.
+
+	// Los Arreglos tienen un tamaño fijo a la hora de compilar.
+	var a4 [4]int           // Un arreglo de 4 ints, iniciados a 0.
+	a3 := [...]int{3, 1, 5} // Un arreglo iniciado con un tamaño fijo de tres
+							// elementos, con valores 3, 1 y 5.
+	// Los Sectores tienen tamaño dinámico. Los arreglos y sectores tienen
+	// sus ventajas y desventajas pero los casos de uso para los sectores
+	// son más comunes.
+	s3 := []int{4, 5, 9}     // Comparar con a3. No hay puntos suspensivos.
+	s4 := make([]int, 4)     // Asigna sectores de 4 ints, iniciados a 0.
+	var d2 [][]float64       // Solo declaración, sin asignación.
+	bs := []byte("a sector") // Sintaxis de conversión de tipo.
+	// Debido a que son dinámicos, los sectores pueden crecer bajo demanda.
+	// Para añadir elementos a un sector, se utiliza la función incorporada
+	// append().
+	// El primer argumento es el sector al que se está anexando. Comúnmente,
+	// la variable del arreglo se actualiza en su lugar, como en el 
+	// siguiente ejemplo.
+	sec := []int{1, 2 , 3}      // El resultado es un sector de longitud 3.
+	sec = append(sec, 4, 5, 6)  // Añade 3 elementos. El sector ahora tiene una
+								// longitud de 6.
+	fmt.Println(sec) // El sector actualizado ahora es [1 2 3 4 5 6]
+	// Para anexar otro sector, en lugar de la lista de elementos atómicos
+	// podemos pasar una referencia a un sector o un sector literal como
+	// este, con elipsis al final, lo que significa tomar un sector y
+	// desempacar sus elementos, añadiéndolos al sector sec.
+	sec = append(sec, []int{7, 8, 9} ...) // El segundo argumento es un
+										  // sector literal.
+	fmt.Println(sec)  // El sector actualizado ahora es [1 2 3 4 5 6 7 8 9]
+	p, q := aprendeMemoria() // Declara p, q para ser un tipo puntero a
+							 // int.
+	fmt.Println(*p, *q)      // * sigue un puntero. Esto imprime dos ints.
+
+	// Los Mapas son arreglos asociativos dinámicos, como los hash o
+	// diccionarios de otros lenguajes.
+	m := map[string]int{"tres": 3, "cuatro": 4}
+	m["uno"] = 1
+
+	// Las variables no utilizadas en Go producen error.
+	// El guión bajo permite "utilizar" una variable, pero descartar su
+	// valor.
+	_, _, _, _, _, _, _, _, _ = s2, g, f, u, pi, n, a3, s4, bs
+	// Esto cuenta como utilización de variables.
+	fmt.Println(s, c, a4, s3, d2, m)
+
+	aprendeControlDeFlujo() // Vuelta al flujo.
+}
+
+// Es posible, a diferencia de muchos otros lenguajes tener valores de
+// retorno con nombre en las funciones.
+// Asignar un nombre al tipo que se devuelve en la línea de declaración de
+// la función nos permite volver fácilmente desde múltiples puntos en una
+// función, así como sólo utilizar la palabra clave `return`, sin nada
+// más.
+func aprendeRetornosNombrados(x, y int) (z int) {
+	z = x * y
+	return // aquí z es implícito, porque lo nombramos antes.
 }
 
-// Go posee recolector de basura. Tiene puntero pero no aritmética de
-// punteros.  Puedes cometer un errores con un puntero nil, pero no
+// Go posee recolector de basura. Tiene punteros pero no aritmética de
+// punteros. Puedes cometer errores con un puntero nil, pero no
 // incrementando un puntero.
-func learnMemory() (p, q *int) {
-    // q y p tienen un tipo puntero a int.
-    p = new(int) // Función incorporada que asigna memoria.
-    // La asignación de int se inicializa a 0, p ya no es nil.
-    s := make([]int, 20) // Asigna 20 ints a un solo bloque de memoria.
-    s[3] = 7             // Asignar uno de ellos.
-    r := -2              // Declarar otra variable local.
-    return &s[3], &r     // & toma la dirección de un objeto.
+func aprendeMemoria() (p, q *int) {
+	// Los valores de retorno nombrados q y p tienen un tipo puntero
+	// a int.
+	p = new(int) // Función incorporada que reserva memoria.
+	// La asignación de int se inicia a 0, p ya no es nil.
+	s := make([]int, 20) // Reserva 20 ints en un solo bloque de memoria.
+	s[3] = 7             // Asigna uno de ellos.
+	r := -2              // Declara otra variable local.
+	return &s[3], &r     // & toma la dirección de un objeto.
 }
 
-func expensiveComputation() float64 {
-    return m.Exp(10)
+func cálculoCaro() float64 {
+	return m.Exp(10)
 }
 
-func learnFlowControl() {
-    // La declaración If requiere llaves, pero no paréntesis.
-    if true {
-        fmt.Println("told ya")
-    }
-    // El formato está estandarizado por el comando "go fmt."
-    if false {
-        // Pout.
-    } else {
-        // Gloat.
-    }
-    // Utiliza switch preferiblemente para if encadenados.
-    x := 42.0
-    switch x {
-    case 0:
-    case 1:
-    case 42:
-        // Los cases no se mezclan, no requieren de "break".
-    case 43:
-        // No llega.
+func aprendeControlDeFlujo() {
+	// La declaración If requiere llaves, pero no paréntesis.
+	if true {
+		fmt.Println("ya relatado")
+	}
+	// El formato está estandarizado por la orden "go fmt."
+	if false {
+		// Abadejo.
+	} else {
+		// Relamido.
+	}
+	// Utiliza switch preferentemente para if encadenados.
+	x := 42.0
+	switch x {
+	case 0:
+	case 1:
+	case 42:
+		// Los cases no se mezclan, no requieren de "break".
+	case 43:
+		// No llega.
+	}
+	// Como if, for no utiliza paréntesis tampoco.
+	// Variables declaradas en for e if son locales a su ámbito.
+	for x := 0; x < 3; x++ { // ++ es una instrucción.
+		fmt.Println("iteración", x)
+	}
+	// aquí x == 42.
+
+	// For es la única instrucción de bucle en Go, pero tiene formas
+	// alternativas.
+	for { // Bucle infinito.
+		break    // ¡Solo bromeaba!
+		continue // No llega.
+	}
+
+	// Puedes usar `range` para iterar en un arreglo, un sector, una
+	// cadena, un mapa o un canal.
+	// `range` devuelve o bien, un canal o de uno a dos valores (arreglo,
+	// sector, cadena y mapa).
+	for clave, valor := range map[string]int{"uno": 1, "dos": 2, "tres": 3} {
+		// por cada par en el mapa, imprime la clave y el valor
+		fmt.Printf("clave=%s, valor=%d\n", clave, valor)
+	}
+
+	// Como en for, := en una instrucción if significa declarar y asignar
+	// primero, luego comprobar y > x.
+	if y := cálculoCaro(); y > x {
+		x = y
     }
-    // Como if, for no utiliza paréntesis tampoco.
-    // Variables declaradas en for y if son locales de su ámbito local.
-    for x := 0; x < 3; x++ { // ++ es una sentencia.
-        fmt.Println("iteration", x)
-    }
-    // x == 42 aqui.
+	// Las funciones literales son "cierres".
+	granX := func() bool {
+		return x > 100 // Referencia a x declarada encima de la instrucción
+							// switch.
+	}
+	fmt.Println("granX:", granX()) // cierto (la última vez asignamos
+											 // 1e6 a x).
+	x /= 1.3e3                   // Esto hace a x == 1300
+	fmt.Println("granX:", granX()) // Ahora es falso.
+
+	// Es más las funciones literales se pueden definir y llamar en línea,
+	// actuando como un argumento para la función, siempre y cuando:
+	// a) la función literal sea llamada inmediatamente (),
+	// b) el tipo del resultado sea del tipo esperado del argumento
+	fmt.Println("Suma dos números + doble: ",
+		func(a, b int) int {
+			return (a + b) * 2
+		}(10, 2)) // Llamada con argumentos 10 y 2
+	// => Suma dos números + doble: 24
+
+	// Cuando lo necesites, te encantará.
+	goto encanto
+encanto:
+
+	aprendeFunciónFábrica() // func devolviendo func es divertido(3)(3)
+	aprendeADiferir()       // Un rápido desvío a una importante palabra clave.
+	aprendeInterfaces()     // ¡Buen material dentro de poco!
+}
 
-    // For es la única sentencia de bucle en Go, pero tiene formas alternativas.
-    for { // Bucle infinito.
-        break    // Solo bromeaba!
-        continue // No llega.
-    }
-    // Como en for, := en una sentencia if significa declarar y asignar primero,
-    // luego comprobar y > x.
-    if y := expensiveComputation(); y > x {
-        x = y
-    }
-    // Los literales de funciones son "closures".
-    xBig := func() bool {
-        return x > 100 // Referencia a x declarada encima de la sentencia switch.
-    }
-    fmt.Println("xBig:", xBig()) // verdadero (la última vez asignamos 1e6 a x).
-    x /= m.Exp(9)                // Esto lo hace x == e.
-    fmt.Println("xBig:", xBig()) // Ahora es falso.
+func aprendeFunciónFábrica() {
+	// Las dos siguientes son equivalentes, la segunda es más práctica
+	fmt.Println(instrucciónFábrica("día")("Un bello", "de verano"))
+
+	d := instrucciónFábrica("atardecer")
+	fmt.Println(d("Un hermoso", "de verano"))
+	fmt.Println(d("Un maravilloso", "de verano"))
+}
 
-    // Cuando lo necesites, te encantará.
-    goto love
-love:
+// Los decoradores son comunes en otros lenguajes. Lo mismo se puede hacer
+// en Go con funciónes literales que aceptan argumentos.
+func instrucciónFábrica(micadena string) func(antes, después string) string {
+	return func(antes, después string) string {
+		return fmt.Sprintf("¡%s %s %s!", antes, micadena, después) // nueva cadena
+	}
+}
 
-    learnInterfaces() // Buen material dentro de poco!
+func aprendeADiferir() (ok bool) {
+	// las instrucciones diferidas se ejecutan justo antes de que la
+	// función regrese.
+	defer fmt.Println("las instrucciones diferidas se ejecutan en orden inverso (PEPS).")
+	defer fmt.Println("\nEsta línea se imprime primero debido a que")
+	// Defer se usa comunmente para cerrar un fichero, por lo que la
+	// función que cierra el fichero se mantiene cerca de la función que lo
+	// abrió.
+	return true
 }
 
 // Define Stringer como un tipo interfaz con un método, String.
 type Stringer interface {
-    String() string
+	String() string
 }
 
-// Define pair como un struct con dos campos int, x e y.
-type pair struct {
-    x, y int
+// Define par como una estructura con dos campos int, x e y.
+type par struct {
+	x, y int
 }
 
-// Define un método del tipo pair. Pair ahora implementa Stringer.
-func (p pair) String() string { // p se llama "recibidor"
-    // Sprintf es otra función pública del paquete fmt.
-    // La sintaxis con punto referencia campos de p.
-    return fmt.Sprintf("(%d, %d)", p.x, p.y)
+// Define un método en el tipo par. Par ahora implementa a Stringer.
+func (p par) String() string { // p se conoce como el "receptor"
+	// Sprintf es otra función pública del paquete fmt.
+	// La sintaxis con punto se refiere a los campos de p.
+	return fmt.Sprintf("(%d, %d)", p.x, p.y)
 }
 
-func learnInterfaces() {
-    // La sintaxis de llaves es un "literal struct". Evalúa a un struct
-    // inicializado.  La sintaxis := declara e inicializa p a este struct.
-    p := pair{3, 4}
-    fmt.Println(p.String()) // Llamar al método String de p, de tipo pair.
-    var i Stringer          // Declarar i como interfaz tipo Stringer.
-    i = p                   // Válido porque pair implementa Stringer.
-    // Llamar al metodo String de i, de tipo Stringer. Misma salida que arriba.
-    fmt.Println(i.String())
-
-    // Las funciones en el paquete fmt llaman al método String para
-    // preguntar a un objeto por una versión imprimible de si mismo.
-    fmt.Println(p) // Salida igual que arriba. Println llama al método String.
-    fmt.Println(i) // Salida igual que arriba.
-
-    learnVariadicParams("great", "learning", "here!")
+func aprendeInterfaces() {
+	// La sintaxis de llaves es una "estructura literal". Evalúa a una
+	// estructura iniciada. La sintaxis := declara e inicia p a esta
+	// estructura.
+	p := par{3, 4}
+	fmt.Println(p.String()) // Llama al método String de p, de tipo par.
+	var i Stringer          // Declara i como interfaz de tipo Stringer.
+	i = p                   // Válido porque par implementa Stringer.
+	// Llama al metodo String de i, de tipo Stringer. Misma salida que
+	// arriba.
+	fmt.Println(i.String())
+
+	// Las funciones en el paquete fmt llaman al método String para
+	// consultar un objeto por una representación imprimible de si
+	// mismo.
+	fmt.Println(p) // Salida igual que arriba. Println llama al método
+				   // String.
+	fmt.Println(i) // Salida igual que arriba.
+	aprendeNúmeroVariableDeParámetros("¡gran", "aprendizaje", "aquí!")
 }
 
 // Las funciones pueden tener número variable de argumentos.
-func learnVariadicParams(myStrings ...interface{}) {
-    // Iterar cada valor de la variadic.
-    for _, param := range myStrings {
-        fmt.Println("param:", param)
-    }
-    
-    // Pasar valor variadic como parámetro variadic.
-    fmt.Println("params:", fmt.Sprintln(myStrings...))
-
-    learnErrorHandling()
+func aprendeNúmeroVariableDeParámetros(misCadenas ...interface{}) {
+	// Itera en cada valor de los argumentos variables.
+	// El espacio en blanco aquí omite el índice del argumento arreglo.
+	for _, parámetro := range misCadenas {
+		fmt.Println("parámetro:", parámetro)
+	}
+
+	// Pasa el valor de múltiples variables como parámetro variadic.
+	fmt.Println("parámetros:", fmt.Sprintln(misCadenas...))
+	aprendeManejoDeError()
 }
 
-func learnErrorHandling() {
-    // ", ok" forma utilizada para saber si algo funcionó o no.
-    m := map[int]string{3: "three", 4: "four"}
-    if x, ok := m[1]; !ok { // ok será falso porque 1 no está en el map.
-        fmt.Println("no one there")
-    } else {
-        fmt.Print(x) // x sería el valor, si estuviera en el map.
-    }
-    // Un valor de error comunica más información sobre el problema aparte de "ok".
-    if _, err := strconv.Atoi("non-int"); err != nil { // _ descarta el valor
-        // Imprime "strconv.ParseInt: parsing "non-int": invalid syntax".
-        fmt.Println(err)
-    }
-    // Revisarmeos las interfaces más tarde. Mientras tanto,
-    learnConcurrency()
+func aprendeManejoDeError() {
+	// ", ok" forma utilizada para saber si algo funcionó o no.
+	m := map[int]string{3: "tres", 4: "cuatro"}
+	if x, ok := m[1]; !ok { // ok será falso porque 1 no está en el mapa.
+		fmt.Println("nada allí")
+	} else {
+		fmt.Print(x) // x sería el valor, si estuviera en el mapa.
+	}
+	// Un valor de error comunica más información sobre el problema aparte
+	// de "ok".
+	if _, err := strconv.Atoi("no-int"); err != nil { // _ descarta el
+																	  // valor
+		// Imprime "strconv.ParseInt: parsing "no-int": invalid syntax".
+		fmt.Println(err)
+	}
+	// Revisaremos las interfaces más adelante. Mientras tanto...
+	aprendeConcurrencia()
 }
 
-// c es un canal,  un objeto de comunicación de concurrencia segura.
+// c es un canal, un objeto de comunicación concurrente seguro.
 func inc(i int, c chan int) {
-    c <- i + 1 // <- es el operador "enviar" cuando un canal aparece a la izquierda.
+	c <- i + 1 // <- es el operador "enviar" cuando aparece un canal a la
+				  // izquierda.
 }
 
 // Utilizaremos inc para incrementar algunos números concurrentemente.
-func learnConcurrency() {
-    // Misma función make utilizada antes para crear un slice. Make asigna e
-    // inicializa slices, maps, y channels.
-    c := make(chan int)
-    // Iniciar tres goroutines concurrentes. Los números serán incrementados
-    // concurrentemente, quizás en paralelo si la máquina es capaz y
-    // está correctamente configurada. Las tres envían al mismo channel.
-    go inc(0, c) // go es una sentencia que inicia una nueva goroutine.
-    go inc(10, c)
-    go inc(-805, c)
-    // Leer los tres resultados del channel e imprimirlos.
-    // No se puede saber en que orden llegarán los resultados!
-    fmt.Println(<-c, <-c, <-c) // Channel a la derecha, <- es el operador "recibir".
-
-    cs := make(chan string)       // Otro channel, este gestiona cadenas.
-    ccs := make(chan chan string) // Un channel de cadenas de channels.
-    go func() { c <- 84 }()       // Iniciar una nueva goroutine solo para
-                                  // enviar un valor.
-    go func() { cs <- "wordy" }() // Otra vez, para cs en esta ocasión.
-    // Select tiene una sintáxis parecida a la sentencia switch pero
-    // cada caso involucra una operacion de channels. Selecciona un caso
-    // de forma aleatoria de los casos que están listos para comunicarse.
-    select {
-    case i := <-c: // El valor recibido puede ser asignado a una variable,
-        fmt.Printf("it's a %T", i)
-    case <-cs:     // o el valor puede ser descartado.
-        fmt.Println("it's a string")
-    case <-ccs:    // Channel vacío, no está listo para la comunicación.
-        fmt.Println("didn't happen.")
-    }
-
-    // En este punto un valor fue devuelvto de c o cs. Uno de las dos
-    // goroutines que se iniciaron se ha completado, la otrá permancerá
-    // bloqueada.
-
-    learnWebProgramming() // Go lo hace. Tu también quieres hacerlo.
+func aprendeConcurrencia() {
+	// Misma función make utilizada antes para crear un sector. Make asigna
+	// e inicia sectores, mapas y canales.
+	c := make(chan int)
+	// Inicia tres rutinasgo concurrentes. Los números serán incrementados
+	// concurrentemente, quizás en paralelo si la máquina es capaz y está
+	// correctamente configurada. Las tres envían al mismo canal.
+	go inc(0, c) // go es una instrucción que inicia una nueva rutinago.
+	go inc(10, c)
+	go inc(-805, c)
+	// Lee los tres resultados del canal y los imprime.
+	// ¡No se puede saber en que orden llegarán los resultados!
+	fmt.Println(<-c, <-c, <-c) // Canal a la derecha, <- es el operador
+										// "recibe".
+
+	cs := make(chan string)       // Otro canal, este gestiona cadenas.
+	ccs := make(chan chan string) // Un canal de canales cadena.
+	go func() { c <- 84 }()       // Inicia una nueva rutinago solo para
+											// enviar un valor.
+	go func() { cs <- "verboso" }() // Otra vez, para cs en esta ocasión.
+	// Select tiene una sintaxis parecida a la instrucción switch pero cada
+	// caso involucra una operación con un canal. Selecciona un caso de
+	// forma aleatoria de los casos que están listos para comunicarse.
+	select {
+	case i := <-c: // El valor recibido se puede asignar a una variable,
+		fmt.Printf("es un %T", i)
+	case <-cs:     // o el valor se puede descartar.
+		fmt.Println("es una cadena")
+	case <-ccs:    // Canal vacío, no está listo para la comunicación.
+		fmt.Println("no sucedió.")
+	}
+
+	// En este punto un valor fue devuelto de c o cs. Una de las dos
+	// rutinasgo que se iniciaron se ha completado, la otrá permancerá
+	// bloqueada.
+
+	aprendeProgramaciónWeb() // Go lo hace. Tú también quieres hacerlo.
 }
 
 // Una simple función del paquete http inicia un servidor web.
-func learnWebProgramming() {
-    // El primer parámetro de la direccinón TCP a la que escuchar.
-    // El segundo parámetro es una interfaz, concretamente http.Handler.
-    err := http.ListenAndServe(":8080", pair{})
-    fmt.Println(err) // no ignorar errores
+func aprendeProgramaciónWeb() {
+// El primer parámetro es la direccinón TCP a la que escuchar.
+	// El segundo parámetro es una interfaz, concretamente http.Handler.
+	go func() {
+		err := http.ListenAndServe(":8080", par{})
+		fmt.Println(err) // no ignora errores
+	}()
+	consultaAlServidor()
 }
 
-// Haz pair un http.Handler implementando su único método, ServeHTTP.
-func (p pair) ServeHTTP(w http.ResponseWriter, r *http.Request) {
-    // Servir datos con un método de http.ResponseWriter.
-    w.Write([]byte("You learned Go in Y minutes!"))
+// Hace un http.Handler de par implementando su único método, ServeHTTP.
+func (p par) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	// Sirve datos con un método de http.ResponseWriter.
+	w.Write([]byte("¡Aprendiste Go en Y minutos!"))
+}
+
+func consultaAlServidor() {
+	resp, err := http.Get("http://localhost:8080")
+	fmt.Println(err)
+	defer resp.Body.Close()
+	cuerpo, err := ioutil.ReadAll(resp.Body)
+	fmt.Printf("\nEl servidor web dijo: `%s`\n", string(cuerpo))
 }
 ```
 
-## Para leer más 
+## Más información
+
+La raíz de todas las cosas sobre Go es el
+[sitio web oficial de Go](http://golang.org/).
+Allí puedes seguir el tutorial, jugar interactivamente y leer mucho más.
 
-La raíz de todas las cosas de Go es la [web oficial de Go](http://golang.org/).
-Ahí puedes seguir el tutorial, jugar interactivamente y leer mucho.
+La definición del lenguaje es altamente recomendada.  Es fácil de leer y
+sorprendentemente corta (como la definición del lenguaje Go en estos
+días).
 
-La propia definición del lenguaje también está altamente
-recomendada. Es fácil de leer e increíblemente corta (como otras
-definiciones de lenguajes hoy en día)
+Puedes jugar con el código en el
+[parque de diversiones Go](https://play.golang.org/p/ncRC2Zevag).  ¡Trata
+de cambiarlo y ejecutarlo desde tu navegador!  Ten en cuenta que puedes
+utilizar [https://play.golang.org]( https://play.golang.org) como un
+[REPL](https://en.wikipedia.org/wiki/Read-eval-print_loop) para probar
+cosas y el código en el navegador, sin ni siquiera instalar Go.
 
-En la lista de lectura de estudiantes de Go está el código fuente de
-la librería estándar. Muy bien documentada, demuestra lo mejor de Go
-leíble, comprendible, estilo Go y formas Go. Pincha en el nombre de
-una función en la documentación y te aparecerá el código fuente!
+En la lista de lecturas para estudiantes de Go está el
+[código fuente de la biblioteca estándar](http://golang.org/src/pkg/). 
+Ampliamente documentado, que demuestra lo mejor del legible y comprensible
+Go, con su característico estilo y modismos.  ¡O puedes hacer clic en un
+nombre de función en [la documentación](http://golang.org/pkg/) y
+aparecerá el código fuente!
 
+Otro gran recurso para aprender Go está en
+[Go con ejemplos](http://goconejemplos.com/).