adding minor changes

Author: ldynia

en/02.1.md

@@ -6,9 +6,9 @@ The Go programming language was created with one goal in mind, to be able to bui
     public static void main() {
 
     }
-    
-    or 
-    public static void main() 
+
+    or
+    public static void main()
     {
 
     }
@@ -21,13 +21,13 @@ For other languages there are many variables when it comes to writing code, ever
 
 So to mitigate all the problems that Google faced with the current tools, they wrote a systems language called Go, which you are about to learn! There are many advantages to using golang, and there might be disadvantages too for every coin has both sides. But significant improvements in places like code formatting, since they designed the language in such a way that there won't be wars on how to format code, the gocode written by anyone in the world (assuming they know and use `gofmt`) will look exactly the same, this won't seem to matter until you work in a team! also when the company uses automated code review or some other fancy technique then in other languages which don't have strict and standard formatting rules then the code might get screwed up, but not in go!
 
-Go was designed with concurrency in mind, please note that parallelism != concurrency, there is an amazing post by Rob Pike on the golang blog, blog.golang.org, you will find it there, it is worth a read.
+Go was designed with concurrency in mind, please note that parallelism != concurrency, there is an amazing post by Rob Pike on the golang blog, [www.blog.golang.org](https://blog.golang.org/concurrency-is-not-parallelism), you will find it there, it is worth a read.
 
 Another very important change that go has brought in programming that I personally love is the concept of `GOPATH`, gone are the days when you had to create a folder called `code` and then create workspaces for eclipse and what not, now you have to keep one folder tree for go code and it'll be updated by the package manager automatically. Also under the code we are recommended to create folders with either a custom domain or the github domain, for example I created a task manager using golang so I created a set of folders
 `~/go/src/github.com/thewhitetulip/Tasks` note: In *nix systems `~` stands for home directory, which is the windows equivalent of `C:\\Users\\username`
 now the `~/go/` is the universe for the gocode in your machine, it is just a significant improvement over other languages so we can store the code efficiently without hassles, it might seem strange at first, but it does make a lot of sense over the ridiculous package names some other languages use like reverse domains.
 
-note: along with src there are two folders `pkg` which is for packages and `bin` which is for binary
+**Note:** Along with `src` there are two folders `pkg` which is for packages and `bin` which is for binary.
 
 This `GOPATH` advantage isn't just restricted to storing code in particular folder, but when you have created five packages for your project then you don't have to import them like `"import ./db"`, you can give it `import "github.com/thewhitetulip/Tasks/db"`, so while doing a `go get` on my repo, the `go` tool will find the package from `github.com/...` path if it wasn't downloaded initially, it just standardizes a lot of screwed up things in the programming discipline.
 
@@ -44,17 +44,17 @@ According to international practice, before you learn how to program in some lan
 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 こんにちは世界
-	
+
 ## Explanation
 
 One thing that you should know in the first is that Go programs are composed by `package`.
@@ -75,7 +75,7 @@ On the sixth line, we called the function `Printf` which is from the package `fm
 
 As we mentioned in chapter 1, the package's name and the name of the folder that contains that package can be different. Here the `<pkgName>` comes from the name in `package <pkgName>`, not the folder's name.
 
-You may notice that the example above contains many non-ASCII characters. The purpose of showing this is to tell you that Go supports UTF-8 by default. You can use any UTF-8 character in your programs. 
+You may notice that the example above contains many non-ASCII characters. The purpose of showing this is to tell you that Go supports UTF-8 by default. You can use any UTF-8 character in your programs.
 
 Each go file is in some package, and that package should be a distinct folder in the GOPATH, but main is a special package which doesn't require a `main` folder. This is one aspect which they left out for standardization! But should you choose to make a main folder then you have to ensure that you run the binary properly. Also one go code can't have more than one `main` go file.
 

en/02.2.md

@@ -15,60 +15,60 @@ Define multiple variables.
 ```Go
 // define three variables which types are "type"
 var vname1, vname2, vname3 type
-```	
+```
 Define a variable with initial value.
 ```Go
 // define a variable with name “variableName”, type "type" and value "value"
 var variableName type = value
-```	
+```
 Define multiple variables with initial values.
 ```Go
 /*
     Define three variables with type "type", and initialize their values.
     vname1 is v1, vname2 is v2, vname3 is v3
 */
 var vname1, vname2, vname3 type = v1, v2, v3
-```	
+```
 Do you think that it's too tedious to define variables use the way above? Don't worry, because the Go team has also found
-this to be a problem. Therefore if you want to define variables with initial values, we can just omit the variable type, 
+this to be a problem. Therefore if you want to define variables with initial values, we can just omit the variable type,
 so the code will look like this instead:
 ```Go
 /*
     Define three variables without type "type", and initialize their values.
     vname1 is v1，vname2 is v2，vname3 is v3
 */
 var vname1, vname2, vname3 = v1, v2, v3
-```	
+```
 Well, I know this is still not simple enough for you. Let's see how we fix it.
 ```Go
 /*
     Define three variables without type "type" and without keyword "var", and initialize their values.
     vname1 is v1，vname2 is v2，vname3 is v3
 */
 vname1, vname2, vname3 := v1, v2, v3
-```	
-Now it looks much better. Use `:=` to replace `var` and `type`, this is called a brief statement. But wait, it has one limitation: this form can only be used inside of functions. You will get compile errors if you try to use it outside of function bodies. Therefore, we usually use `var` to define global variables.
+```
+Now it looks much better. Use `:=` to replace `var` and `type`, this is called a **short assignment**. It has one limitation: this form can only be used inside of a functions. You will get compile errors if you try to use it outside of function bodies. Therefore, we usually use `var` to define global variables.
 
 `_` (blank) is a special variable name. Any value that is given to it will be ignored. For example, we give `35` to `b`, and discard `34`.( ***This example just show you how it works. It looks useless here because we often use this symbol when we get function return values.*** )
 ```Go
 _, b := 34, 35
-```	
+```
 If you don't use variables that you've defined in your program, the compiler will give you compilation errors. Try to compile the following code and see what happens.
 ```Go
 package main
 
 func main() {
     var i int
 }
-```	
+```
 ## Constants
 
 So-called constants are the values that are determined during compile time and you cannot change them during runtime. In Go, you can use number, boolean or string as types of constants.
 
 Define constants as follows.
 ```Go
 const constantName = value
-// you can assign type of constants if it's necessary 
+// you can assign type of constants if it's necessary
 const Pi float32 = 3.1415926
 ```
 More examples.
@@ -77,7 +77,7 @@ const Pi = 3.1415926
 const i = 10000
 const MaxThread = 10
 const prefix = "astaxie_"
-```	
+```
 ## Elementary types
 
 ### Boolean
@@ -93,7 +93,7 @@ func test() {
     valid := false      // brief statement of variable
     available = true    // assign value to variable
 }
-```	
+```
 ### Numerical types
 
 Integer types include both signed and unsigned integer types. Go has `int` and `uint` at the same time, they have same length, but specific length depends on your operating system. They use 32-bit in 32-bit operating systems, and 64-bit in 64-bit operating systems. Go also has types that have specific length including `rune`, `int8`, `int16`, `int32`, `int64`, `byte`, `uint8`, `uint16`, `uint32`, `uint64`. Note that `rune` is alias of `int32` and `byte` is alias of `uint8`.
@@ -115,7 +115,7 @@ That's all? No! Go supports complex numbers as well. `complex128` (with a 64-bit
 var c complex64 = 5+5i
 //output: (5+5i)
 fmt.Printf("Value is: %v", c)
-```	
+```
 ### String
 
 We just talked about how Go uses the UTF-8 character set. Strings are represented by double quotes `""` or backticks ``` `` ```.
@@ -133,28 +133,28 @@ It's impossible to change string values by index. You will get errors when you c
 ```Go
 var s string = "hello"
 s[0] = 'c'
-```	
+```
 What if I really want to change just one character in a string? Try the following code.
 ```Go
 s := "hello"
 c := []byte(s)  // convert string to []byte type
 c[0] = 'c'
 s2 := string(c)  // convert back to string type
 fmt.Printf("%s\n", s2)
-```	
+```
 You use the `+` operator to combine two strings.
 ```Go
 s := "hello,"
 m := " world"
 a := s + m
 fmt.Printf("%s\n", a)
-```	
+```
 and also.
 ```Go
 s := "hello"
 s = "c" + s[1:] // you cannot change string values by index, but you can get values instead.
 fmt.Printf("%s\n", s)
-```	
+```
 What if I want to have a multiple-line string?
 ```Go
 m := `hello
@@ -170,7 +170,7 @@ err := errors.New("emit macho dwarf: elf header corrupted")
 if err != nil {
     fmt.Print(err)
 }
-```	
+```
 ### Underlying data structure
 
 The following picture comes from an article about [Go data structure](http://research.swtch.com/godata) in [Russ Cox's Blog](http://research.swtch.com/). As you can see, Go utilizes blocks of memory to store data.
@@ -197,7 +197,7 @@ const prefix = "Go_"
 var i int
 var pi float32
 var prefix string
-```	
+```
 Group form.
 ```Go
 import(
@@ -216,7 +216,7 @@ var(
     pi float32
     prefix string
 )
-```	
+```
 Unless you assign the value of constant is `iota`, the first value of constant in the group `const()` will be `0`. If following constants don't assign values explicitly, their values will be the same as the last one. If the value of last constant is `iota`, the values of following constants which are not assigned are `iota` also.
 
 ### iota enumerate
@@ -227,13 +227,13 @@ const(
     x = iota  // x == 0
     y = iota  // y == 1
     z = iota  // z == 2
-    w  // If there is no expression after the constants name, it uses the last expression, 
+    w  // If there is no expression after the constants name, it uses the last expression,
     //so it's saying w = iota implicitly. Therefore w == 3, and y and z both can omit "= iota" as well.
 )
 
 const v = iota // once iota meets keyword `const`, it resets to `0`, so v = 0.
 
-const ( 
+const (
   e, f, g = iota, iota, iota // e=0,f=0,g=0 values of iota are same in one line.
 )
 ```
@@ -251,25 +251,25 @@ The reason that Go is concise because it has some default behaviors.
 `array` is an array obviously, we define one as follows.
 ```Go
 var arr [n]type
-```	
+```
 in `[n]type`, `n` is the length of the array, `type` is the type of its elements. Like other languages, we use `[]` to get or set element values within arrays.
 ```Go
 var arr [10]int  // an array of type [10]int
 arr[0] = 42      // array is 0-based
 arr[1] = 13      // assign value to element
 fmt.Printf("The first element is %d\n", arr[0])  
 // get element value, it returns 42
-fmt.Printf("The last element is %d\n", arr[9]) 
+fmt.Printf("The last element is %d\n", arr[9])
 //it returns default value of 10th element in this array, which is 0 in this case.
-```	
+```
 Because length is a part of the array type, `[3]int` and `[4]int` are different types, so we cannot change the length of arrays. When you use arrays as arguments, functions get their copies instead of references! If you want to use references, you may want to use `slice`. We'll talk about later.
 
 It's possible to use `:=` when you define arrays.
 ```Go
 a := [3]int{1, 2, 3} // define an int array with 3 elements
 
-b := [10]int{1, 2, 3} 
-// define a int array with 10 elements, of which the first three are assigned. 
+b := [10]int{1, 2, 3}
+// define a int array with 10 elements, of which the first three are assigned.
 //The rest of them use the default value 0.
 
 c := [...]int{4, 5, 6} // use `…` to replace the length parameter and Go will calculate it for you.
@@ -281,7 +281,7 @@ doubleArray := [2][4]int{[4]int{1, 2, 3, 4}, [4]int{5, 6, 7, 8}}
 
 // The declaration can be written more concisely as follows.
 easyArray := [2][4]int{{1, 2, 3, 4}, {5, 6, 7, 8}}
-```	
+```
 Array underlying data structure.
 
 ![](images/2.2.array.png?raw=true)
@@ -300,8 +300,8 @@ var fslice []int
 Then we define a `slice`, and initialize its data.
 ```Go
 slice := []byte {'a', 'b', 'c', 'd'}
-```	
-`slice` can redefine existing slices or arrays. `slice` uses `array[i:j]` to slice, where `i` is 
+```
+`slice` can redefine existing slices or arrays. `slice` uses `array[i:j]` to slice, where `i` is
 the start index and `j` is end index, but notice that `array[j]` will not be sliced since the length
 of the slice is `j-i`.
 ```Go
@@ -318,8 +318,8 @@ a = ar[2:5]
 // 'b' is another slice of array ar
 b = ar[3:5]
 // now 'b' has elements ar[3] and ar[4]
-```	
-Notice the differences between `slice` and `array` when you define them. We use `[…]` to let Go 
+```
+Notice the differences between `slice` and `array` when you define them. We use `[…]` to let Go
 calculate length but use `[]` to define slice only.
 
 Their underlying data structure.
@@ -353,8 +353,8 @@ bSlice = aSlice[:3]  // bSlice contains aSlice[0], aSlice[1], aSlice[2], so it h
 bSlice = aSlice[0:5] // slice could be expanded in range of cap, now bSlice contains d,e,f,g,h
 bSlice = aSlice[:]   // bSlice has same elements as aSlice does, which are d,e,f,g
 ```
-`slice` is a reference type, so any changes will affect other variables pointing to the same slice or array. 
-For instance, in the case of `aSlice` and `bSlice` above, if you change the value of an element in `aSlice`, 
+`slice` is a reference type, so any changes will affect other variables pointing to the same slice or array.
+For instance, in the case of `aSlice` and `bSlice` above, if you change the value of an element in `aSlice`,
 `bSlice` will be changed as well.
 
 `slice` is like a struct by definition and it contains 3 parts.
@@ -379,24 +379,24 @@ There are some built-in functions for slice.
 - `append` appends one or more elements to `slice`, and returns `slice` .
 - `copy` copies elements from one slice to the other, and returns the number of elements that were copied.
 
-Attention: `append` will change the array that `slice` points to, and affect other slices that point to the same array. 
-Also, if there is not enough length for the slice (`(cap-len) == 0`), `append` returns a new array for this slice. When 
+Attention: `append` will change the array that `slice` points to, and affect other slices that point to the same array.
+Also, if there is not enough length for the slice (`(cap-len) == 0`), `append` returns a new array for this slice. When
 this happens, other slices pointing to the old array will not be affected.
 
 ### map
 
 `map` behaves like a dictionary in Python. Use the form `map[keyType]valueType` to define it.
 
 Let's see some code. The 'set' and 'get' values in `map` are similar to `slice`, however the index in `slice` can only be
-of type 'int' while `map` can use much more than that: for example `int`, `string`, or whatever you want. Also, they are 
+of type 'int' while `map` can use much more than that: for example `int`, `string`, or whatever you want. Also, they are
 all able to use `==` and `!=` to compare values.
 ```Go
 // use string as the key type, int as the value type, and `make` initialize it.
 var numbers map[string] int
 // another way to define map
 numbers := make(map[string]int)
 numbers["one"] = 1  // assign value by key
-numbers["ten"] = 10 
+numbers["ten"] = 10
 numbers["three"] = 3
 
 fmt.Println("The third number is: ", numbers["three"]) // get values
@@ -415,7 +415,7 @@ Use `delete` to delete an element in `map`.
 ```Go
 // Initialize a map
 rating := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
-// map has two return values. For the second return value, if the key doesn't 
+// map has two return values. For the second return value, if the key doesn't
 //exist，'ok' returns false. It returns true otherwise.
 csharpRating, ok := rating["C#"]
 if ok {
@@ -426,25 +426,25 @@ if ok {
 
 delete(rating, "C")  // delete element with key "c"
 ```
-As I said above, `map` is a reference type. If two `map`s point to same underlying data, 
+As I said above, `map` is a reference type. If two `map`s point to same underlying data,
 any change will affect both of them.
 ```Go
 m := make(map[string]string)
 m["Hello"] = "Bonjour"
 m1 := m
 m1["Hello"] = "Salut"  // now the value of m["hello"] is Salut
-```	
+```
 ### make, new
 
-`make` does memory allocation for built-in models, such as `map`, `slice`, and `channel`, while `new` is for types' 
+`make` does memory allocation for built-in models, such as `map`, `slice`, and `channel`, while `new` is for types'
 memory allocation.
 
-`new(T)` allocates zero-value to type `T`'s memory, returns its memory address, which is the value of type `*T`. By Go's 
+`new(T)` allocates zero-value to type `T`'s memory, returns its memory address, which is the value of type `*T`. By Go's
 definition, it returns a pointer which points to type `T`'s zero-value.
 
 `new` returns pointers.
 
-The built-in function `make(T, args)` has different purposes than `new(T)`. `make` can be used for `slice`, `map`, 
+The built-in function `make(T, args)` has different purposes than `new(T)`. `make` can be used for `slice`, `map`,
 and `channel`, and returns a type `T` with an initial value. The reason for doing this is because the underlying data of
 these three types must be initialized before they point to them. For example, a `slice` contains a pointer that points to
 the underlying `array`, length and capacity. Before these data are initialized, `slice` is `nil`, so for `slice`, `map`
@@ -471,7 +471,7 @@ float32 0 // length is 4 byte
 float64 0 //length is 8 byte
 bool    false
 string  ""
-```	
+```
 ## Links
 
 - [Directory](preface.md)