Cuneytt · October 4, 2017 21:01 · Feb 28, 2015 · Feb 28, 2015 · Feb 28, 2015 · Feb 28, 2015
diff --git a/The Three Go Landmines → The Three Go Landmines.markdown b/The Three Go Landmines → The Three Go Landmines.markdown
diff --git a/The Three Go Landmines b/The Three Go Landmines
@@ -81,4 +81,4 @@ func DoTheThing(reallyDoIt bool) (err error) {
 }
 ```
 
-The above function will *always* return a nil error, because the inner err variable "shadows" the function scope variable. Adding a ```var result string``` and not using ```:=``` would fix this. 
+The above function will *always* return a nil error, because the inner err variable "shadows" the function scope variable. Adding a ```var result string``` and not using ```:=``` would fix this.
diff --git a/The Three Go Landmines b/The Three Go Landmines
@@ -81,4 +81,4 @@ func DoTheThing(reallyDoIt bool) (err error) {
 }
 ```
 
-The above function will *always* return a nil error, because the inner err variable "shadows" the function scope variable. Adding a ```var result string``` and not using ```:=``` would fix this.
+The above function will *always* return a nil error, because the inner err variable "shadows" the function scope variable. Adding a ```var result string``` and not using ```:=``` would fix this. 
diff --git a/The Three Go Landmines b/The Three Go Landmines
@@ -0,0 +1,84 @@
+There are three easy to make mistakes in go. I present them here in the way they are often found in the wild, not in the way that is easiest to understand.
+
+All three of these mistakes have been made in Kubernetes code, getting past code review at least once each that I know of.
+
+1. Loop variables are scoped outside the loop.
+
+What do these lines do? Make predictions and then scroll down.
+
+```go
+func print(pi *int) { fmt.Println(*pi) }
+
+for i := 0; i < 10; i++ {
+  defer fmt.Println(i)
+  defer func(){ fmt.Println(i) }()
+  defer func(i int){ fmt.Println(i) }(i)
+  defer print(&i)
+  go fmt.Println(i)
+  go func(){ fmt.Println(i) }()
+}
+```
+
+Answers:
+
+```go
+func print(pi *int) { fmt.Println(*pi) }
+
+for i := 0; i < 10; i++ {
+  defer fmt.Println(i) // OK; prints 9 ... 0
+  defer func(){ fmt.Println(i) }() // WRONG; prints "10" 10 times
+  defer func(i int){ fmt.Println(i) }(i) // OK
+  defer print(&i) // WRONG; prints "10" 10 times
+  go fmt.Println(i) // OK; prints 0 ... 9 in unpredictable order
+  go func(){ fmt.Println(i) }() // WRONG; totally unpredictable.
+}
+
+for key, value := range myMap {
+  // Same for key & value as i!
+}
+```
+
+Everyone expects these values to be scoped inside the loop, but go reuses the same memory location for every iteration. This means that you must never let the address of ```key```, ```value```, or ```i``` above escape the loop. An anonymous ```func() { /* do something with i */ }``` (a "closure") is a subtle way of taking a variable's address
+
+2. Nil interface is not the same as having a nil pointer in the interface.
+
+```go
+type Cat interface {
+  Meow()
+}
+
+type Tabby struct {}
+func (*Tabby) Meow() { fmt.Println("meow") }
+
+func GetACat() Cat {
+  var myTabby *Tabby = nil
+  // Oops, we forgot to set myTabby to a real value
+  return myTabby
+}
+
+func TestGetACat(t *testing.T) {
+  if GetACat() == nil {
+    t.Errorf("Forgot to return a real cat!")
+  }
+}
+```
+
+Guess what? The above test will NOT detect the nil pointer! This is because the interface serves as a pointer, so GetACat effectively returns a pointer to a nil pointer. Never do the thing that GetACat does, and you (and your coworkers) will be much happier. It is *very* easy to do this with error values. http://golang.org/doc/faq#nil_error
+
+3. Shadowing considered harmful to your sanity.
+
+```go
+var ErrDidNotWork = errors.New("did not work")
+
+func DoTheThing(reallyDoIt bool) (err error) {
+  if reallyDoIt {
+    result, err := tryTheThing()
+    if err != nil || result != "it worked" {
+      err = ErrDidNotWork
+    }
+  }
+  return err
+}
+```
+
+The above function will *always* return a nil error, because the inner err variable "shadows" the function scope variable. Adding a ```var result string``` and not using ```:=``` would fix this.
No results found