initial thai translation

Author: taveek

th/01.0.md

@@ -0,0 +1,20 @@
+# 1 Go Environment Configuration
+
+Welcome to the world of Go, let's start exploring!
+
+Go is a fast-compiled, garbage-collected, concurrent systems programming language. It has the following advantages:
+
+- Compiles a large project within a few seconds.
+- Provides a software development model that is easy to reason about, avoiding most of the problems associated with C-style header files.
+- Is a static language that does not have levels in its type system, so users do not need to spend much time dealing with relations between types. It is more like a lightweight object-oriented language.
+- Performs garbage collection. It provides basic support for concurrency and communication.
+- Designed for multi-core computers.
+
+Go is a compiled language. It combines the development efficiency of interpreted or dynamic languages with the security of static languages. It is going to be the language of choice for modern, multi-core computers with networking. For these purposes, there are some problems that need to inherently be resolved at the level of the language of choice, such as a richly expressive lightweight type system, a native concurrency model, and strictly regulated garbage collection. For quite some time, no packages or tools have emerged that have aimed to solve all of these problems in a pragmatic fashion; thus was born the motivation for the Go language.
+
+In this chapter, I will show you how to install and configure your own Go development environment.
+
+## Links
+
+- [Directory](preface.md)
+- Next section: [Installation](01.1.md)

th/01.1.md

@@ -0,0 +1,148 @@
+# 1.1 Installation
+
+## Three ways to install Go
+
+There are many ways to configure the Go development environment on your computer, and you can choose whichever one you like. The three most common ways are as follows.
+
+
+-  Official installation packages.
+	- The Go team provides convenient installation packages in Windows, Linux, Mac and other operating systems. This is probably the easiest way to get started. You can get the installers from the [Golang Download Page](https://golang.org/dl/).
+- Install it yourself from source code.
+    -  Popular with developers who are familiar with Unix-like systems.
+- Using third-party tools.
+	- There are many third-party tools and package managers for installing Go, like apt-get in Ubuntu and homebrew for Mac.
+	
+In case you want to install more than one version of Go on a computer, you should take a look at a tool called [GVM](https://github.com/moovweb/gvm). It is the best tool I've seen so far for accomplishing this task, otherwise you'd have to deal with it yourself.
+
+## Install from source code
+
+To compile Go 1.5 and upwards, you only need the previous version of Go, as Go has achieved bootstrapping. You only need Go to compile Go.
+
+To compile Go 1.4 downwards, you will need a C compiler as some parts of Go are still written in Plan 9 C and AT&T assembler.
+
+On a Mac, if you have installed Xcode, you already have the compiler.
+
+On Unix-like systems, you need to install gcc or a similar compiler. For example, using the package manager apt-get (included with Ubuntu), one can install the required compilers as follows:
+
+```sh
+sudo apt-get install gcc libc6-dev
+```
+
+On Windows, you need to install MinGW in order to install gcc. Don't forget to configure your environment variables after the installation has completed.( ***Everything that looks like this means it's commented by a translator: If you are using 64-bit Windows, you should install the 64-bit version of MinGW*** )
+
+At this point, execute the following commands to clone the Go source code and compile it.( ***It will clone the source code to your current directory. Switch your work path before you continue. This may take some time.*** )
+
+	git clone https://go.googlesource.com/go
+	cd go/src
+	./all.bash 
+	
+A successful installation will end with the message "ALL TESTS PASSED."
+
+On Windows, you can achieve the same by running `all.bat`.
+
+If you are using Windows, the installation package will set your environment variables automatically. In Unix-like systems, you need to set these variables manually as follows. ( ***If your Go version is greater than 1.0, you don't have to set $GOBIN, and it will automatically be related to your $GOROOT/bin, which we will talk about in the next section***)
+
+    export GOROOT=$HOME/go
+    export GOBIN=$GOROOT/bin
+    export PATH=$PATH:$GOROOT/bin
+
+If you see the following information on your screen, you're all set.
+
+![](images/1.1.mac.png?raw=true)
+
+Figure 1.1 Information after installing from source code
+
+Once you see the usage information of Go, it means you have successfully installed Go on your computer. If it says "no such command", check that your $PATH environment variable contains the installation path of Go.
+
+## Using the standard installation packages
+
+Go has one-click installation packages for every supported operating system. These packages will install Go in `/usr/local/go` (`c:\Go` in Windows) by default. Of course this can be modified, but you also need to change all the environment variables manually as I've shown above.
+
+### How to check if your operating system is 32-bit or 64-bit?
+
+Our next step depends on your operating system type, so we have to check it before we download the standard installation packages.
+
+If you are using Windows, press `Win+R` and then run the command tool. Type the `systeminfo` command and it will show you some useful system information. Find the line that says "system type" -if you see "x64-based PC" that means your operating system is 64-bit, 32-bit otherwise.
+
+I strongly recommend downloading the 64-bit package if you are a Mac user, as Go no longer supports pure 32-bit processors on Mac OSX.
+
+Linux users can type `uname -a` in the terminal to see system information.
+A 64-bit operating system will show the following:
+
+    <some description> x86_64 x86_64 x86_64 GNU/Linux
+    // some machines such as Ubuntu 10.04 will show as following
+    x86_64 GNU/Linux
+
+32-bit operating systems instead show:
+
+    <some description> i686 i686 i386 GNU/Linux
+
+### Mac
+
+Go to the [download page](https://golang.org/dl/), choose `go1.4.2.darwin-386.pkg` (The later version has no 32-bit download.)for 32-bit systems and `go1.8.3.darwin-amd64.pkg` for 64-bit systems. Going all the way to the end by clicking "next", `~/go/bin` will be added to your system's $PATH after you finish the installation. Now open the terminal and type `go`. You should see the same output shown in figure 1.1.
+
+### Linux
+
+Go to the [download page](https://golang.org/dl/), choose `go1.8.3.linux-386.tar.gz` for 32-bit systems and `go1.8.3.linux-amd64.tar.gz` for 64-bit systems. Suppose you want to install Go in the `$GO_INSTALL_DIR` path. Uncompress the `tar.gz` to your chosen path using the command `tar zxvf go1.8.3.linux-amd64.tar.gz -C $GO_INSTALL_DIR`. Then set your $PATH with the following: `export PATH=$PATH:$GO_INSTALL_DIR/go/bin`. Now just open the terminal and type `go`. You should now see the same output displayed in figure 1.1.
+
+### Windows
+
+Go to the [download page](https://golang.org/dl/), choose `go1.8.3.windows-386.msi` for 32-bit systems and `go1.8.3.windows-amd64.msi` for 64-bit systems. Going all the way to the end by clicking "next", `c:/go/bin` will be added to `path`. Now just open a command line window and type `go`. You should now see the same output displayed in figure 1.1.
+
+## Use third-party tools
+
+### GVM
+
+GVM is a Go multi-version control tool developed by a third-party, like rvm for ruby. It's quite easy to use. Install gvm by typing the following commands in your terminal:
+
+    bash < <(curl -s -S -L https://raw.github.com/moovweb/gvm/master/binscripts/gvm-installer)
+
+Then we install Go using the following commands:
+
+    gvm install go1.8.3
+    gvm use go1.8.3
+
+After the process has finished, you're all set.
+
+### apt-get
+
+Ubuntu is the most popular desktop release version of Linux. It uses `apt-get` to manage packages. We can install Go using the following commands.
+
+    sudo add-apt-repository ppa:gophers/go
+    sudo apt-get update
+    sudo apt-get install golang-go
+
+### wget
+```sh
+
+wget https://storage.googleapis.com/golang/go1.8.3.linux-amd64.tar.gz
+sudo tar -xzf go1.8.3.linux-amd64.tar.gz -C /usr/local 
+
+# Go environment
+export GOROOT=/usr/local/go
+export GOBIN=$GOROOT/bin
+export PATH=$PATH:$GOBIN
+export GOPATH=$HOME/gopath 
+```    
+Starting from go 1.8, The GOPATH environment variable now has a default value if it is unset. It defaults to `$HOME/go` on Unix and `%USERPROFILE%/go` on Windows.
+### Homebrew
+
+Homebrew is a software management tool commonly used in Mac to manage packages. Just type the following commands to install Go.
+
+1. Install Homebrew
+
+```sh
+     /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
+```
+
+2. Install Go
+
+```sh
+    brew update && brew upgrade
+    brew install go
+```
+## Links
+
+- [Directory](preface.md)
+- Previous section: [Go environment configuration](01.0.md)
+- Next section: [$GOPATH and workspace](01.2.md)

th/01.2.md

@@ -0,0 +1,156 @@
+# 1.2 $GOPATH and workspace
+
+## $GOPATH
+
+Go takes a unique approach to manage the code files with the introduction of a `$GOPATH` directory which contains all the go code on the machine. Note that this is different from the `$GOROOT` environment variable which states where go is installed on the machine. We have to define the `$GOPATH` variable before using the language, in *nix systems there is a file called `.profile` we need to append the below export statement to the file. The concept behind gopath is a novel one, where we can link to any go code at any instant of time without ambiguity.
+
+Starting from go 1.8, the GOPATH environment variable now has a default value if it not set: it defaults to `$HOME/go` on Unix and `%USERPROFILE%/go` on Windows.
+
+On Unix-like systems, the variable should be used like this:
+	
+	export GOPATH=${HOME}/mygo
+	
+In Windows, you need to create a new environment variable called GOPATH, then set its value to `c:\mygo`( ***This value depends on where your workspace is located*** )
+
+It's OK to have more than one path (workspace) in `$GOPATH`, but remember that you have to use `:`(`;` in Windows) to separate them. At this point, `go get` will save the content to your first path in `$GOPATH`. It is highly recommended to not have multiples versions, the worst case is to create a folder by the name of your project right inside `$GOPATH`, it breaks everything that the creators were wishing to change in programming with the creation of go language because when you create a folder inside `$GOPATH` you will reference your packages as directly as <packagename>, and this breaks all the applications which will import your package because the `go get` won't find your package. Please follow conventions, there is a reason conventions are created.
+
+In `$GOPATH`, you must have three folders as follows:
+
+- `src` for source files whose suffix is .go, .c, .g, .s.
+- `pkg` for compiled files whose suffix is .a.
+- `bin` for executable files
+
+In this book, I use `mygo` as my only path in `$GOPATH`.
+
+## Package directory
+
+Create package source files and folders like `$GOPATH/src/mymath/sqrt.go` (`mymath` is the package name) ( ***Author uses `mymath` as his package name, and the same name for the folder that contains the package source files***)
+
+Every time you create a package, you should create a new folder in the `src` directory, with the notable exception of main, for which `main` folder creation is optional. Folder names are usually the same as the package that you are going to use. You can have multi-level directories if you want to. For example, if you create the directory `$GOPATH/src/github.com/astaxie/beedb`, then the package path would be `github.com/astaxie/beedb`. The package name will be the last directory in your path, which is `beedb` in this case.
+
+Execute following commands. ( ***Now author goes back to talk examples*** )
+
+	cd $GOPATH/src
+	mkdir mymath
+	
+Create a new file called `sqrt.go`, type the following content to your file.
+```Go
+// Source code of $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
+}
+```	
+Now my package directory has been created and its code has been written. I recommend that you use the same name for your packages as their corresponding directories, and that the directories contain all of the package source files.
+
+## Compile packages
+
+We've already created our package above, but how do we compile it for practical purposes? There are two ways to do this.
+
+1. Switch your work path to the directory of your package, then execute the `go install` command.
+2. Execute the above command except with a file name, like `go install mymath`.
+
+After compiling, we can open the following folder.
+
+	cd $GOPATH/pkg/${GOOS}_${GOARCH}
+	// you can see the file was generated
+	mymath.a
+	
+The file whose suffix is `.a` is the binary file of our package. How do we use it?
+
+Obviously, we need to create a new application to use it.
+
+Create a new application package called `mathapp`.
+
+	cd $GOPATH/src
+	mkdir mathapp
+	cd mathapp
+	vim main.go
+	
+Write the following content to main.go.
+
+```Go
+
+//$GOPATH/src/mathapp/main.go source code.
+package main
+
+import (
+	"mymath"
+	"fmt"
+)
+
+func main() {
+	fmt.Printf("Hello, world. Sqrt(2) = %v\n", mymath.Sqrt(2))
+}
+```
+
+To compile this application, you need to switch to the application directory, which in this case is `$GOPATH/src/mathapp`, then execute the `go install` command. Now you should see an executable file called `mathapp` was generated in the directory `$GOPATH/bin/`. To run this program, use the `./mathapp` command. You should see the following content in your terminal. 
+
+	Hello world. Sqrt(2) = 1.414213562373095
+	
+## Install remote packages
+
+Go has a tool for installing remote packages, which is a command called `go get`. It supports most open source communities, including Github, Google Code, BitBucket, and Launchpad.
+
+	go get github.com/astaxie/beedb
+	
+You can use `go get -u …` to update your remote packages and it will automatically install all the dependent packages as well.
+
+This tool will use different version control tools for different open source platforms. For example, `git` for Github and `hg` for Google Code. Therefore, you have to install these version control tools before you use `go get`.
+
+After executing the above commands, the directory structure should look like following.
+
+	$GOPATH
+		src
+		 |-github.com
+		 	 |-astaxie
+		 	 	 |-beedb
+		pkg
+		 |--${GOOS}_${GOARCH}
+		 	 |-github.com
+		 	 	 |-astaxie
+		 	 	 	 |-beedb.a
+		 	 	 	 
+Actually, `go get` clones source code to the `$GOPATH/src` of the local file system, then executes `go install`.
+
+You can use remote packages in the same way that we use local packages.
+```Go
+import "github.com/astaxie/beedb"
+```
+## Directory complete structure
+
+If you've followed all of the above steps, your directory structure should now look like the following.
+
+	bin/
+		mathapp
+	pkg/
+		${GOOS}_${GOARCH}, such as 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
+					
+Now you are able to see the directory structure clearly: `bin` contains executable files, `pkg` contains compiled files and `src` contains package source files.
+
+(The format of environment variables in Windows is `%GOPATH%`, however this book mainly follows the Unix-style, so Windows users need to replace these yourself.)
+
+## Links
+
+- [Directory](preface.md)
+- Previous section: [Installation](01.1.md)
+- Next section: [Go commands](01.3.md)