Merge branch 'master' of github.com:astaxie/build-web-application-with-golang

Author: M2shad0w

.gitignore

@@ -6,3 +6,6 @@ _book
 *.epub
 *.pdf
 .DS_Store
+.gitignore
+.vscode
+.git

de/09.4.md

@@ -32,7 +32,7 @@ If the user inputs a user name or password as:
 
 Then our SQL becomes the following:
 
-	SELECT * FROM user WHERE username='myuser' or 'foo'=='foo' --'' AND password='xxx'
+	SELECT * FROM user WHERE username='myuser' or 'foo' = 'foo' --'' AND password='xxx'
 
 In SQL, anything after `--` is a comment. Thus, inserting the `--` as the attacker did above alters the query in a fatal way, allowing an attacker to successfully login as a user without a valid password.
 

en/01.1.md

@@ -76,15 +76,15 @@ A 64-bit operating system will show the following:
 
 ### Mac
 
-Go to the [download page](https://golang.org/dl/), choose `go1.4.2.darwin-386.pkg` for 32-bit systems and `go1.7.4.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.
+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.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.7.4.linux-386.tar.gz` for 32-bit systems and `go1.7.4.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.7.4.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.
+Go to the [download page](https://golang.org/dl/), choose `go1.8.linux-386.tar.gz` for 32-bit systems and `go1.8.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.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.7.4.windows-386.msi` for 32-bit systems and `go1.7.4.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.
+Go to the [download page](https://golang.org/dl/), choose `go1.8.windows-386.msi` for 32-bit systems and `go1.8.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
 
@@ -96,8 +96,8 @@ GVM is a Go multi-version control tool developed by a third-party, like rvm for
 
 Then we install Go using the following commands:
 
-    gvm install go1.7.4
-    gvm use go1.7.4
+    gvm install go1.8
+    gvm use go1.8
 
 After the process has finished, you're all set.
 
@@ -109,16 +109,19 @@ Ubuntu is the most popular desktop release version of Linux. It uses `apt-get` t
     sudo apt-get update
     sudo apt-get install golang-stable
 
-###wget
+### wget
 ```sh
 
-wget https://storage.googleapis.com/golang/go1.7.4.linux-amd64.tar.gz
-sudo tar -xzf go1.7.4.linux-amd64.tar.gz -C /usr/local 
-export PATH=PATH:/usr/local/go/binexportGOROOT=HOME/go 
-export PATH=PATH:GOROOT/bin 
-export GOPATH=HOME/gowork 
-```    
+wget https://storage.googleapis.com/golang/go1.8.linux-amd64.tar.gz
+sudo tar -xzf go1.8.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.

en/01.2.md

@@ -4,15 +4,17 @@
 
 Go takes a unique approach to manage the code files with the introduction of a `$GOPATH` directory which contains all the go code in 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 `.bashrc` 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 is unset. It defaults to $HOME/go on Unix and %USERPROFILE%/go on Windows.
+
 In Unix-like systems, the variable should be used like this:
 
 	export GOPATH=/home/apple/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 break them up. At this point, `go get` will save the content to your first path in $GOPATH. So 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 anywhere. So please follow conventions, there is a reason conventions are created
+It's OK to have more than one path (workspace) in $GOPATH, but remember that you have to use `:`(`;` in Windows) to break them up. 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.
+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.
@@ -72,6 +74,8 @@ Create a new application package called `mathapp`.
 
 Write the following content to main.go.
 
+```Go
+
 	//$GOPATH/src/mathapp/main.go source code.
 	package main
 
@@ -83,7 +87,8 @@ Write the following content to main.go.
 	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
@@ -114,9 +119,9 @@ After executing the above commands, the directory structure should look like fol
 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.

en/01.4.md

@@ -468,7 +468,7 @@ Atom is an awesome text editor released as open source cross platform, built on
 
 Download: https://atom.io/
 
-##Gogland
+## Gogland
 
 Gogland is the codename for a new commercial IDE by JetBrains aimed at providing an ergonomic environment for Go development.
 

en/02.1.md

@@ -1,6 +1,7 @@
 ## What makes Go different from other languages?
 
 The Go programming language was created with one goal in mind, to be able to build scalable web-applications for large scale audiences in a large team. So that is the reason they made the language as standardized as possible, hence the `gofmt` tool and the strict usage guidelines to the language was for the sake of not having two factions in the developer base, in other languages there are religious wars on where to keep the opening brace?
+```java
 
     public static void main() {
 
@@ -11,6 +12,7 @@ The Go programming language was created with one goal in mind, to be able to bui
     {
 
     }
+```    
 or for python should we use 4 spaces or 6 spaces or a tab or two tabs and other user preferences.
 
 While this might seem to be a shallow problem at the top, but when the codebase grows and more and more people are working on the same code base, then it is difficult to maintain the code's "beauty", if you know python then you might be aware of PEP8, which is a set of guidelines about how to write elegant code. We live in a world where robots can drive a car, so we shouldn't just write code, we should write elegant code.
@@ -40,15 +42,15 @@ Before we start building an application in Go, we need to learn how to write a s
 According to international practice, before you learn how to program in some languages, you will want to know how to write a program to print "Hello world".
 
 Are you ready? Let's Go!
-
+```Go
 	package main
 
 	import "fmt"
 
 	func main() {
 		fmt.Printf("Hello, world or 你好，世界 or καλημ ́ρα κóσμ or こんにちは世界\n")
 	}
-	
+```	
 It prints following information.
 
 	Hello, world or 你好，世界 or καλημ ́ρα κóσμ or こんにちは世界
@@ -83,10 +85,11 @@ Each go file is in some package, and that package should be a distinct folder in
 the thing here is that when your code is using some static files or something else, then you ought to run the binary from the root of the application as we see in the second line above, I am running the `main` binary *outside* the main package, sometimes you might wonder why your application isn't working then this might be one of the possible problems, please keep this in mind.
 
 One thing you will notice here is that go doesn't see to use semi colons to end a statement, well, it does, just there is a minor catch, the programmer isn't expected to put semi colons, the compiler adds semi colons to the gocode when it compiles which is the reason that this (thankfully!) is a syntax error
-
+```Go
     func main ()
     {
     }
+```    
 because the compiler adds a semi colon at the end of `main()` which is a syntax error and as stated above, it helps avoid religious wars, i wish they combine `vim` and `emacs` and create a universal editor which'll help save some more wars! But for now we'll learn Go.
 
 ## Conclusion