Golang

04.07.2017
Fatih Şimşek - Software Infrastructure
GoLang

GoLang
Open Source
Huge community
Robert Griesemer, Rob Pike, Ken Thompson
Started at late 2009
1.0v published in March 2012
1.8v published in February 2017
•Go 1.8 (February 2017)

Designers
All Team: https://www.youtube.com/watch?v=sln-gJaURzk

Scale at Google
System Scale
• Designed to scale to 106+ machines
• Everyday jobs run on 1000s machines
• Job coordinate, interacting with others in the system
• Lots going on at once
Solution: great support for concurrency

Scale at Google
Engineering Scale
• 500+ developers across 40+ offices
• 20+ changes per minute
• 50% of code base changes every month
• 50 million test cases executed per day
• Single code tree
Solution: design the language for large code bases

Pain Points
Slow Build Cross-language builds
Code hard to read Uncontrolled Dependencies
Each programmer using a different
subset of th language
Cost of updates
Version skew
Difficult of writing automatic tools

Why GoLang?
Simple (25 keywords)
Fast compiled, Modern
Compile into one executable file
Static Type-Checked, Fast Compiled
Garbage-Collected
Built-in Concurrency

When to use Go?
System programming
Web apps
CLI based apps
Games
Scientific Apps

Who uses Go?
https://github.com/golang/go/wiki/GoUsers
Google Dropbox SoundCloud
IBM eBay TIBCO
Twitter Medium Uber
Facebook Github WMware
Yahoo Pinterest Yandex

Success Stories
Dailymotion: We like its simplicity, its performance and its static
type checking.
Dropbox: We decided to migrate our performance-critical backends
from Python to Go to leverage better concurrency support and faster
execution speed
Uber: We are extremely happy with our decision to Go for it and
write our service in a new language. Go typically takes just a few days
for a C++, Java or Node.js developer to learn, and the code is easy to
maintain
Tumblr: Go is an ideal language for writing web servers. It’s compiled
and integrates seamlessly with C libraries.

Success Stories
MongoDB: The Backup Service started as a Java project, but as the
project matured, the team wanted to move to a language that
compiled natively on the machine. After considering a few options,
the team decided that Go was the best fit.
Medium: Our Neo4j database is managed by a service written in Go.
Cloudfare: Go's concurrency makes writing software that must scale
up and down very easy.

Developement Environment
Sublime Text
Atom
Visual Studio Code
Intellij
Netbeans
Eclipse

Visual Studio Code with GoLang
https://golang.org/dl/
Delve debugger
go get github.com/derekparker/delve/cmd/dlv
Install Go extension for Visual Studio Code

Variables
• var i int var (
• var f float64 = 1.5 counter int64
• var b bool = true wg sync.WaitGroup
• var s string = "golang" )
Shortcut:
• i := 10
• s := "golang"
• f := 1.5
• b := false
No implicit numeric conversions

Array
Array bounds are always checked
var days [7]string
var board [4][2]int
var val [5]int = [5]int { 44, 72, 16, 1, 5 }
var counts = [...]int { 2,4,5,6 }
var scores = [5]int {1: 10, 2: 20}

Array
Passing an array between functions can be an expensive
operation in terms of memory and performance.
var array [8]int var array [8]int
foo(array) foo(&array)
func foo(array [8]int) { func foo(array *[8]int) {
... ...
} }
Passing pointer of array is only copy eight bytes.

Slice
Slices are built around the concept of dynamic arrays that can
grow and shrink
slice := make([]string, 5)
slice := []string{"Red", "Blue", "Green", "Yellow", "Pink"}
newSlice := slice[1:3]
newSlice = append(newSlice, 60)

Map
Maps don’t have a capacity or any restriction on growth
colors := map[string]string{}
colors["Red"] = "#da1337"
value, exists := colors["Blue"]
for key, value := range colors {
fmt.Printf("Key: %s Value: %sn", key, value)
}
func printColor(colors map[string]string) {
...
}

Function
func [<func-identifier>] ([<argument-list>]) [(<result-list>)] {
return [<value or expression list>]
}
func add(op0 int, op1 int) int {
return op0 + op1
}
func main() {
var opAdd func(int, int) = add
opAdd2 := add
}

Function
Variadic Functions:
func avg(nums ...float64) int
Return Parameters:
func div(op0, op1 int) (int, int) {
return q, r
}
func div(op0, op1 int) (q,r int) {
return
}

Function
Pass by reference:
func half(val *float64) {
*val = *val / 2
}
func main() {
num :=2.8
half(&num)
rad := func() float64 {
return 5 * math.Pi / 180
}()
}

Pointer
Similar to C/C++, Go uses the * operator to designate a type as
a pointer
var countPtr *int
var row []*int64
var a int = 1024
var aptr *int = &a
Unlike C, Go runtime maintains control of the management of
pointers at runtime. A programmer cannot add an arbitrary
integer value to the pointer to generate a new pointer address

OOP
struct Class with fields, only non-virtual methods
interface Class with only virtual methods
embedding Multiple inheritance and composition

Struct
No Constructor:
type user struct {
name string
email string
ext int
}
lisa := user {
name: "Lisa",
email: "lisa@email.com",
ext: 123
}
lisa := user{"Lisa", "lisa@email.com", 123}

Struct
No Inheritance / Composition:
type admin struct {
person user
level string
}
fred := admin {
person: user {
name: "Lisa",
email: "lisa@email.com",
ext: 123
},
level: "super"
}

Struct
No Inheritance / Embedding:
type Animal struct { type Dog struct {
legCount int Animal
} }
func (anm Animal) numberOfLegs int {
return anm.legCount
}
func main() {
d: = Dog(Animal(4))
fmt.Println("Leg count: %s", d.numberofLegs())
}

Interface
Implement all methods in interface:
type geometry interface { func main() {
area() float64 r: rect{ width:3, height:4 }
} measure(r)
type rect struct { }
width, height float64
}
func (r rect) area() float64 {
return r.width * r.height
}
func measure(g geometry) {
fmt.Println(g.area())
}

Packages
Name of the identifier itself carries the visibility
• Upper case : Public / exported / visible to other packages
• Lower case : Private to the package
import (
[identifier] "<path>"
)
import "fmt "
import vpr "github.com/spf13/viper"
import . "foo/bar/util/logger"
init(): function is invoked after the package-level variables are initialized

Error Handling
defer:
Pushing function to internal stack, delaying its execution
right before the enclosing function returns
• Closing open files
• Releasing network resources
• Closing channel
• Commiting database transactions
• Error handling

Error Handling
panic / recover:
func main() {
panicAndRecover()
fmt.Println("I need to run the statement at any cost!")
}
func panicAndRecover() {
defer func() {
if err := recover(); err != nil {
fmt.Println(err)
}
}()
panic("Unable to connect database!")
}

Concurrency
When a function is created as a goroutine, it’s treated as an
independent unit of work that gets scheduled and then
executed on an available logical processor
The Go runtime scheduler is a sophisticated piece of software
that manages all the goroutines that are created and need
processor time
The scheduler sits on top of the operating system, binding
operating system’s threads to logical processors which, in turn,
execute goroutines

Goroutine
runtime.GOMAXPROCS(1)
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
....
}
fmt.Println("Waiting for Finish")
wg.Wait()

Race Conditions
Go has a special tool that can detect race conditions in your
code.
go build –race //Build the code using the racind detector
./example //Run the code
------------------------------
WARNING: DATE RACE
Write by goroutine: 5
main.incCounter()
/example/main.go:49 +0x96
Previous read by goroutine 6:
main.main()
/example/main.go:49 +0x66

Locking
Go provides traditional support to synchronize goroutines by
locking access to shared resources
atomic.AddInt64(&counter, 1)
atomic.LoadInt64(&counter)
atomic.StoreInt64(&counter,1)
mutex.Lock() {
....
}
mutex.UnLock()

Channel
Don’t communicate by sharing memory, share memory by
communicating
Synchronize goroutines as they send and receive the resources
they need to share between each other
unbuffered := make(chan int)
buffered := make(chan string, 10)
value := <- buffered
buffered <- value

Garbage Collection
Go 1.5:
• Concurrent
• Low latency

Garbage Collection
Tricolor Algorithm:
Initially color all nodes white (unexplored)
Color the root gray.
while some gray node x exist
color some white successors of x gray
if x has no successors left, color it black
Breadth-First
Mark and Sweep
Limit GC latency to less than 10 miliseconds

Golang

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Golang

Ähnlich wie Golang (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Golang

Hinweis der Redaktion