Go for C++ developers

Go for C++ developers

Agenda:

• let's talk about Go

• how do I do X in Go?

• concurrency, because it's awesome

• Q & A: but feel free to interrupt anytime

• We might not go through all the slides

About me

2011 Joined Google as a Software Engineer

• writing mostly in C++ and Python
• used to think smart code was better than boring code

2012 Joined the Go team as a Developer Programs Engineer

2014 to today Developer Advocate for the Google Cloud Platform

Let's talk about Go

Go is

Go is

• open source

• statically typed

• object oriented (if you ask me)

• compiled

• memory safe

• type safe

Why Go?

Go was created for:

• scalability

• concurrency

• simplicity

Who uses Go?

Google:

• YouTube
• dl.google.com

Others:

• Docker
• SoundCloud
• Canonical
• CloudFlare
• Mozilla
• ...

go.dev/wiki/GoUsers

Who uses Go?

Some Go features

Go types

• primitive types

int, uint, int8, uint8, ...
bool, string
float32, float64
complex64, complex128

• structs

struct {
    Name string
    Age  int
}

• slices and arrays

[]int, [3]string, []struct{ Name string }

• maps

map[string]int

Kinds of types (continued)

• pointers

*int, *Person

• functions

func(int, int) int

• channels

chan bool

• interfaces

interface {
    Start()
    Stop()
}

Type declarations

type [name] [specification]

Person is a struct type.

type Person struct {
    name string
    age  int
}

Celsius is a float64 type.

type Celsius float64

Function declarations

func [name] ([params]) [return value]
func [name] ([params]) ([return values])

A sum function:

func sum(a int, b int) int {
    return a + b
}

A function with multiple return values:

func divMod(a, b int) (int, int) {
    return a / b, a % b
}

Made clearer by naming the return values:

func divMod(den, div int) (quo, rem int) {
    return den / div, den % div
}

Method declarations

func ([receiver]) [name] ([params]) ([return values])

A method on a struct:

func (p Person) IsMinor() bool {
    return p.age < 18
}

But also a method on a float64:

func (c Celsius) Freezing() bool {
    return c <= 0
}

Constraint: Methods can be defined only on types declared in the same package.

// This won't compile
func (s string) Length() int { return len(s) }

Declaring variables

Normal declaration:

var text string = "hello"

You can omit types:

var text = "hello"

And inside of functions:

text := "hello"

Other types

a := 0                             // int
b := true                          // boolean
f := 1.0                           // float64
p := Person{"Francesc", "Campoy"}  // Person

No implicit numeric conversion

Given types:

type Celsius float64

type Fahrenheit float64

And the variables:

var freezing Fahrenheit = 32
var boiling Celsius = 100

This code won't compile:

sauna := (freezing + boiling) / 2

There's no implicit numeric conversion in Go.

Pointers and memory allocation

Pointers

Go has pointers:

var p *int
p = new(int)

But no pointer arithmetics:

var p *int = &a[0]
var q = p+2            // invalid

There's new but there's no delete.

Memory is garbage collected after it's no longer accessible.

Memory allocation

The compiler decides where to allocate based on escape analysis.

Using new doesn't imply using the heap:

stack.go:

func get() int {
    n := new(int)
    return *n
}

And not all values in the heap are created with new:

heap.go:

func get() *int {
    n := 4
    return &n
}

Choosing what allocation you want

You can not decide where a value is allocated.

But you can see what kind of allocation is used:

$ go tool 6g -m stack.go

stack.go:3: can inline get
stack.go:4: get new(int) does not escape

Compare to:

$ go tool 6g -m heap.go

heap.go:3: can inline get
heap.go:4: moved to heap: n
heap.go:5: &n escapes to heap

RAII

Resource Acquisition Is Initialization

Provides:

• encapsulation of acquisition and disposition of resources

• exception safe

An example:

void write_to_file (const std::string & message) {
    // mutex to protect file access
    static std::mutex mutex;

    // lock mutex before accessing file
    // at the end of the scope unlock mutex
    std::lock_guard<std::mutex> lock(mutex);

    // mutual exclusion access section
    ...
}

RAII in Go: defer

The defer statement:

• schedules a function call at the end of the current function

• stacks all deferred calls - last in first out

var m sync.Mutex

func writeToFile(msg string) error {
    m.Lock()
    defer m.Unlock()

    // mutual exclusion access section
}

Garbage collection

Go is a garbage collected language

But it's easy to limit heap allocations

• many values are allocated on the stack

• object pools: sync.Pool

• contiguous area of memory

// +build ignore,OMIT

package main

import (
	"fmt"
	"unsafe"
)

type Date struct {
    Day   int
    Month int
    Year  int
}

func main() {
    fmt.Printf("size of %T: %v\n", 0, unsafe.Sizeof(0))
    fmt.Printf("size of %T: %v\n", Date{}, unsafe.Sizeof(Date{}))
    fmt.Printf("size of %T: %v\n", [100]Date{}, unsafe.Sizeof([100]Date{}))
}

More about garbage collection

Trusted in production.

Brad Fitzpatrick's talk on migrating dl.google.com from C++ to Go:

• dl.google.com: Powered by Go

Current state and road plan:

• go.dev/s/go14gc

Inheritance vs Composition

Inheritance vs Composition

• Inheritance breaks encapsulation

• Composition causes boilerplate to proxy all methods

Example:

type Engine struct{}

func (e Engine) Start() { ... }
func (e Engine) Stop()  { ... }

We want Car to be able to Start and Stop too.

More detail in my talk Go for Javaneros

Struct embedding

Composition + Proxy of selectors

// +build ignore,OMIT

package main

import "fmt"

type Engine struct{}

func (e Engine) Start() {
    fmt.Println("Engine started")
}

func (e Engine) Stop() {
    fmt.Println("Engine stopped")
}

type Car struct {
    Engine // Notice the lack of name
}

func main() {
    var c Car

    c.Start()
    c.Stop()
}

Struct embedding and the diamond problem

What if two embedded fields have the same type?

// +build ignore,OMIT

package main

import "fmt"

type Engine struct{}

func (e Engine) Start() { fmt.Println("Engine started") }
func (e Engine) Stop()  { fmt.Println("Engine stopped") }

type Radio struct{}

func (r Radio) Start() { fmt.Println("Radio started") }
func (r Radio) Stop()  { fmt.Println("Radio stopped") }

type Car struct {
    Engine
    Radio
}

func main() {
    var c Car
    c.Radio.Start()
    c.Engine.Start()
}

Struct embedding

It looks like inheritance but it is not inheritance.

It is composition.

Used to share implementations between different types.

What if want to share behavior instead?

Interfaces

Interfaces

An interface is a set of methods.

In Java (C++ doesn't have interfaces)

interface Switch {
    void open();
    void close();
}

In Go:

type OpenCloser interface {
    Open()
    Close()
}

It's all about satisfaction

Java interfaces are satisfied explicitly.

C++ abstract classes need to be extended explicitly

Go interfaces are satisfied implicitly.

Go: implicit satisfaction

If a type defines all the methods of an interface, the type satisfies that interface.

Benefits:

• fewer dependencies
• no type hierarchy
• organic composition

Structural subtyping

Better than duck typing. Verified at compile time.

FuncDraw: an example on interfaces

FuncDraw: package parser

Package parse provides a parser of strings into functions.

func Parse(text string) (*Func, error) { ... }

Func is a struct type, with an Eval method.

type Func struct { ... }

func (p *Func) Eval(x float64) float64 { ... }

FuncDraw: package draw

Package draw generates images given a function.

func Draw(f *parser.Func) image.Image {
    for x := start; x < end; x += inc {
        y := f.Eval(x)
        ...
    }
}

draw depends on parser, which makes testing hard.

Breaking dependencies

Let's use an interface instead

type Evaluable interface {
    Eval(float64) float64
}

func Draw(f Evaluable) image.Image image.Image {
    for x := start; x < end; x += inc {
        y := f.Eval(x)
        ...
    }
}

Advanced interfaces and composition

Struct embedding of interfaces

Embedding an interface:

• more types can be used
• limits what is added to the embedding type

Given:

type Person struct {
    First string
    Last  string
    Age   int
}

Employee exposes the Age of Person

type Employee struct {
    Person
}

e := Employee{Person{"John", "Doe", 49}}

Choosing what to proxy

But we could hide it by choosing an interface:

type Employee struct {
    Namer
}

type Namer interface {
    Name() string
}

And we need to make Person satisfy Namer

func (e Person) Name() string { return e.First + e.Last }

And the rest of the code still works:

e := Employee{Person{"John", "Doe", 49}}

Easy mocking of interfaces

Given this function:

func CheckPassword(c net.Conn) error {
    // read a password from the connection
    buf := make([]byte, 256)
    n, err := c.Read(buf)
    if err != nil {
        return fmt.Errorf("read: %v", err)
    }

    // check it's correct
    got := string(buf[:n])
    if got != "password" {
        return fmt.Errorf("wrong password")
    }
    return nil
}

How would you test it?

Easy mocking of interfaces

net.Conn is an interface defined in the net package of the standard library.

type Conn interface {
    Read(b []byte) (n int, err error)
    Write(b []byte) (n int, err error)
    Close() error
    LocalAddr() Addr
    RemoteAddr() Addr
    SetDeadline(t time.Time) error
    SetReadDeadline(t time.Time) error
    SetWriteDeadline(t time.Time) error
}

We need a fake net.Conn!

One solution

We could define a new type that satisfies net.Conn

type fakeConn struct {}

func (c fakeConn) Read(b []byte) (n int, err error) {...}
func (c fakeConn) Write(b []byte) (n int, err error) {...}
func (c fakeConn) Close() error {...}
...

But, is there a better way?

The better way

type fakeConn struct {
    net.Conn
    r io.Reader
}

func (c fakeConn) Read(b []byte) (int, error) {
    return c.r.Read(b)
}

And our test can look like:

// +build ignore,OMIT

package main

import (
	"fmt"
	"io"
	"log"
	"net"
	"strings"
)

func CheckPassword(c net.Conn) error {
	// read a password from the connection
	buf := make([]byte, 256)
	n, err := c.Read(buf)
	if err != nil {
		return fmt.Errorf("read: %v", err)
	}

	// check it's correct
	got := string(buf[:n])
	if got != "password" {
		return fmt.Errorf("wrong password")
	}
	return nil
}

type fakeConn struct {
	net.Conn
	r io.Reader
}

func (c fakeConn) Read(b []byte) (int, error) {
	return c.r.Read(b)
}

// end_fake OMIT

func main() {
    c := fakeConn{
        r: strings.NewReader("foo"),
    }
    err := CheckPassword(c)
    if err == nil {
        log.Println("expected error using wrong password")
    } else {
        log.Println("OK")
    }
}

Concurrency

Concurrency

It is part of the language, not a library.

Based on three concepts:

• goroutines: lightweight threads
• channels: typed pipes used to communicate and synchronize between goroutines
• select: control structure to coordinate concurrent operations

Sleep and talk

func sleepAndTalk(t time.Duration, msg string) {
    time.Sleep(t)
    fmt.Printf("%v ", msg)
}

We want a message per second.

// +build ignore,OMIT

package main

import (
	"fmt"
	"time"
)

func sleepAndTalk(t time.Duration, msg string) {
	time.Sleep(t)
	fmt.Printf("%v ", msg)
}

func main() {
    sleepAndTalk(0*time.Second, "Hello")
    sleepAndTalk(1*time.Second, "Gophers!")
    sleepAndTalk(2*time.Second, "What's")
    sleepAndTalk(3*time.Second, "up?")
}

What if we started all the sleepAndTalk concurrently?

Just add go!

Concurrent sleep and talk

// +build ignore,OMIT

package main

import (
	"fmt"
	"time"
)

func sleepAndTalk(t time.Duration, msg string) {
	time.Sleep(t)
	fmt.Printf("%v ", msg)
}

func main() {
    go sleepAndTalk(0*time.Second, "Hello")
    go sleepAndTalk(1*time.Second, "Gophers!")
    go sleepAndTalk(2*time.Second, "What's")
    go sleepAndTalk(3*time.Second, "up?")
}

That was fast ...

When the main goroutine ends, the program ends.

Concurrent sleep and talk with more sleeping

// +build ignore,OMIT

package main

import (
	"fmt"
	"time"
)

func sleepAndTalk(t time.Duration, msg string) {
	time.Sleep(t)
	fmt.Printf("%v ", msg)
}

func main() {
    go sleepAndTalk(0*time.Second, "Hello")
    go sleepAndTalk(1*time.Second, "Gophers!")
    go sleepAndTalk(2*time.Second, "What's")
    go sleepAndTalk(3*time.Second, "up?")
    time.Sleep(4 * time.Second)
}

But synchronizing with Sleep is a bad idea.

Communicating through channels

sleepAndTalk sends the string into the channel instead of printing it.

func sleepAndTalk(secs time.Duration, msg string, c chan string) {
    time.Sleep(secs * time.Second)
    c <- msg
}

We create the channel and pass it to sleepAndTalk, then wait for the values to be sent.

// +build ignore,OMIT

package main

import (
	"fmt"
	"time"
)

func sleepAndTalk(secs time.Duration, msg string, c chan string) {
	time.Sleep(secs * time.Second)
	c <- msg
}

func main() {
    c := make(chan string)

    go sleepAndTalk(0, "Hello", c)
    go sleepAndTalk(1, "Gophers!", c)
    go sleepAndTalk(2, "What's", c)
    go sleepAndTalk(3, "up?", c)

    for i := 0; i < 4; i++ {
        fmt.Printf("%v ", <-c)
    }
}

Aside: a web server

A production ready web server.

package main

import (
    "fmt"
    "log"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "hello")
}

func main() {
    http.HandleFunc("/", handler)
    err := http.ListenAndServe("localhost:1234", nil)
    if err != nil {
        log.Fatal(err)
    }
}

Let's count on the web

Why is this wrong?

// +build ignore,OMIT

package main

import (
	"fmt"
	"log"
	"net/http"
)

var nextID int

func handler(w http.ResponseWriter, q *http.Request) {
    fmt.Fprintf(w, "<h1>You got %v<h1>", nextID)
    nextID++
}

func main() {
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe("localhost:8080", nil))
}

Let's count on the web correctly

We receive the next id from a channel.

var nextID = make(chan int)

func handler(w http.ResponseWriter, q *http.Request) {
    fmt.Fprintf(w, "<h1>You got %v<h1>", <-nextID)
}

We need to send ids into the channel.

func counter() {
    for i := 0; ; i++ {
        nextID <- i
    }
}

Let's count on the web correctly

And we need to do both at the same time.

// +build ignore,OMIT

package main

import (
	"fmt"
	"log"
	"net/http"
)

var nextID = make(chan int)

func handler(w http.ResponseWriter, q *http.Request) {
	fmt.Fprintf(w, "<h1>You got %v<h1>", <-nextID)
}

func counter() {
	for i := 0; ; i++ {
		nextID <- i
	}
}

func main() {
    http.HandleFunc("/", handler)
    go counter()
    log.Fatal(http.ListenAndServe("localhost:8080", nil))
}

Let's fight!

select allows us to choose among multiple channel operations.

// +build ignore,OMIT

package main

import (
	"fmt"
	"net/http"
)

var battle = make(chan string)

func handler(w http.ResponseWriter, q *http.Request) {
    select {
    case battle <- q.FormValue("usr"):
        fmt.Fprintf(w, "You won!")
    case won := <-battle:
        fmt.Fprintf(w, "You lost, %v is better than you", won)
    }
}

func main() {
	http.HandleFunc("/fight", handler)
	http.ListenAndServe("localhost:8080", nil)
}

Go - localhost:8080/fight?usr=go
C++ - localhost:8080/fight?usr=cpp

Chain of gophers

Ok, I'm just bragging here

Chain of gophers

// +build ignore,OMIT

package main

import (
	"fmt"
	"time"
)

func f(left, right chan int) {
    left <- 1 + <-right
}

func main() {
    start := time.Now()
    const n = 1000
    leftmost := make(chan int)

    right := leftmost
    left := leftmost
    for i := 0; i < n; i++ {
        right = make(chan int)
        go f(left, right)
        left = right
    }

    go func(c chan int) { c <- 0 }(right)

    fmt.Println(<-leftmost, time.Since(start))
}

Concurrency is very powerful

And there's lots to learn!

• Go Concurrency Patterns, by Rob Pike
• Advanced Concurrency Patterns, by Sameer Ajmani
• Concurrency is not Parallelism, by Rob Pike

In conclusion

• Go is simple, consistent, readable, and fun.

• All types are equal: methods on any type.

• Implicit satisfaction of interfaces makes code easier to reuse.

• Use composition instead of inheritance.

• Struct embedding is a powerful tool.

• Concurrency is awesome, and you should check it out.

What to do next?

Learn Go on your browser with go.dev/tour

Find more about Go on go.dev

Join the community at golang-nuts

Link to the slides /talks/2015/go4cpp.slide

Thank you