Go. Why it goes

About me
Serhii Pichkurov
◎5+ years of experience
◎Java
◎Mostly backend
◎No experience as presenter
before
◎9 months with Go

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

Characteristics
Go (often referred to as golang) is:
◎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)

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

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

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

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

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

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

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

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

Slices
A slice, on the other hand, is a dynamically-sized,
flexible view(reference) into the elements of an array
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")

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

Maps
m = make(map[string]int) // declare
m["route"] = 66 // put
i := m["route"] // get
delete(m, "route")
_, ok := m["route"] //check is present
for key, value := range m { //iterate
fmt.Println("Key:", key, "Value:", value)
}
commits := map[string]int{ //static population
"gri": 1908,
"adg": 912,
}

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

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)

Structs
type Item struct {
Title string
URL string
}
item := Item{Title:"title",URL:"http:..."}

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

Tags aka annotations
type Person struct {
FirstName string `json:"first_name"`
LastName string `json:"last_name"`
MiddleName string
`json:"middle_name,omitempty"`
}

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"

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

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

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

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"

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

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

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)
}

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

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

Go differs from Java in
several ways
◎ Programs compile to machine code. There's no VM.
◎ Statically linked binaries
◎ Control over memory layout
◎ Function values and lexical closures
◎ GC does not have compaction phase
◎ Multiply return

Go intentionally leaves
out many features
◎ No classes
◎ No constructors
◎ No inheritance
◎ No ‘implements’ keyword
◎ No final
◎ No exceptions
◎ No user-defined generics

Exceptions go away
◎No Exceptions by design
◎Handling with multiple return
◎Panic!
type error interface {
Error() string
}

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("Failed to read RPM head: %v",
err)
return
}

go get is great,
but we need
more

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/
...

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

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

IDE
There's no "Go IDE". Go tools meet you where
you are.
◎Eclipse
◎IntelliJ
◎Atom
◎Emacs
◎Vim
◎many others

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

Pointers,
pointers to
pointers, more
pointers.

Nil pointer is
still there and
happens in
runtime

Unused variables
or imports —
compilation error

func foo() []interface{} {
return []int{1,2,3}
}
cannot use []int literal (type []int) as
type []interface {} in return argument

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

Intellij: Debug
works once in
a day, tests are
not debuggable

Missing Comma In
Multi-Line Slice,
Array, and Map
Literals

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

“
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

Simplicity is complicated but
the clarity is worth the fight

Go. Why it goes

Go. Why it goes

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente(20)

Destacado

Destacado(16)

Similar a Go. Why it goes

Similar a Go. Why it goes(20)

Último

Último(20)

Go. Why it goes