Go: Why it goes by Serhii Pichkurov In this talk Serhii will talk about Go, also known as Golang – an open source language developed at Google and used in production by companies such as Docker, Dropbox, Facebook and Google itself. Go is now heavily used as a general-purpose programming language that’s a pleasure to use and maintain. This introductory talk contains many live demos of basic language concepts, concurrency model, simple HTTP-based endpoint implementation and, of course, tests using build-in framework. This presentation will be interesting for backend engineers and DevOps to understand why Go had become so popular and how it might help to build robust and maintainable services. Join this session after which you can start coding using language that has static safe compiler, GC and is as fast as C++ or Java, with even simpler syntax than Python!

1. Go. Why it
goes?
1

2. About me
Serhii Pichkurov
●6+ years of experience
●Mostly backend
●~ 1 year with Go
2

3. Agenda
● Go is not C, not Java, not anything
● Gopher
● Rob Pike argument
● Main ideas
● Concurrency model
● Tools
● Issues and gotchas 3

4. Characteristics
Go (often referred to as golang) is:
4
●Clean procedural language designed
for scalable cloud software
●open source
●statically typed with duck typing

5. Characteristics
●CSP(communicating sequential processes) as
concurrent model
●with garbage collection
●created at Google in 2007 by Robert
Griesemer(V8), Rob Pike(UNIX, UTF-8), and Ken
Thompson(UNIX, regexp)
5

6. Characteristics
●compiled
●two compilers: "gc"(many platforms including
smartphones) and “gccgo”(more optimizations,
more processors)
●Linux, OS X, FreeBSD, Windows and more
6

7. Motivated by Google’s needs:
Why new lang?
7
● No surprises
● Efficiency
● Safety
● Concurrency
● Scalability
● Fast development cycle
● A cute mascot

8. Who uses Go at Google?
Lots of projects. Thousands of Go programmers. Millions
of lines of Go code.
Public examples:
● Kubernetes
● SPDY proxy for Chrome on mobile devices
● dl.google.com is written in Go
● YouTube Vitess MySQL balancer
8

9. Who uses Go besides Google?
9

10. Products written in Go
10

11. Go use-cases
● Cloud/Networking - routers, proxies, etc
● Distributed services and storages
● Internal infrastructures
● Microservices (with frameworks, like
GoKit)
● Containers and orchestration
● Command-line tools
11

12. Mascot: the gopher
12

13. Rob Pike
13

14. Rob Pike argument
● Go is different
● Go does not try to be like the other
languages
● Go does not compete on features
● As of Go 1, the language is fixed
14

15. Active Development
15

16. GC in Go 1.6
16https://talks.golang.org/2016/state-of-go.slide

17. Everything is passed by
value
17

18. Go elements
● concrete data types
● functions and methods
● interfaces
● structs
● packages
● concurrency
● good tools, fast builds
All the pieces feel simple in practice
18

19. Types
●bool
●string
●int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64
●byte //alias for uint8
●rune //alias for int32, Unicode char
●float32 float64
●complex32 complex64
19

20. var c, python, java bool
20
k := 3
c, python, java := true, false, "no!"

21. 21
func do_something() (string, int) {
return "result", 0
}
first, second := do_something()

22. Unused variables
or imports —
compilation error
22

23. Arrays
An array's length is part of its type, so arrays
cannot be resized.
var arr [5]int
arr[4] = 42
23

24. Slices
A slice, on the other hand, is a dynamically-sized,
flexible view(reference) into the elements of an array
var foo []int
24

25. Slices
foo := make([]int, 5)
25
foo[3] = 42
foo[4] = 100

26. Slices
bytes := [5]byte{} // array
var slice = bytes[2:4]
names := []string{"leto", "paul", "teg"}
c := make([]string, len(names))
copy(c, names)
names = append(names,"ioav")
26

27. Maps
m = make(map[string]int) // declare
m["route"] = 66 // put
i := m["route"] // get
delete(m, "route")
_, ok := m["route"] //check is present
27

28. Maps
Important to remember: when no value is
assigned to key, zero value is returned
28

29. for key, value := range m { //iterate
fmt.Println("Key:", key, "Value:", value)
}
commits := map[string]int{ //static population
"gri": 1908,
"adg": 912,
}
29
Maps

30. Interfaces
Just a set of methods. No data. Simple idea, but more
complex than expected.
type Reader interface {
Read(p []byte) (n int, err error)
}
_, err := reader.Read(p)
30

31. Structs
type Person struct {
FirstName string
LastName string
}
person := Person{FirstName:"title", LastName:"http:..."}
31

32. Tags aka annotations
type Person struct {
FirstName string `json:"first_name"`
LastName string `json:"last_name"`
MiddleName string `json:"-"`
}
32
xml:"FirstName"`
xml:"LastName"`
xml:"MiddleName"`

33. Pointers
A pointer holds the memory address of a variable.
The & operator generates a pointer to its operand:
i := 42
p = &i
The * operator denotes the pointer's underlying value:
fmt.Println(*p) // read i through the pointer p
*p = 21 // set i through the pointer p
33

34. Receivers
type Server struct {
...
}
34
func (srv *Server) Close() error {
...
}
func (srv Server) Name() string {
...
}

35. Demo
35

36. Packages
We can import one or more package, there are three types:
system, local and remote.
System – out of the box. Like http, testing, etc
Local – in your repository, no need to use full path.
Remote – has complete import path pointing to the server.
To import remote package:
import "github.com/nf/wav"
36

37. Getting dependencies
For remote package use go get to fetch into workspace.
go get github.com/nf/wav
Other operations also done via go CLI tool:
go build
go test
go run
and more
37

38. 38
export GOPATH = $HOME/go_workspace

39. Concurrency
Based on CSP that was first described in a 1978 paper by
Tony Hoare.
Has three elements:
● coroutines (execution)
● channels (communication)
● select (coordination)
39

40. “
Don't communicate by
sharing memory, share
memory by communicating
40

41. Goroutines
Start a goroutine with the go keyword:
go function(args)
Like garbage collection, eliminate considerations from the
programmer's concern:
● no stack size
● no return or completion status
● no mechanism for management
● no "ID"
41

42. Goroutines
●Goroutines are like lightweight threads.
●Go programs can have hundreds of
thousands of them
●The Go runtime schedules goroutines
onto OS threads
●Blocked goroutines don't use a thread
42

43. Channels
Channels provide communication between
goroutines.
c := make(chan string)
// goroutine 1
c <- "hello!"
// goroutine 2
s := <-c
fmt.Println(s) // "hello!"
43

44. Select
A select statement blocks until one of its cases can run, then it
executes that case.
msg := "hi"
select {
case n := <-in:
fmt.Println("received", n)
case out <- msg:
fmt.Println("sent", msg)
}
44

45. Demo time
45

46. 46

47. Go and Java have much in common
● C family (imperative, braces)
● Statically typed
● Garbage collected
● Memory safe (nil references,
runtime bounds checks)
47

48. ● Variables are always initialized
(zero/nil/false)
● Methods
● Interfaces
● Type assertions (instanceof)
● Reflection
48
Go and Java have much in common

49. Go differs from Java in several ways
● Programs compile to machine code. There's no VM.
● Statically linked binaries
● Multiple return
● Error handling
● Bit different GC(no compaction)
49

50. Go intentionally leaves out many features
● No classes
● No ‘implements’ keyword
● No final
● No exceptions
● No user-defined generics
50

51. Exceptions go away
● no exceptions by design
● handling with multiple return
● panic!
type error interface {
Error() string
}
51

52. Errors design
rpm, err := rpm.OpenPackageFile(localPath)
if err != nil {
log.Error("Failed to read RPM headers: %v", err)
return
}
file, err = file.ReadAt(archiveHead, int64(headerEnd))
if err != nil {
log.Error("Invalid archive head head: %v", err)
return
} 52

53. Tools
53

54. go get is great,
but we need
more
54

55. Vendoring
server-one uses the mux package in $GOPATH/src/github.com/gorilla/mux.
server-two uses the mux package in vendor.
$GOPATH
src/
server-one/
main.go (import "github.com/gorilla/mux")
server-two/
main.go (import "github.com/gorilla/mux")
vendor/
github.com/
gorilla/
mux/
...
55

56. Glide for Package Management
● Semantic Versions and Ranges
● Git, Bzr, Hg, Svn
● Works with Go toolchain
● Leverages vendor directory
● Imports from Godep, GB, GPM, Gom
● Private Repos and Forks
56

57. Go tools support
●go fmt
●goimports
●go lint or gometalinter
●godoc lookups
●go generate
●many more
●easy to write your own
57

58. IDE
There's no "Go IDE". Go tools meet you where you are.
●Eclipse
●JetBrains(GoLand)
●Atom
●Emacs
●Vim
●many others
58

59. My experience
Project that searches for vulnerabilities inside artifacts
●microservices
●RabbitMQ
●MongoDB/PostgreSQL
●REST API
●work with files and archives
●Docker
●34860 lines of code
59

60. Issues and
gotchas
60

61. Pointers, pointers to
pointers, more
pointers.
61

62. Nil pointer is still
there and happens in
runtime
62

63. No generics
63

64. “
If you want to do
something expensive —
do it explicitly
64

65. Missing comma in
multi-line Slice,
Array, and Map
Literals
65

66. func main() {
x := []int{
1,
2 //error
}
_ = x
}
66

67. Summary
67

68. “
I’m impressed about how easy
people can pick it up and start
being productive in a project ,
it’s also very easy to deploy
David Cuadrado, Authy
68

69. Simple can be expressive
69

70. Simplicity is complicated but
the clarity is worth the fight
70

71. Thanks!
71

72. Q&A
72