Beauty and Power of Go

Beauty and
Power of Go
Frank Müller / Oldenburg / Germany

Frank Müller

Born 1965 in Oldenburg

Software Development
since 1984

Author since 1999

Book about Go
in 2011

Introduction

© Tarandeep Sing

Let‘s talk about Go

• End of 2007 start by Rob Pike, Ken
Thompson and Robert Griesemer

• Implementation started after design
in mid 2008

• Going public in November 2009
• Release of Go 1 in March 2012

History

• Rob Pike
• Unix, Plan 9, Inferno, acme, Limbo,
UTF-8

• Ken Thompson
• Multics, Unix, B, Plan 9, ed, UTF-8
• Turing Award

Famous parents

“
Go aims to combine the safety
and performance of a statically
typed compiled language with the
expressiveness and
convenience of a dynamically
typed interpreted language.
It also aims to be suitable for
modern systems - large scale -
programming.
– Rob Pike

// Organized in packages.
package main

// Packages can be imported.
import “fmt“

// Simple function declaration.
func sayHello(to string) {
// Package usage by prefix.
fmt.Printf(“Hello, %s!n“, to)
}

// Main program is function main() in package main.
func main() {
sayHello(“World“)
}

Hello, World!

• Roots in C and Plan 9
• Native binaries with garbage
collection

• Static typing
• Concurreny
• Interfaces
• Powerful tools
• No fantastic new pur language
Some quick facts

“
It is better to have a permanent
income than to be fascinating.
– Oscar Wilde

bool rune string uintptr

byte uint / uint8 - uint64 int / int8 - int64

ﬂoat32 / ﬂoat64 complex64 / complex128

struct array slice map pointer

interface function

channel

Large set of standard types

// Declaration can be done this way:
var i int

i = myIntReturningFunction()

// More usual is:
i := myIntReturningFunction()

// Even for complex types:
s := []string{“Hello“, “World“}
m := map[string]string{
“foo“: “bar“,
“baz“, “yadda“,
}

// Or multiple values:
v, err := myFunctionWithPossibleError()

Implicit declaration

// Alias for a simple type.
type Weight float64

func (w *Weight) String() string {
return fmt.Sprintf(“%.3f kg“, w)
}

// Struct with hidden fields.
type Name struct {
first string
last string
}

func (n *Name) String() string {
return n.first + “ “ + n.last
}

func (n *Name) SetLast(l string) {
n.last = l
}

Own types can have methods

// Two-dimensional object.
type BasePlate struct {
width float64
depth float64
}

func (bp *BasePlate) Area() float64 {
return bp.width * bp.depth
}

// Use the base plate.
type Box struct {
BasePlate
height float64
}

func (b *Box) Volume() float64 {
return b.Area() * b.height
}

No inheritence, but embedding

// Create a base plate.
func NewBasePlate(w, d float64) *BasePlate {
return &BasePlate{w, d}
}

// Create a box.
func NewBox(w, d, h float64) *Box {
return &Box{BasePlate{w, d}, h}
}

// Create an illuminated box.
func NewIlluminatedBox() *IlluminatedBox {
ib := &IlluminatedBox{
box: NewBox(1.0, 1.0, 1.0),
lightOnHour: 22,
lightDuration: 8 * time.Hour,
}
go ib.backend()
return ib
}

No contructors, simple functions

© www.freeimages.co.uk

Interfaces

• Important abstraction
• Duck typing à la Go
• Set of method signatures
• No explicit implementation

Interfaces

// Interface declaration.
type Duck interface {
Quack() string
}

// First duck implementation.
type SimpleDuck Name

func (sd *SimpleDuck) Quack() string {
return fmt.Sprintf(“Quack, my name is %s“, sd)
}

// Second duck implementation.
type ComplexDuck struct {
name Name
box *IlluminatedBox
}

func (cd *ComplexDuck) Quack() string {
return fmt.Sprintf(“Quack, my name is %s “ +
“and my box has %.3f m3.“, cd.name,
cd.box.Volume())
}

Declare and implement interfaces

// A pond with ducks.
type Pond struct {
ducks []Duck
}

// Add ducks to the pond.
func (p *Pond) Add(ds ...Duck) {
p.ducks = append(p.ducks, ds...)
}

// Add ducks to the pond.
func main() {
p := &Pond{}
huey := NewSimpleDuck(...)
dewey := NewComplexDuck(...)
louie := NewAnyDuck(...)

p.Add(huey, dewey, louie)

for _, duck := range p.ducks {
println(duck.Quack())
}
}

Use interfaces

// An empty interface has no methods.
type Anything interface{}

// Type switch helps to get the real type.
func foo(any interface{}) error {
switch v := any.(type) {
case bool:
fmt.Printf(“I‘m a bool: %v“, v)
case ComplexType:
fmt.Printf(“I‘m a complex type: %v“, v)
default:
return errors.New(“Oh, type is unexpected!“)
}
return nil
}

// Or even shorter with type assertion.
v, ok := any.(WantedType)
if !ok {
return errors.New(“Expected a ‘WantedType‘!“)
}

Empty interface

• First-class functions
• Higher-order functions

• User-deﬁned function types
• Function literals
• Closures

• Multiple return values

Flexible world of functions

// Function type to do something with ducks.
type DuckAction func(d Duck) error

// Pond method to let the ducks do something.
func (p *Pond) LetDucksDo(a DuckAction) error {
for _, d := range p.ducks {
if err := a(d); err != nil {
return err
}
}
}

// Use a duck action.
func CollectQuacks(p *Pond) ([]string, error) {
quacks := []string{}
if err := p.LetDucksDo(func(d Duck) error {
quacks = append(quacks, d.Quack)
return nil
}); err != nil {
return nil, err
}
return quacks, nil
}

Full bandwidth of function usage

• Lightweight goroutines running in a
thread pool

• Up to thousands of goroutines

• Synchronization and communication
via channels

• Multi-way concurrent control via
select statement

Concurrency

• Concurrency is the composition of
independently executing processes

• Parallelism is the simultaneous
execution of computations in a
context

Concurrency is not parallelism

• Modern applications deal with lots of
things at once

• Concurrency allows to structure
software for these kinds of
applications

Structuring applications with concurrency

// A goroutine is just a function.
func fileWrite(filename, text string) {
f, err := file.Open(filename)
if err != nil {
log.Printf(“fileWrite error: %v“, err)
}
defer f.Close()

f.WriteString(text)
}

// It is started with the keyword ‘go‘.
func main() {
f := “...“
t := “...“

// Write file in the background.
go fileWrite(f, t)

// Meanwhile do something else.
...
}

Simple goroutine

// Read strings and convert them to upper case.
func pipe(in <-chan string, out chan<- string) {
for s := range in {
out <- strings.ToUpper(s)
}
}

// Use buffered channels for async. communication.
func main() {
in := make(chan string, 50)
out := make(chan string, 50)

go pipe(in, out)

in <- "lower-case string"
s := <-out

// Prints “LOWER-CASE STRING“.
fmt.Println(s)
}

Pipeline goroutine using range statement

// Job with four parts.
func job(s *Source, t *Target) {
a := partA(s)
b := partB(a)
c := partC(b)
d := partD(c)
t.Set(d)
}

// Start job multiple times.
func parallel(s *Source, t *Target) {
for i := 0; i < 4; i++ {
go job(s, t)
}
}

Naive approach leads to syncing problems

// Start a pipeline of parts.
func concurrent(s *Source, t *Target) {
abChan := make(chan *AResult, 5)
bcChan := make(chan *BResult, 5)
cdChan := make(chan *CResult, 5)
waitChan := make(chan bool)

go partA(s, abChan)
go partB(abChan, bcChan)
go partC(bcChan, cdChan)
go partD(cdChan, t, waitChan)

<-waitChan
}

Pipelined approach

// Type X managing some data.
type X struct { ... }

// Backend of type X.
func (x *X) backend() {
for {
select {
case r := <-w.requestChan:
// One request after another.
w.handleRequest(r)
case c := <-w.configChan:
// A configuration change.
w.handleConfiguration(c)
case <-w.stopChan:
// X instance shall stop working.
return
case <-time.After(5 * time.Second):
// No request since 5 seconds.
w.handleTimeout()
}
}
}

Complex scenarios using select statement

// A possible request.
type Request struct {
f func() *Response
responseChan chan string
}

// Public method to add an exclamation mark.
func (x *X) Exclamation(in string) string {
// Also x could be modified here.
f := func() { return in + “!“ }
req := &Request{f, make(chan string)}
x.requestChan <- req
return <-req.responseChan
}

// Using the requests closure in the backend.
func (x *X) handleRequest(req *Request) {
res := req.f()
x.responses = append(x.responses, res)
req.responseChan <- res
}

Request and response handling

// Start 10 pipes to do the work.
func balancedWorker(ins []string) []string {
in, out := make(chan string), make(chan string)
outs := []string{}
// Start worker goroutines.
for i := 0; i < 10; i++ {
go worker(in, out)
}
// Send input strings in background.
go func() {
for _, is := range ins {
in <- is
}
close(in)
}()
// Collect output.
for os := range out {
outs = append(outs, os)
if len(outs) == len(ins) {
break
}
}
return outs
}

Simple load balancing

// Receiving data.
select {
case data, ok := <-dataChan:
if ok {
// Do something with data.
} else {
// Channel is closed.
}
case <-time.After(5 * time.Seconds):
// A timeout happened.
}

// Sending data.
select {
case dataChan <- data:
// Everything fine.
case <-time.After(5 * time.Seconds):
// A timeout happened.
}

Adding some safety

• error is just an interface
• Errors are return values
• defer helps to ensure cleanup tasks

• panic should be used with care
• recover can handle panics
• Leads to clear and immediate error
handling

Error, panic and recover

// Error for non-feedable ducks.
type NonFeedableDuckError struct {
Duck Duck
Food *Food
}

// Fullfil the error interface.
func (e *NonFeedableError) Error() string {
return fmt.Sprintf(“It seems %v dislikes %v, “,
“maybe a rubber duck?“, e.Duck, e.Food)
}

// Error as only return value.
func FeedDucks(p *Pond, f *Food) error {
return p.LetDucksDo(func(d Duck) error {
// Type assert for ‘FeedableDuck‘ interface.
if fd, ok := d.(FeedableDuck); ok {
return fd.Feed(f)
}
return &NonFeedableDuckError{d, f}
})
}

Deﬁnition and usage of own error type

// Retrieve data from a server.
func Retrieve(addr, name string) (*Data, error) {
conn, err := net.Dial(“tcp“, addr)
if err != nil {
return nil, err
}
defer conn.Close()
// Do the retrieving.
...
return data, nil
}

// Somewhere else.
data, err := Retrieve(“localhost:80“, “/foo/bar“)
if err != nil {
// Handle the error.
...
}

Error in multi-value return, cleanup with defer

// Save execution of function ‘f‘.
func safeExec(f func()) (err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Sprintf(“Ouch: %v!“, r)
}
}
f()
return nil
}

// Somewhere else.
var result float64

err := safeExec(func() {
// Divide by zero.
result = 1.0 / (1.0 - 1.0)
})
if err != nil {
// Do the error management.
...
}

panic and recover

• Network / HTTP / Template
• Encodings (JSON, XML, ...)

• I/O, Formatting
• Crypto
• Images

• Time
• Reﬂection
Large set of useful packages

• Import of external packages
• Namespace based on SCM

• BitBucket, GitHub
• Google Code, Launchpad
• Example:

• “code.google.com/p/tcgl/redis“

External packages

• build - build the software
• fmt - format the sources
• test - run unit tests

• install - install the package
• get - retrieve and install an external
package

• doc - source documentation
Most important go subcommands

• http://golang.org/
• http://tour.golang.org/
• http://blog.golang.org/
• http://godashboard.appspot.com/
• http://go-lang.cat-v.org/
• http://www.reddit.com/r/golang/
• #go-nuts on irc.freenode.net
• Google Group golang-nuts
Some links

Thank you for listening.

Questions?

And now some practice ...

Beauty and Power of Go

More Related Content

What's hot (20)

Similar to Beauty and Power of Go (20)

More from Frank Müller (20)

Recently uploaded (20)

Beauty and Power of Go

Editor's Notes