Go. why it goes v2

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

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

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

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

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

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

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

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

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

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

Everything is passed by
value
17

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

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

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

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

Unused variables
or imports —
compilation error
22

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

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

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

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

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

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

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

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

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

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"`

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

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

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

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
export GOPATH = $HOME/go_workspace

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

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

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

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

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

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

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

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

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

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

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

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

go get is great,
but we need
more
54

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

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

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

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

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

Pointers, pointers to
pointers, more
pointers.
61

Nil pointer is still
there and happens in
runtime
62

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

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

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

“
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

Simplicity is complicated but
the clarity is worth the fight
70

Go. why it goes v2

More Related Content

What's hot (20)

Similar to Go. why it goes v2 (20)

Recently uploaded (20)

Go. why it goes v2