remove typo fix

LANGS.md

@@ -1,3 +1,4 @@
 * [English](en/)
+* [French](fr/)
 * [中文](zh/)
-* [日本語](ja/)
+* [日本語](ja/)

README.md

@@ -1,5 +1,7 @@
 # Multiple Language Versions
 * [English](en/)
+* [French](fr/)
+* [Spanish](es/)
 * [中文](zh/)
 * [日本語](ja/)
 

book.json

@@ -0,0 +1,39 @@
+{
+  "output": null,
+  "generator": "site",
+  "title": "Build Web Application with golang",
+  "description": "Build Web Application with golang",
+  "extension": null,
+  "plugins": [],
+  "pluginsConfig": {
+    "fontSettings": {
+    "theme": "sepia", "night" or "white",
+    "family": "serif" or "sans",
+    "size": 1 to 4
+    }
+  },
+  "pdf": {
+    "toc": true,
+    "pageNumbers": true,
+    "fontSize": 18,
+    "paperSize": "a4",
+    "margin": {
+      "right": 36,
+      "left": 36,
+      "top": 36,
+      "bottom": 36
+    }
+  }
+  "links": {
+    "home": "https://github.com/astaxie/build-web-application-with-golang",
+    "about": "https://github.com/astaxie/build-web-application-with-golang",
+    "issues": "https://github.com/astaxie/build-web-application-with-golang/issues",
+    "edit": null,
+    "sharing": {
+      "google": null,
+      "facebook": null,
+      "twitter": null,
+      "weibo": null
+    }
+  }
+}

es/01.0.md

@@ -0,0 +1,20 @@
+# 1 Configurando el entorno de Go
+
+Bienvenido al mundo de Go, empecemos a explorar!
+
+Go es un lenguaje de programación para sistemas concurrentes con garbage-collector y compilado-rápido. Tiene las siguientes ventajas:
+
+- Compila un gran proyecto en pocos segundos
+- Proporciona un modelo de desarrollo de software con el que es fácil razonar, evitando la mayoría de problemas asociados con archivos de cabecera al estilo C.
+- Es un lenguaje estático que no tiene niveles en su sistema de tipos, de esa forma sus usuarios no necesitan gastar tiempo lidiando con las relaciones entre los tipos. Es más parecido a un lenguaje orientado a objetos ligero.
+- Realiza garbage collection. Provee soporte básico para comunicación y concurrencia.
+- Diseñado para computadoras multi core.
+
+Go es un lenguaje compilado. Combina la eficiencia en desarrollo de lenguajes interpretados o dinámicos con la seguridad de lenguajes estáticos. Será el lenguaje de elección para computadoras modernas con múltiples core y red. Para este propósito, existen algunos problemas que necesitan ser resueltos al nivel del lenguaje elegido, cómo un sistema de tipo ligero y abundantemente expresivo, un modelo de concurrencia nativo, y un garbage collector estrictamente regulado. Por algún tiempo, no habían emergido paquetes o herramientas que apuntaran a resolver todos estos problemas de una forma pragmática; de esa forma surgió la motivación para el lenguaje Go.
+
+En este capítulo, te mostraremos cómo instalar y configurar tu propio ambiente de desarrollo en Go.
+
+## Links
+
+- [Directorio](preface.md)
+- Sección siguiente: [Instalación](01.1.md)

es/01.1.md

@@ -0,0 +1,123 @@
+# 1.1 Instalación
+
+## Tres formas de instalar Go
+
+Existen muchas formas de configurar el entorno de desarrollo de Go en tu computadora, y puedes escoger la que más te guste. Las tres formas más comunes son las siguientes:
+
+- Paquetes oficiales de instalación
+	- El equipo de Go provee packetes de instalación convenientes para Windows, Linux, Mac y otros sistemas operativos. Este es probablemente el método más fácil para iniciar.
+- Instalarlo desde el código fuente
+	- Es popular con los desarrolladores que están familiarizados con sistemas tipo Unix.
+- Usando herramientas de terceros.
+	- Existen muchas herramientas de terceros y manejadores de paquetes para instalar Go, como apt-get en Ubuntu y Homebrew en la Mac.
+
+En el caso que desees instalar más de una versión de Go en la misma computadora, deberías revisar la herramienta llamada [GVM](https://github.com/moovweb/gvm). Es la mejor herramienta que he visto hasta el momento para cumplir esta tarea, de otra forma tendrás que lidiar con eso tu mismo.
+
+## Instalando desde el código fuente
+
+Debido a que algunas partes de Go están escritas en Plan 9 C y ensamblador AT&T, debes instalar un compilador de C antes de continuar.
+
+Si tienes una Mac y ya tienes instalado Xcode, entonces ya cuentas con el compilador.
+
+En sistemas tipo Unix, debes instalar gcc o un compilador similar. Por ejemplo, usando el manejador de paquetes apt-get (incluído con Ubuntu) puedes instalar los compiladores requeridos de la siguiente forma:
+
+ `sudo apt-get install gcc libc6-dev`
+
+En Windows, debes instalar MinGW antes para poder instalar gcc. No olvides configurar tus variables de entorno después de que la instalación se ha completado. (Si estás utilizando una versión de Windows de 64 bits, entonces debes instalar la versión de 64 bits de MinGW)
+
+El equipo Go usa [Mercurial](http://mercurial.selenic.com/downloads/) para manejar su código fuente, por lo que debes instalar esta herramienta para poder bajar el código fuente de Go.
+
+En este punto ejecuta los siguientes comandos para clonar el código fuente de Go y compilarlo. (Clonará el código fuente en tú directorio actual. Cambia tu ruta actual antes de continuar. Esto puede tomar algún tiempo.)
+
+	hg clone -u release https://code.google.com/p/go
+	cd go/src
+	./all.bash
+
+Una instalación exitosa finalizará con el mensaje "ALL TESTS PASSED."
+
+En Windows puedes lograr lo mismo ejecutando `all.bat`.
+
+Si estas usando Windows el paquete de instalación establecerá tus variables de entorno automáticamente. En sistemas tipo Unix necesitas establecer estas variables de la siguiente manera. (Si tu versión de Go es mayor que 1.0 no debes establecer $GOBIN ya que estará relacionada automáticamente a tu $GOROOT/bin del que hablaremos en la sección siguiente)
+
+    export GOROOT=$HOME/go
+    export GOBIN=$GOROOT/bin
+    export PATH=$PATH:$GOROOT/bin
+
+Si ves la siguiente información en tu pantalla, todo está listo.
+
+![](images/1.1.mac.png?raw=true)
+
+Imagen 1.1 Información después de instalar desde el código fuente
+
+Una vez que veas la información de uso de Go significa que has instalado exitosamente Go en tu computadora. Si dice "no such command", verifica que tu variable de entorno $PATH contiene la ruta de instalación de Go.
+
+## Usando los paquetes de instalación estándar
+
+Go tiene paquetes de instalación de un solo click para todo sistema operativo soportado. Estos paquetes instalarán Go en `/usr/local/go` (`c:\Go` en Windows) por defecto. Por supuesto esto puede ser modificado, pero también necesitas cambiar todas las variables de entorno manualmente a cómo mostramos anteriormente.
+
+### Cómo revisar si tu sistema operativo es de 32-bits ó 64-bits?
+
+Nuestro siguiente paso depende en el tipo de tu sistema operativo, así que debemos revisar esto antes de bajar los paquetes de instalación estándar.
+
+Si estás usando Windows, presiona `Win+R` y luego ejecuta la herramienta de comandos. Escribe el comando `systeminfo` y te mostrará información útil. Busca la línea que dice "system type" si ves "x64-based PC" eso significa que tu sistema operativo es de 64-bits, de otra forma es de 32-bits.
+
+Si eres un usuario de Mac recomiendo fuertemente que bajes el paquete de 64-bits, debido a que Go ya no soporta procesadores puros de 32-bits en Mac OSX.
+
+Los usuarios de Linux pueden escribir `uname -a` en la terminal para ver la información del sistema.
+
+Un sistema operativo de 64-bits mostrará lo siguiente:
+
+    <alguna descripción> x86_64 x86_64 x86_64 GNU/Linux
+    // algunas versiones como Ubuntu 10.04 mostrarán de la siguiente forma
+    x86_64 GNU/Linux
+
+En cambio los sistemas operativos de 32-bits mostrarán:
+
+    <alguna descripción> i686 i686 i386 GNU/Linux
+
+### Mac
+
+Ve a la [página de descarga](http://code.google.com/p/go/downloads/list), escoge `go1.0.3.darwin-386.pkg` para sistemas de 32-bits y `go1.0.3.darwin-amd64.pkg` para sistemas de 64-bits. Ve hasta el final presionando "next",`~/go/bin` será agregado al $PATH de tu sistema al finalizar la instalación. Ahora abre la terminal y escribe `go`. Debes ver el mismo resultado que se muestra en la imagen 1.1.
+
+### Linux
+
+Ve a la [página de descarga](http://code.google.com/p/go/downloads/list), escoge `go1.0.3.linux-386.tar.gz` para sistemas de 32-bits y `go1.0.3.linux-amd64.tar.gz` para sistemas de 64-bits. Supongamos que quieres instalar Go en la ruta `$GO_INSTALL_DIR`. Descomprime el archivo `tar.gz` a la ruta que escojas usando el comando `tar zxvf go1.0.3.linux-amd64.tar.gz -C $GO_INSTALL_DIR`. Luego configura tu $PATH con el siguiente comando: `export PATH=$PATH:$GO_INSTALL_DIR/go/bin`. Ahora abre la terminal y escribe `go`. Debes ver el mismo resultado que se muestra en la imagen 1.1.
+
+### Windows
+
+Ve a la [página de descarga](http://code.google.com/p/go/downloads/list), escoge `go1.0.3.windows-386.msi` para sistemas de 32-bits y `go1.0.3.windows-amd64.msi` para sistemas de 64-bits. Ve hasta el final presionando "next", `c:/go/bin` será agregado al `path`. Ahora abre la terminal y escribe `go`. Debes ver el mismo resultado que se muestra en la imagen 1.1.
+
+## Usando herramientas de terceros
+
+### GVM
+
+GVM es una herramienta de control de múltiples versiones de Go desarrollado por terceros, parecida a rvm para ruby. Es bien fácil de utilizar. Instala gvm escribiendo los siguientes comandos en tu terminal:
+
+    bash < <(curl -s https://raw.github.com/moovweb/gvm/master/binscripts/gvm-installer)
+
+Luego instalamos Go usando los siguientes comandos:
+
+    gvm install go1.0.3
+    gvm use go1.0.3
+
+Cuando el proceso ha finalizado estamos listos.
+
+### apt-get
+
+Ubuntu es la versión de escritorio más popular de Linux. Utiliza `apt-get` para manejar paquetes. Podemos instalar Go usando los siguientes comandos.
+
+    sudo add-apt-repository ppa:gophers/go
+    sudo apt-get update
+    sudo apt-get install golang-stable
+
+### Homebrew
+
+Homebrew es una herramienta para manejar software comúnmente usada en la Mac. Simplemente escribe lo siguiente para instalar Go.
+
+    brew install go
+
+## Links
+
+- [Directorio](preface.md)
+- Sección anterior: [Configurando el entorno de Go](01.0.md)
+- Sección siguiente: [$GOPATH y el ambiente de trabajo](01.2.md)

es/01.2.md

@@ -0,0 +1,151 @@
+#1.2 $GOPATH y el ambiente de trabajo
+
+## $GOPATH
+
+Todos los comandos de Go dependen de una importante variable de entorno llamada $GOPATH. Favor notar que esta no es la variable $GOROOT que es la que muestra dónde Go está instalado. Esta variable apunta al ambiente de trabajo de Go en tu computadora (You uso esta ruta en mi computadora; si no tienes la misma estructura de directorios, por favor reemplaza por la que tengas).
+
+En sistemas tipo Unix, la variable debe usar así:
+
+	export GOPATH=/home/apple/mygo
+
+En Windows, necesitas crear una nueva variable de entorno llamada GOPATH, luego estable su valor a `c:\mygo` (Este valor depende dónde tu ambiente de trabajo esté ubicado)
+
+Está bien tener más de una ruta de ambiente de trabajo en $GOPATH, pero recuerda que debes usar `:`(`;` en Windows) para separarlos. En este punto, `go get` guardará el contenido de tu primera ruta en $GOPATH.
+
+En $GOPATH, debes tener los siguientes tres directorios:
+
+- `src` para archivos fuentes cuyo sufijo es .go, .c, .g, .s.
+- `pkg` para archivos compilados cuyo sufijo es .a.
+- `bin` para archivos ejecutables
+
+En este libro, utilizo `mygo` cómo mi única ruta en $GOPATH.
+
+## Directorio de paquetes
+
+Crea archivos de código fuente de paquetes de la siguiente forma `$GOPATH/src/mymath/sqrt.go` (`mymath` es el nombre del paquete) ( ***El autor utiliza `mymath` cómo su nombre de paquete, el mismo nombre para el directorio que contiene los archivos de código fuente del paquete)
+
+Cada vez que creas un paquete, deberías crear un nuevo folder en el directorio `src`. Los nombres de los directorios usualmente son los mismos que el paquete que vas a utilizar. Puedes tener directorios de múltiples niveles si lo deseas. Por ejemplo, si creas el directorio `$GOPATH/src/github.com/astaxie/beedb`, entonces la ruta del paquete sería `github.com/astaxie/beedb`. El nombre del paquete será el último directorio en tu ruta, que es `beedb` en este caso.
+
+Ejecuta los siguientes comandos. (Ahora el autor mostrará unos ejemplos)
+
+	cd $GOPATH/src
+	mkdir mymath
+
+Crea un nuevo archivo llamado `sqrt.go`, escribe el siguiente contenido en el archivo.
+
+	// Código fuente de $GOPATH/src/mymath/sqrt.go
+	package mymath
+
+	func Sqrt(x float64) float64 {
+		z := 0.0
+		for i := 0; i < 1000; i++ {
+			z -= (z*z - x) / (2 * x)
+		}
+		return z
+	}
+
+Ahora el directorio de mi paquete ha sido creado y su código ha sido escrito. Recomiendo que uses el mismo nombre para tus paquetes y sus directorios correspondientes y que los directorios contenga todo el código fuente del paquete.
+
+## Compilar paquetes
+
+Ya hemos creado nuestra paquete, pero cómo lo compilamos para propósitos prácticos? hay dos formas de hacer esto.
+
+1. Cambia tu ruta de trabajo al directorio de tu paquete, luego ejecuta el comando `go install`.
+2. Ejecuta el comando de arriba, con la diferencia de que suministras el nombre del archivo como parámetro `go install mymath`.
+
+Después de compilar podemos abrir el siguiente directorio.
+
+	cd $GOPATH/pkg/${GOOS}_${GOARCH}
+	// puedes ver que el archivo fue generado
+	mymath.a
+
+Este archivo cuyo sufijo es `.a`, es el archivo binario de nuestro paquete. Cómo lo usamos?
+
+Obviamente, necesitamos crear una nueva aplicación para utilizarlo.
+
+Crea una nueva aplicación llamada `mathapp`.
+
+	cd $GOPATH/src
+	mkdir mathapp
+	cd mathapp
+	vim main.go
+
+código
+
+	//$GOPATH/src/mathapp/main.go código fuente
+	package main
+
+	import (
+		"mymath"
+		"fmt"
+	)
+
+	func main() {
+		fmt.Printf("Hello, world. Sqrt(2) = %v\n", mymath.Sqrt(2))
+	}
+
+Para compilar esta aplicación necesitas cambiar al directorio de la aplicación que en este caso es `$GOPATH/src/mathapp`, luego ejecuta el comando `go install`. Ahora deberías ver un archivo ejecutable llamado `mathapp` que se ha generado en el directorio `$GOPATH/bin/`. Para correr este programa usa el comando `./mathapp`. Deberías de ver el siguiente contenido en tu terminal:
+
+	Hello world. Sqrt(2) = 1.414213562373095
+
+## Instala paquete remotos
+
+Go tiene una herramienta para instalar paquetes remotos, es el comando llamado `go get`. Soporta la mayoría de comunidades de código libre, incluyendo Github, Google Code, BitBucket y Launchpad.
+
+	go get github.com/astaxie/beedb
+
+Puedes usar `go get -u …` para actualizar tus paquetes remotos e incluso instalará todas sus dependencias.
+
+Esta herramienta usará diferente herramientas de control de versiones para las diferentes plataformas de código libre. Por ejemplo, `git` para Github y `hg` para Google Code. Debido a esto, debes instalar estas herramientas de control de versiones antes de usar `go get`.
+
+Después de ejecutar los comandos anteriormente descritos, la estructura de directorios debería verse de la siguiente forma:
+
+	$GOPATH
+		src
+		 |-github.com
+		 	 |-astaxie
+		 	 	 |-beedb
+		pkg
+		 |--${GOOS}_${GOARCH}
+		 	 |-github.com
+		 	 	 |-astaxie
+		 	 	 	 |-beedb.a
+
+Actualmente, `go get` clona el código fuente a la ruta $GOPATH/src, luego ejecuta `go install`.
+
+Puedes usar paquetes remotos de la misma forma que usas paquetes locales.
+
+	import "github.com/astaxie/beedb"
+
+## Estructura completa del directorio
+
+Si has seguido todos los pasos anteriores, la estructura de tu directorio se debería ver de la siguiente forma.
+
+	bin/
+		mathapp
+	pkg/
+		${GOOS}_${GOARCH}, como darwin_amd64, linux_amd64
+      mymath.a
+      github.com/
+        astaxie/
+          beedb.a
+	src/
+		mathapp
+			main.go
+		mymath/
+			sqrt.go
+		github.com/
+			astaxie/
+				beedb/
+					beedb.go
+					util.go
+
+Ahora puedes ver la estructura de directorios claramente; `bin` contiene los archivos ejecutables, `pkg` contiene los archivos compliados y `src` los archivos de código fuente del paquete.
+
+(El formato de las variables de entorno en Windows es `%GOPATH%`, sin embargo este libro sigue principalmente el estilo Unix, así que si eres un usuario Windows debes reemplazarlo apropiadamente)
+
+## Links
+
+- [Directorio](preface.md)
+- Sección anterior: [Instalación](01.1.md)
+- Sección siguiente: [Comandos Go](01.3.md)

es/01.3.md

@@ -0,0 +1,104 @@
+#1.3 Comandos Go
+
+## Comandos Go
+
+El lenguaje Go viene con un conjunto completo de herramientas de comandos operacionales. Puedes ejecutar en la lína de comando `go` para verlas:
+
+![](images/1.3.go.png?raw=true)
+
+Imagen 1.3 El comando Go muestra información detallada.
+
+Todos estos nos son muy útiles, veamos cómo usar algunos de ellos.
+
+## go build
+
+Este comando es para pruebas de compilación. Compilará paquetes dependientes de ser necesario.
+
+- Si el paquete no es el paquete principal `main` como `mymath` en la sección 1.2, nada será generado después de ejecutar `go build`. Si necesitas el archivo de paquete `.a` en `$GOPATH/pkg`, mejor usa `go install`.
+- Si el paquete es el paquete principal `main`, generará un archivo ejecutable en el mismo directorio. Si quieres que el archivo sea generado en `$GOPATH/bin`, usa `go install` o `go build -o ${PATH_HERE}/a.exe.`
+- Si hay muchos archivos en el directorio, pero solamente deseas compilar uno de ellos, debes anexar el nombre del archivo después de `go build`. Por ejemplo, `go build a.go`. `go build` compilará todos los archivos en el directorio.
+- También puedes asignar el nombre del archivo que será generado. Por ejemplo, en el proyecto `mathapp` (en la sección 1.2), usando `go build -o astaxie.exe` generará `astaxie.exe` en vez de `mathapp.exe`. El nombre por defecto es el nombre de tu directorio (en paquetes no principales non-main) o el primer nombre de archivo de código fuente (paquetes principales main).
+
+(De acuerdo a la [Especificación del Lenguaje de Programación Go](https://golang.org/ref/spec), los nombres de paquetes deben ser el nombre después de la palabra `package` en la primera línea de tus archivos de código fuente. No tiene que ser el mismo que el nombre del directorio y el nombre del archivo ejecutable será, por defecto, el del nombre de tu directorio)
+
+- `go build` ignora archivos cuyos nombres empiezan con `_` o `.`.
+- Si deseas tener diferentes archivos fuentes para cada sistema operativo, puedes nombrar los archivos con el nombre del sistema operativo como sufijo. Supongamos que existen archivos fuentes para cargar arreglos. Pueden ser nombrados de la siguiente forma:
+
+	array_linux.go | array_darwin.go | array_windows.go | array_freebsd.go
+
+`go build` escoge el que está asociado con tu sistema operativo. Por ejemplo, solamente compila array_linux.go en sistemas Linux e ignora todos los demás.
+
+## go clean
+
+Este comando es para limpiar los archivos que son generados por los compiladores, incluyendo los siguientes archivos:
+
+	_obj/            // viejo directorio de object, dejado por Makefiles
+	_test/           // viejo directorio de test, dejado por Makefiles
+	_testmain.go     // viejo directorio de gotest, dejado por Makefiles
+	test.out         // viejo directorio de test, dejado por Makefiles
+	build.out        // viejo directorio de test, dejado por Makefiles
+	*.[568ao]        // object files, dejado por Makefiles
+
+	DIR(.exe)        // generado por go build
+	DIR.test(.exe)   // generado por go test -c
+	MAINFILE(.exe)   // generado por go build MAINFILE.go
+
+Usualmente utilizo este comando para limpiar mis archivos antes de subir mi proyecto a Github. Estas son herramientas útiles para pruebas locales, pero inútiles para el control de versiones.
+
+## go fmt
+
+La gente que trabaja con C/C++ deben saber que la gente siempre están argumentando qué estilo de código es mejor: estilo K&R o ANSI. Sin embargo, en Go, solamente hay un estilo de código que es forzado. Por ejemplo, llave izquierda solamente debe ser insertada al final de las líneas y no pueden estar en sus propias líneas, de otra forma tendrás errores de compilación! Afortunadamente, no debes recordar estas reglas `go fmt` hace este trabajo por ti. Solamente ejecuta el comando `go fmt <Nombre de Archivo>.go` en la terminal. No uso mucho este comando, porque los IDEs usualmente ejecutan este comando automáticamente cuando guardas tu código fuente. Hablaré más respecto a los IDEs en la siguiente sección.
+
+Usualmente usamos `gofmt -w` en vez de `go fmt`. El último, no rescribirá tus archivos después de formatearlos, `gofmt -w src` formatea todo el proyecto.
+
+## go get
+
+Este comando es para obtener paquetes remotos. Hasta el momento soporta BitBucket, Github, Google Code y Launchpad. Actualmente existen dos cosas que suceden después de ejecutar este comando. La primera es que Go descarga el código fuente, luego ejecuta `go install`. Antes de que utilices este comando, asegúrate que tienes instaladas todas las herramientas relacionadas.
+
+	BitBucket (Mercurial Git)
+	Github (git)
+	Google Code (Git, Mercurial, Subversion)
+	Launchpad (Bazaar)
+
+Para poder usar este comando, debes instalar estas herramientas correctamente. No olvides establecer `$PATH`. Por cierto, también soporta nombres de dominios customizados. Usa `go help remote` para más detalles al respecto.
+
+## go install
+
+Este comando compila todos los paquetes y genera archivos, luego los mueve a `$GOPATH/pkg` o `$GOPATH/bin`.
+
+## go test
+
+Este comando carga todos los archivos cuyos nombres incluyen `*_test.go` y genera archivos de pruebas, luego muestra información que se ve de la siguiente forma.
+
+	ok   archive/tar   0.011s
+	FAIL archive/zip   0.022s
+	ok   compress/gzip 0.033s
+	...
+
+Prueba todos tus archivos de prueba por defecto. Usa el comando `go help testflag` para más detalles.
+
+## go doc
+
+Muchas personas dicen que no necesitamos ninguna herramienta de documentación adicional para programar en Go (En realidad, ya he hecho un [CHM](https://github.com/astaxie/godoc)). Go tiene nativamente una herramienta de documentación poderosa.
+
+Así que, cómo buscamos información de paquetes en la documentación? Por ejemplo, si deseas encontrar más detalles del paquete `builtin`, usa el comando `go doc builtin`. Similarmente, usa el comando `go doc net/http` para buscar la documentación del paquete `http`. Si quieres ver más detalles de funciones específicas, usa los comandos `godoc fmt Printf` y `godoc -src fmt Printf` para ver el código fuente.
+
+Ejecuta el comando `godoc -http=:8080`, luego abre `127.0.0.1:8080` en tu navegador. Debes ver una versión localizada de golang.org. Puede no solamente mostrar la información de los paquetes estándar, sino también puede mostrar los paquetes en tu `$GOPATH/pkg`. Es grandiosa para aquellas personas que sufren del firewall en China.
+
+## Otros comandos
+
+Go provee comandos adicionales a los que ya mostramos.
+
+	go fix // actualiza código de una vieja versión antes de go1 a una nueva versión después de go1
+	go version // muestra información de tu versión de Go
+	go env // muestra las variables de entorno relacionadas a Go
+	go list // lista todos los paquetes instalados
+	go run // compila los archivos temporales y ejecuta la aplicación
+
+También hay más detalles de los comandos que hemos hablado, puedes usar el comando `go help <nombre de comando>` para mostrarlos.
+
+## Links
+
+- [Directorio](preface.md)
+- Sección anterior: [$GOPATH y el ambiente de trabajo](01.2.md)
+- Sección siguiente: [Herramientas de Desarrollo para Go](01.4.md)

es/01.4.md

@@ -0,0 +1,399 @@
+# Herramientas de Desarrollo para Go
+
+En esta sección les mostraré algunos IDEs que pueden ayudarte a volverte un programador más eficiente, con características cómo completamiento de código inteligente y auto formato. Todos son multi-plataforma, así que los pasos que mostraré no deberían de ser muy diferentes aún en el caso que no estés utilizando el mismo sistema operativo.
+
+## LiteIDE
+
+LiteIDE es un IDE de código libre, ligero para programar únicamente proyectos Go, es desarrollado por visualfc.
+
+![](images/1.4.liteide.png?raw=true)
+
+Imagen 1.4 Panel principal de LiteIDE
+
+Características de LiteIDE
+
+- Multi-platforma
+	- Windows
+	- Linux
+	- Mac OS
+- Cross-compile
+	- Maneja múltiples ambientes de compilación
+	- Soporta la compilación para diferentes sistemas
+- Manejo de Proyectos estándar
+	- Vista de documentación basada en $GOPATH
+	- Sistema de compilación basado en $GOPATH
+	- Indice de documentación del API basado en $GOPATH
+- Editor de código fuente Go
+	- Delineado de código
+	- Soporte completo de gocode
+	- Indice del API y vista de la documentaciónd de Go
+	- Ver expresiones de código usando `F1`
+	- Saltar a la declaración de funciones usando `F2`
+	- Soporte Gdb
+	- Auto-formateo con `gofmt`
+- Otras
+	- Multi-lenguaje
+	- Sistema de plugin
+	- Temas
+	- Soporte de sintaxis basado en Kate
+	- Completamiento inteligente basado en texto-completo
+	- Atajos configurables (shortcuts)
+	- Soporte de Markdown
+		- Previsualizar en tiempo real
+		- CSS personalizado
+		- Exportar HTML y PDF
+		- Convertir y unir a HTML y PDF
+
+### Instalación de LiteIDE
+
+- Instalar LiteIDE
+	- [Página de descarga](http://code.google.com/p/golangide)
+	- [Código Fuente](https://github.com/visualfc/liteide)
+
+	Primeramente debes instalar Go, luego descarga la versión apropiada para tu sistema operativo. Descomprime el paquete para poder usarlo directamente.
+- Instala gocode
+
+	Debes instalar gocode para poder usar el completamiento inteligente
+
+		go get -u github.com/nsf/gocode
+
+- Entorno de compilación
+
+	Cambia la configuración en LiteIDE para que se ajuste a tu sistema operativo.
+	En Windows y usando al versión de 64-bits de Go, debes usar win64 cómo la configuración de entorno en la barra de herramientas. Luego escoge `opinion`, busca `LiteEnv` en la lista de la izquierda y abre el archivo `win64.env` en la lista de la derecha.
+
+		GOROOT=c:\go
+		GOBIN=
+		GOARCH=amd64
+		GOOS=windows
+		CGO_ENABLED=1
+
+		PATH=%GOBIN%;%GOROOT%\bin;%PATH%
+		。。。
+
+	Reemplaza `GOROOT=c:\go` con tu ruta de instalación de Go y guarda. Si tienes MinGW64, agrega `c:\MinGW64\bin` a la variable de entorno de tu path para soportar `cgo`.
+
+	En Linux y usando la versiónd de 64-bits de Go, debes escoger linux64 como la configuración de entorno en la barra de herramientas. Luego escoge `opinion`, busca `LiteEnv` en la lista de la izquierda y abre el archivo `linux64.env` en la lista de la derecha.
+
+		GOROOT=$HOME/go
+		GOBIN=
+		GOARCH=amd64
+		GOOS=linux
+		CGO_ENABLED=1
+
+		PATH=$GOBIN:$GOROOT/bin:$PATH
+		。。。
+
+	Reemplaza `GOROOT=$HOME/go` con tu ruta de instalación de Go y guarda.
+- $GOPATH
+	$GOPATH es la ruta que contiene la lista de proyectos. Abre la herramienta de comandos (o presiona `Ctrl+` en LiteIDE), luego escribe `go help gopath` para más detalles.
+	Es bien fácil ver y cambiar $GOPATH en LiteIDE.
+
+## Sublime Text
+
+Ahora voy a introducir Sublime Text 2 (o simplemente Sublime) + GoSublime + gocode + MarGo. Déjenme explicar el porqué.
+
+- Completamiento inteligente
+
+	![](images/1.4.sublime1.png?raw=true)
+
+	Imagen 1.5 Completamiento inteligente con Sublime
+- Auto-formateo de los archivos de código
+- Manejo de proyectos
+
+	![](images/1.4.sublime2.png?raw=true)
+
+	Imagen 1.6 Manjo de proyectos con Sublime
+
+- Realce de sintaxis
+- Prueba gratis eterna sin limitaciones funcionales. Te recuerda de vez en cuando la compra de una licencia, pero simplemente puedes ignorarla si lo deseas. Por supuesto, si encuentras que realmente mejora tu productividad y realmente disfrutas usarlo, compra una copia y apoya el desarrollo de nuevas versiones!
+
+Primero, descarga la versión de [Sublime](http://www.sublimetext.com/) adecuada para tu sistema operativo.
+
+1. Presiona `Ctrl+`, abre la herramienta de comandos e ingresa los siguientes comandos
+
+		import urllib2,os; pf='Package Control.sublime-package'; ipp=sublime.installed_packages_path(); os.makedirs(ipp) if not os.path.exists(ipp) else None; urllib2.install_opener(urllib2.build_opener(urllib2.ProxyHandler())); open(os.path.join(ipp,pf),'wb').write(urllib2.urlopen('http://sublime.wbond.net/'+pf.replace(' ','%20')).read()); print 'Please restart Sublime Text to finish installation'
+
+	Reinicia Sublime Text cuando la instalación ha finalizado. Luego busca la opción de `Package Control` en el menú de "Preferences".
+
+	![](images/1.4.sublime3.png?raw=true)
+
+	Imagen 1.7 Sublime Package Control
+2. Para instalar GoSublime, SidebarEnhancements y Go Build, presiona `Ctrl+Shift+p` para abrir Package Control, luego escribe `pcip` (atajo para "Package Control: Install Package").
+
+	![](images/1.4.sublime4.png?raw=true)
+
+	Imagen 1.8 Sublime Install Packages
+
+	Ahora escribe "GoSublime", presiona OK para instalar el paquete y repite los mismos pasos para instalar SidebarEnhancements y Go Build. Una vez más reinicia el editor cuando se complete la instalación.
+3. Para verificar que la instalación fue exitosa, abre Sublime, luego abre el achivo `main.go` para ver si tiene el realce de sintaxis adecuado, escribe `import` para ver si el completamiento de código se muestra. Luego de escribir `import "fmt"`, escribe `fmt.` en cualquier parte luego de la declaración `import` para ver si el completamiento inteligente de funciones está funcionando.
+
+	Si todo está bien, estamos listos.
+
+	Si no, revisa tu $PATH nuevamente. Abre la terminal, escribe `gocode`. Si no se ejecuta, tu $PATH no fue configurado correctamente.
+
+## Vim
+
+Vim es un editor de texto popular para los programadores, que evolucionó de su predecesor más ligero, Vi. Tiene funciones para completamiento inteligente, compilació y saltar a los errores.
+
+![](images/1.4.vim.png?raw=true)
+
+Imagen 1.8 Completamiento inteligente en Vim para Go
+
+1. Realce de sintaxis para Go
+
+		cp -r $GOROOT/misc/vim/* ~/.vim/
+
+2. Habilitando el realce de sintaxis
+
+		filetype plugin indent on
+		syntax on
+
+3. Instalar [gocode](https://github.com/nsf/gocode/)
+
+		go get -u github.com/nsf/gocode
+
+	gocode se instalará por defecto en `$GOBIN`
+
+4. Configura [gocode](https://github.com/nsf/gocode/)
+
+		~ cd $GOPATH/src/github.com/nsf/gocode/vim
+		~ ./update.bash
+		~ gocode set propose-builtins true
+		propose-builtins true
+		~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
+		lib-path "/home/border/gocode/pkg/linux_amd64"
+		~ gocode set
+		propose-builtins true
+		lib-path "/home/border/gocode/pkg/linux_amd64"
+
+	Explicación de la configuración de gocode:
+
+	propose-builtins: especifica si abrir o no el completamiento inteligente; falso por defecto.
+	lib-path: gocode solamente busca paquetes en `$GOPATH/pkg/$GOOS_$GOARCH` y `$GOROOT/pkg/$GOOS_$GOARCH`. Esta configuración puede usarse para agregar rutas adicionales.
+
+5. Felicitaciones! Prueba `:e main.go` para experimentar el mundo de Go!
+
+## Emacs
+
+Emcas es la llamada arma de Dios. No es solamente un editor, sino un poderoso IDE.
+
+![](images/1.4.emacs.png?raw=true)
+
+Imagen 1.10 Panel principal de Emacs editando Go
+
+1. Realce de sintaxis
+
+		cp $GOROOT/misc/emacs/* ~/.emacs.d/
+
+2. Instalar [gocode](https://github.com/nsf/gocode/)
+
+		go get -u github.com/nsf/gocode
+
+		gocode se instalará por defecto en `$GOBIN`
+3. Configura [gocode](https://github.com/nsf/gocode/)
+
+		~ cd $GOPATH/src/github.com/nsf/gocode/vim
+		~ ./update.bash
+		~ gocode set propose-builtins true
+		propose-builtins true
+		~ gocode set lib-path "/home/border/gocode/pkg/linux_amd64"
+		lib-path "/home/border/gocode/pkg/linux_amd64"
+		~ gocode set
+		propose-builtins true
+		lib-path "/home/border/gocode/pkg/linux_amd64"
+
+4. Instalar [Auto Completion](http://www.emacswiki.org/emacs/AutoComplete)
+	Descarga y descomprime
+
+		~ make install DIR=$HOME/.emacs.d/auto-complete
+
+	Configura el archivo ~/.emacs
+
+		;;auto-complete
+		(require 'auto-complete-config)
+		(add-to-list 'ac-dictionary-directories "~/.emacs.d/auto-complete/ac-dict")
+		(ac-config-default)
+		(local-set-key (kbd "M-/") 'semantic-complete-analyze-inline)
+		(local-set-key "." 'semantic-complete-self-insert)
+		(local-set-key ">" 'semantic-complete-self-insert)
+
+	Visita este [link](http://www.emacswiki.org/emacs/AutoComplete) para más detalles.
+5. Configura .emacs
+
+		;; golang mode
+		(require 'go-mode-load)
+		(require 'go-autocomplete)
+		;; speedbar
+		;; (speedbar 1)
+		(speedbar-add-supported-extension ".go")
+		(add-hook
+		'go-mode-hook
+		'(lambda ()
+    		;; gocode
+    		(auto-complete-mode 1)
+    		(setq ac-sources '(ac-source-go))
+    		;; Imenu & Speedbar
+    		(setq imenu-generic-expression
+        		'(("type" "^type *\\([^ \t\n\r\f]*\\)" 1)
+        		("func" "^func *\\(.*\\) {" 1)))
+    		(imenu-add-to-menubar "Index")
+    		;; Outline mode
+    		(make-local-variable 'outline-regexp)
+    		(setq outline-regexp "//\\.\\|//[^\r\n\f][^\r\n\f]\\|pack\\|func\\|impo\\|cons\\|var.\\|type\\|\t\t*....")
+    		(outline-minor-mode 1)
+    		(local-set-key "\M-a" 'outline-previous-visible-heading)
+    		(local-set-key "\M-e" 'outline-next-visible-heading)
+    		;; Menu bar
+    		(require 'easymenu)
+    		(defconst go-hooked-menu
+        		'("Go tools"
+        		["Go run buffer" go t]
+        		["Go reformat buffer" go-fmt-buffer t]
+        		["Go check buffer" go-fix-buffer t]))
+    		(easy-menu-define
+        		go-added-menu
+        		(current-local-map)
+        		"Go tools"
+        		go-hooked-menu)
+
+    		;; Other
+    		(setq show-trailing-whitespace t)
+    		))
+		;; helper function
+		(defun go ()
+    		"run current buffer"
+    		(interactive)
+    		(compile (concat "go run " (buffer-file-name))))
+
+		;; helper function
+		(defun go-fmt-buffer ()
+    		"run gofmt on current buffer"
+    		(interactive)
+    		(if buffer-read-only
+    		(progn
+        		(ding)
+        		(message "Buffer is read only"))
+    		(let ((p (line-number-at-pos))
+    		(filename (buffer-file-name))
+    		(old-max-mini-window-height max-mini-window-height))
+        		(show-all)
+        		(if (get-buffer "*Go Reformat Errors*")
+    		(progn
+        		(delete-windows-on "*Go Reformat Errors*")
+        		(kill-buffer "*Go Reformat Errors*")))
+        		(setq max-mini-window-height 1)
+        		(if (= 0 (shell-command-on-region (point-min) (point-max) "gofmt" "*Go Reformat Output*" nil "*Go Reformat Errors*" t))
+    		(progn
+        		(erase-buffer)
+        		(insert-buffer-substring "*Go Reformat Output*")
+        		(goto-char (point-min))
+        		(forward-line (1- p)))
+    		(with-current-buffer "*Go Reformat Errors*"
+    		(progn
+        		(goto-char (point-min))
+        		(while (re-search-forward "<standard input>" nil t)
+        		(replace-match filename))
+        		(goto-char (point-min))
+        		(compilation-mode))))
+        		(setq max-mini-window-height old-max-mini-window-height)
+        		(delete-windows-on "*Go Reformat Output*")
+        		(kill-buffer "*Go Reformat Output*"))))
+		;; helper function
+		(defun go-fix-buffer ()
+    		"run gofix on current buffer"
+    		(interactive)
+    		(show-all)
+    		(shell-command-on-region (point-min) (point-max) "go tool fix -diff"))
+6. Felicitaciones, ya estás listo! Speedbar está cerrada por defecto -remueve los símbolos de comentarios en la línea `;;(speedbar 1)` para habilitar esta característica o puedes usarla a través de `M-x speedbar`.
+
+## Eclipse
+
+Eclipse también es una grandiosa herramienta de desarrollo. Te mostraré como usarla para escribir programas en Go.
+
+![](images/1.4.eclipse1.png?raw=true)
+
+Imagen 1.1 Panel principal de Eclipse editando Go
+
+1. Descarga e instala[Eclipse](http://www.eclipse.org/)
+2. Descarga [goclipse](https://code.google.com/p/goclipse/)
+	[http://code.google.com/p/goclipse/wiki/InstallationInstructions](http://code.google.com/p/goclipse/wiki/InstallationInstructions)
+3. Descarga gocode
+
+	gocode in Github.
+
+		https://github.com/nsf/gocode
+
+	Necesitas instalar git en Windows, usualmente usamos [msysgit](https://code.google.com/p/msysgit/)
+
+	Instala gocode en la herramienta de comandos
+
+		go get -u github.com/nsf/gocode
+
+	También puedes instalar desde el código fuente si gustas.
+4. Descarga e instala [MinGW](http://sourceforge.net/projects/mingw/files/MinGW/)
+5. Configura los plugins.
+
+	Windows->Preferences->Go
+
+	(1).Configura el compilador Go
+
+	![](images/1.4.eclipse2.png?raw=true)
+
+	Imagen 1.12 Configuración de Go en Eclipse
+
+	(2).Configura gocode(opcional), estable la ruta de gocode a dónde se encuentra el archivo gocode.exe
+
+	![](images/1.4.eclipse3.png?raw=true)
+
+	Imagen 1.13 Configuración gocode
+
+	(3).Configura gdb(opcional), establece la ruta gdb a dónde se encuentra el archivo gdb.exe
+
+	![](images/1.4.eclipse4.png?raw=true)
+
+	Imagen 1.14 Configuración gdb
+6. Verifica la instalación
+
+	Crea un nuevo proyecto Go y un archivo hello.go
+
+	![](images/1.4.eclipse5.png?raw=true)
+
+	Imagen 1.15 Crea un nuevo proyecto Go y un archivo
+
+	Prueba la instalación a cómo sigue (necesitas escribir el comando en la consola en Eclipse)
+
+	![](images/1.4.eclipse6.png?raw=true)
+
+	Imagen 1.16 Prueba el programa Go en Eclipse
+
+## IntelliJ IDEA
+
+Las personas que han trabajado con Java deben estar familiarizadas con este IDE. Soporta el realce de sintaxis y completamiento de código inteligente, implementado por un plugin.
+
+1. Descarga IDEA, no hay diferencia entre la edición Ultimate y Community
+
+	![](images/1.4.idea1.png?raw=true)
+
+2. Instala el plugin Go. Escoge `File - Setting - Plugins`, luego da click en `Browser repo`.
+
+	![](images/1.4.idea3.png?raw=true)
+
+3. Busca `golang`, doble click `download and install` y espera que la descarga se complete.
+
+	![](images/1.4.idea4.png?raw=true)
+
+	Click `Apply`, luego reinicia.
+4. Ahora puedes crear un proyecto Go.
+
+	![](images/1.4.idea5.png?raw=true)
+
+	Introduce la ubicación de tu Go sdk en el siguiente paso - básicamente es tu $GOROOT.
+
+( ***Revisa este [artíclo de blog](http://wuwen.org/tips-about-using-intellij-idea-and-go/) para una configuración paso a paso *** )
+
+## Links
+
+- [Directorio](preface.md)
+- Sección anterior: [Comandos Go](01.3.md)
+- Sección siguiente: [Resumen](01.5.md)

es/01.5.md

@@ -0,0 +1,9 @@
+# 1.5 Resumen
+
+En este capítulo hablamos acerca de como instalar Go usando tres métodos diferentes, incluyendo desde el código fuente, paquetes estándares y herramientas de terceros. Luego mostramos como configurar el ambiente de desarrollo de Go, principalmente cubriendo como configurar tu `$GOPATH`. Luego de eso se introdujeron algunos pasos para compilar y desplegar los programos Go. Luego cubrimos los comandos Go, incluyendo los comandos para compilar, instalar, formatear y probar. Finalmente existen muchas herramientas poderosas para desarrollar programas Go como LiteIDE, Sublime Text, Vim, Emacs, Eclipse, IntelliJ IDEA, etc. Puedes escoger cualquier y explorar el mundo de Go.
+
+## Links
+
+- [Directorio](preface.md)
+- Sección anterior: [Herramientas de Desarrollo para Go](01.4.md)
+- Siguiente capítulo: [Conocimiento básico de Go](02.0.md)

es/README.md

@@ -0,0 +1,37 @@
+***Construye Aplicaciones Web con Golang***
+======================================
+
+### Propósito
+
+Debido a que estoy interesado en el desarrollo de aplicaciones web, usé mi tiempo libre para escribir este libro en versión código libre. No significa que tengo muy buenas habilidades para construir aplicaciones web; Me gustaría compartir lo que he hecho con Go construyendo aplicaciones web.
+
+- Para aquellos que están trabajando con PHP/Python/Ruby, aprenderán cómo construir una aplicación web con Go.
+- Para aquellos que están trabajando con C/C++, conocerán cómo funciona la web.
+
+Creo que el próposito de estudiar es compartir con otros. La cosa más feliz en mi vida es compartir todo lo que sé con más personas.
+
+# Donaciones
+
+AliPay: <img src="../zh/images/alipay.png" alt="alipay" width="100" height="100">
+
+Donar (Sitio en inglés):[donar](http://beego.me/donate)
+
+## Comunidad
+QQ群：386056972
+
+BBS：[http://golanghome.com/](http://golanghome.com/)
+
+### Reconocimientos
+
+ - [四月份平民 April Citizen](https://plus.google.com/110445767383269817959) (revisó código)
+ - [洪瑞琦 Hong Ruiqi](https://github.com/hongruiqi) (revisó código)
+ - [边  疆 BianJiang](https://github.com/border) (escribió las configuraciones acerca de Vim y Emacs para el desarrollo con Go)
+ - [欧林猫 Oling Cat](https://github.com/OlingCat)(revisó código)
+ - [吴文磊 Wenlei Wu](mailto:spadesacn@gmail.com)(aportó algunas imágenes)
+ - [北极星 Polaris](https://github.com/polaris1119)(revisó todo el libro)
+ - [雨  痕 Rain Trail](https://github.com/qyuhen)(revisó el capítulo 2 y 3)
+
+### Licencia
+
+Este libro está licenciado bajo la [Licencia CC BY-SA 3.0](http://creativecommons.org/licenses/by-sa/3.0/),
+el código está licenciado bajo una [Licencia BSD 3-Clause](<https://github.com/astaxie/build-web-application-with-golang/blob/master/LICENSE.md>), a menos que se especifique de otra forma.

es/code/readme.md

@@ -0,0 +1,6 @@
+## Configuracíon del ambiente de trabajo.
+
+Para evitar problemas con el ambiente de trabajo y ser capaces de desarrollar desde cualquier ruta, establece la variable de entorno `GOPATH` a la ruta de este directorio.
+
+Más información:
+- [Documentación GOPATH](http://golang.org/doc/code.html#GOPATH)

es/code/src/apps/ch.1.2/main.go

@@ -0,0 +1,14 @@
+// Código de ejemplo para el capítulo 1.2 del libro "Construye Aplicaciones Web con Golang"
+// Propósito: Ejecuta este archivo para verificar que tu espacio de trabajo está configurado correctamente.
+// Para ejecutarlo, busca el directorio actual en la terminal y escribe `go run main.go`
+// Si el texto "Hello World" no se muestra, entonces configura tu ambiente de trabajo nuevamente.
+package main
+
+import (
+	"fmt"
+	"mymath"
+)
+
+func main() {
+	fmt.Printf("Hello, world.  Sqrt(2) = %v\n", mymath.Sqrt(2))
+}

es/code/src/mymath/sqrt.go

@@ -0,0 +1,12 @@
+// Código de ejmplo para el capítulo 1.2 de "Construye Aplicaciones Web con Golang"
+// Propósito: Muestra como crear un paquete simple llamado `mymath`
+// Este paquete debe ser importado desde otro archivo Go para poder ejecutarse.
+package mymath
+
+func Sqrt(x float64) float64 {
+	z := 0.0
+	for i := 0; i < 1000; i++ {
+		z -= (z*z - x) / (2 * x)
+	}
+	return z
+}