How to avoid Go gotchas - Ivan Daniluk - Codemotion Milan 2016

How to avoid Go gotchas
by learning internals
Ivan Danyliuk, Codemotion Milano 
26 Nov 2016

Gotchas
• Go has some gotchas
• Good examples:
• 50 Shades of Go: Traps, Gotchas, and Common Mistakes for New
Golang Devs
• Go Traps
• Golang slice append gotcha

Gotchas
• Luckily, Go has very few gotchas
• Especially in comparison with other languages
Go
C++
0 75 150 225 300

Gotchas
• So, what is gotcha?
• “a gotcha is a valid construct in a system, program or
programming language that works as documented but is counter-
intuitive and almost invites mistakes because it is both easy to
invoke and unexpected or unreasonable in its outcome”

Gotchas
• Two solutions:
• “fix” the language
• fix the intuition.
• Let’s build some intuition to fight gotchas then.

Gotchas
• Let’s learn some internals and in memory representations
• It worked for me, should work for you as well.

basic types
Code:
i := 1234
j := int32(4)
i64 := int64(999)
f := float32(3.14)

Code:
i := 1234
j := int32(4)
i64 := int64(999)
f := float32(3.14)
1234
i
4
j
3.14
fi64
999
int int32
ﬂoat32int64
basic types

structs
Code:
type Point struct {
X, Y int
}
p1 := Point{10, 20}
10
int
20
int
p1

Code:
type Point struct {
X, Y int
}
p1 := Point{10, 20}
p2 := &Point{10, 20}
10
int
20
int
p1
10
int
20
int
p2
0x..
*Point
basic types

structs
Code:
func Foo(p Point) {
// ...
}
p1 := Point{10, 20}
Foo(p1)
10
int
20
int
p1
10
int
20
int
Foo()
copy

structs
Code:
func Foo(p *Point) {
// ...
}
p2 := &Point{10, 20}
Foo(p2)
Foo()
copy
10
int
20
int
p2
0x..
*Point
0x..

array
var arr [5]int
Go code: src/runtime/malloc.go
// newarray allocates an array of n elements of type typ.
func newarray(typ *_type, n int) unsafe.Pointer {
if n < 0 || uintptr(n) > maxSliceCap(typ.size) {
panic(plainError("runtime: allocation size out of range"))
}
return mallocgc(typ.size*uintptr(n), typ, true)
}
Code:

array
var arr [5]int
Code:
int
Memory:

array
var arr [5]int
Code: 4 or 8 bytes blocks
(32 or 64 bit arch)
int
Memory:

array
var arr [5]int
Code:
int
0 1 2 3 4
Memory:

array
var arr [5]int
Code:
int
0 1 2 3 4
0 0 0 0 0
Memory:

array
Code:
Memory:
int
0 1 2 3 4
0 0 0 0 42
var arr [5]int
arr[4] = 42

slice
var foo []int
Code:
Go code: src/runtime/slice.go
type slice struct {
array unsafe.Pointer
len int
cap int
}

slice
var foo []int
Code:
Go code: src/runtime/slice.go
array
len
cap
0 1 2 3 4
foo
type slice struct {
array unsafe.Pointer
len int
cap int
}

slice
Code:
array
len
cap
0 1 2 3 4
nil
0
0
var foo []int
foo

slice
var foo []int
foo = make([]int, 5)
Code:
array
len
cap
000 0 0
0x..
5
5
0 1 2 3 4
0 1 2 3 4
foo

slice
var foo []int
foo = make([]int, 3, 5)
Code:
array
len
cap
00 0
0x..
3
5
0 1 2 3 4
0 1 2 3 4
foo

slice
var foo []int
foo[3] = 42
foo[4] = 100
Code:
array
len
cap
4200 0 100
0 1 2 3 4
0x..
5
5
0 1 2 3 4
0 1 2 3 4
foo

slice
Code:
array
len
cap
0x..
5
5
var foo []int
foo[3] = 42
foo[4] = 100
bar := foo[1:4]
4200 0 100
0 1 2 3 40 1 2 3 4
0 1 2 3 4
foo

slice
Code:
array
len
cap
4200 0 100
0
1 2 3 4
0x..
5
5
0
1 2 3 4
0 1 2 3 4
var foo []int
foo[3] = 42
foo[4] = 100
bar := foo[1:4]
array
len
cap
bar
0x..
3
3
foo

slice
Code:
array
len
cap
42990 0 100
0
1 2 3 4
foo
0x..
5
5
0
1 2 3 4
0 1 2 3 4
var foo []int
foo[3] = 42
foo[4] = 100
bar := foo[1:4]
bar[1] = 99
array
len
cap
bar
0x..
3
3
0 1 2

slice
Code:
var digitRegexp = regexp.MustCompile("[0-9]+")
func FindDigits(filename string) []byte {
b, _ := ioutil.ReadFile(filename)
return digitRegexp.Find(b)
}

slice
array
len
cap
32r 1 $
0
b
0x..
10^6
0
array
len
cap
digitRegexp.Find
0x..
3
3
10^6
xa b c d …
10MB slice

append
Code:
a := make([]int, 32)
a = append(a, 1)

append
Code:
a := make([]int, 32)
a = append(a, 1)
fmt.Println("len:", len(b), "cap:", cap(b))
len: 33 cap: 64
Output:

append
array
len
cap
000 0 0
a
0x..
32
32
0 1 2 3 4
0 1 2 30 31
…
32 ints
a = append(a, 1)

array
len
cap
000 0 0
a
0x..
33
64
0 1 2 3 4
0 1 2 30 31
… 1
32 33 34
…
35 62 63
32 ints more
32 + 1
doubling 32
000 0 0
0 1 2 3 4
0 1 2 30 31
…
32 ints

append
array
len
cap
000 0 0
a
0x..
34
64
0 1 2 3 4
0 1 2 30 31
… 1 2
32 33 34
…
35 62 63
33 + 1 a = append(a, 2)
64 ints

interfaces
Code:
type error interface {
Error() string
}

interfaces
Code:
Go code: src/runtime/runtime2.go
type iface struct {
tab *itab
data unsafe.Pointer
}
Error() string
}

type iface struct {
tab *itab
data unsafe.Pointer
}
Error() string
}
interfaces
Code:
Go code: src/runtime/runtime2.go itab = interface table

type iface struct {
tab *itab
data unsafe.Pointer
}
Error() string
}
interfaces
Code:
type itab struct {
inter *interfacetype
_type *_type
link *itab
bad int32
unused int32
fun [1]uintptr
}

interfaces
Code:
tab
data
Error() string
}

data
tab
nil
0x..
interfaces
Code:
inter
type
nil
error
fun
itab
…
Error() string
}
var err error
err
nil interface

interfaces
Code:
Error() string
}
func foo() error {
return nil
}
data
tab
nil
0x..
inter
type
nil
error
fun
itab
…
err

interfaces
Code:
data
tab
nil
0x..
inter
type
nil
error
fun
itab
…
err
func foo() error {
var err error
// err == nil
return err
}
err := foo()
if err != nil { // false
}

interfaces
func foo() error {
var err *os.PathError
// err == nil
return err
}
err := foo()
if err != nil { // ???
}
Code:

interfaces
func foo() error {
// err == nil
return err
}
err := foo()
if err != nil { // true
}
Code:

interfaces
func foo() error {
// err == nil
return err
}
err := foo()
}
Code:
tab
0x..
inter
type
*os.Path
Error
error
fun
itab
…
err
data
os.PathError
err
nil
0x..

tab
interfaces
func foo() error {
err := &os.PathError{
"open", name, e
}
return err
}
err := foo()
}
Code:
data
0x..
0x..
inter
type
*os.Path
Error
error
fun
itab
…
err
os.PathError
err
“open”
…

interfaces
func foo() error {
// err == nil
return err
}
func foo() error {
var err error
// err == nil
return err
}
data
tab
nil
0x..
inter
type
nil
error
fun
itab
…
err
data
tab
0x..
inter
type
*os.Path
Error
error
fun
itab
…
err
0x..
os.PathError
nil
err

interfaces
tab
0x..
inter
type
*os.Path
Error
error
fun
itab
…
err
data
os.PathError
err
nil
0x..
data
tab
nil
0x..
inter
type
nil
error
fun
itab
…
err
!=

type eface struct {
_type *_type
data unsafe.Pointer
}
type empty interface{}
interfaces
Code:
_type
data

interfaces
int64
0x..
int64
42
empty
foo
var foo int64 = 42
func bar() interface{} {
return foo
}
Code:

interfaces
func bar() interface{} {
return int64(42)
}
Code:

interfaces
func bar() []interface{} {
return []int64{1,2,3,4}
}
Code:

interfaces
func bar() []interface{} {
return []int64{1,2,3,4}
}
Code:
$ go build
cannot use []int literal (type []int) as type
[]interface {} in return argument

array
len
cap
[]int
0x..
32
32
4
3131 2 32
0 1 2 3
0 1 2 30 31
…
32 ints
array
len
cap
0x..
32
32
0
…
32 interfaces{}[]interface{}
int
0x..
int
1
empty
data
int
0x..
int
2
empty
data
int
0x..
int
3
empty
data
0
int
0x..
int
31
empty
data
int
0x..
int
32
empty
data

If you want to do something
expensive - do it explicitly

Links
https://divan.github.io/posts/avoid_gotchas/

Links
• Must read:
• Go Data Structures
• Go Data Structures:
Interfaces
• Go Slices: usage and
internals
• Gopher Puzzlers
• And, of course:
• Go source code
• Effective Go
• Go spec

How to avoid Go gotchas - Ivan Daniluk - Codemotion Milan 2016

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to How to avoid Go gotchas - Ivan Daniluk - Codemotion Milan 2016 (20)

More from Codemotion (20)

Recently uploaded (20)

How to avoid Go gotchas - Ivan Daniluk - Codemotion Milan 2016