Introduction to Go

School of Computing Science, Glasgow University

13 October 2014

Dave Cheney

Licence and attribution

This talk is an amalgam of a talk I gave to the Canberra Go users group

go-talks.appspot.com/github.com/davecheney/canberra-gophers/introduction-to-go.slide

and Robert Griesemer's "A Taste of Go"

go-talks.appspot.com/code.google.com/p/go.talks/2014/taste.slide

From which I borrowed much of the "Program elements" section as Robert's description of the language was much better than my attempt.

As this talk is a derivative, it continues to be licenced under the BSD licence that covers the Go project.

golang.org/LICENSE

The Go programming language

Modern
Compact, concise, general-purpose
Imperative, statically type-checked, dynamically type-safe
Garbage-collected
Opinionated, no warnings, unused local vars and imports are an error
Strong support for concurrency
Compiles to native code, statically linked
Fast compilation, efficient execution

Origins of Go

Go started in 2007 by Rob Pike, Robert Griesemer, Ken Thompson.

Russ Cox and Ian Lance Taylor joined soon after.

There is a story that Go was designed while waiting for a C++ program to compile.

In reality, Go was a response to the many of the frustrations that Rob, Robert and Ken experienced with the languages in use at Google at that time; C++, Java, and Python.

Rob Pike's 2012 paper, Less is exponentially more gives an excellent overview of the environment that gave rise to Go.

Public announcement

First public announcement November 10th, 2009. The Go Programming Language, 2009

Go is an open source project.

All the commits, code review, design, debate, etc, are all done in the open on a public mailing lists.

2009 - 2012

Rapid iteration over the next 2.5 years

Go 1.0 was released on the 28th of March, 2012.

Go 1.0 marked a line in the sand

API stability. The Go 1 compatibility document
No major language changes (there have been a few minor additions)
The path to Go 1

Stability

Pro: Your code you write today will continue to work with newer versions of Go. We assert this on every commit.
Con: The bar for adding a new feature is now insurmountably high.

2012 - now

3 point releases so far; Go 1.1, 1.2, and 1.3.

The fourth, Go 1.4, is on target to ship in December.

Rough 6 month release cycle; 3 month change window, 3 month stabilisation.

Big ticket features are discussed before the change window opens.

Each release has bought incremental improvements in the compilers, the runtime, the garbage collector.

New platforms and new architectures added.

Hello, World!

package main

import "fmt"

func main() {
    fmt.Println("Hello, 世界!")
}

Hello, World! Internet-style

package main

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

func HelloServer(w http.ResponseWriter, req *http.Request) {
    log.Println(req.URL)
    fmt.Fprintf(w, "Hello, 世界!\nURL = %s\n", req.URL)
}

func main() {
    fmt.Println("please connect to localhost:7777/hello")
    http.HandleFunc("/hello", HelloServer)
    log.Fatal(http.ListenAndServe(":7777", nil))
}

Constants

Maintained precisely:

const e = 2.71828182845904523536028747135266249775724709369995957496696763
const third = 1/3

Typed or without type:

const M64 int64 = 1<<20

const M = 1<<20

Evaluated at compile-time:

const big = 1<<100 / 1e30  // valid constant expression

Compiler complains if a constant doesn't fit where it is used.

blog.golang.org/constants

Variables

Statically typed:

var x int
var s, t string

Implicitly or explicitly initialized:

var x int
var s, t string = "foo", "bar"  // multiple assignment

var x = 42                      // int
var s, b = "foo", true          // string, bool

Short variable declaration (inside functions only):

x := 42
s, b := "foo", true

Can safely take address of any variable!

return &x

Types

Predeclared types, the usual suspects:

uint8 (byte), uint16, uint32, uint32, uint64,
int8, int16, int32, int32 (rune), int64,
float32, float64,
complex64, complex128,
uint, int, uintptr,
bool, string,
error  // not so usual

Composite types:

array, struct, pointer, function,
slice, map, channel

Abstract type:

interface

Type declarations

Composition from left-to-right (Pascal style):

[10]byte  // array of 10 bytes

struct {
    name        string
    left, right *Node
    action      func(*Node)
}

func(a, b, c int)
func(http.ResponseWriter, *http.Request) error

A type declaration defines a new type:

type Weekday int

type Point struct {
    x, y int
}

Slices

[]T  // slice of T

Descriptor for an underlying array segment
May grow and shrink
Has length and capacity
Assigning a slice copies the descriptor, not the underlying array

Common slice operations:

len(s)
s[i]
s[i:j]
append(s, x)  // append element x to slice s and return new slice

Slices play the role of dynamically sized arrays
Widely used in Go code

Pointers

Pointers are values which point to other values
For each type, there exists a distinct pointer type, accessible via the address of, &, and dereference, * operators.
No pointer arithmetic

x := 1000
y := &x
y += 4          // nope

Maps

map[K]V  // map K -> V

Map is a language-supplied hash table
Maps values of key type K to values of type V
Assigning a map copies the map reference, not the map contents

Common map operations:

make(map[K]V)
len(m)
m[k]
delete(m, k)

Map iteration order is not specified:

for key, value := range m {
    // order of key sequence different each time
}

Statements

Curly braces (C style)
Multiple assignments and some other new constructs
Statements are not Expressions.
Many cleanups: mandatory braces, no parentheses for conditionals, implicit break in switches, no semicolons, etc.

a, b = b, a                 // swap
f, err = os.Open(filename)

if x < y {
    return x
} else {
    return y
}

switch day {
case Mon:
    ...
    // break is implicit
case Tue, Wed:
    ...
}

Statements, continued

Unified for syntax

for {
    // loop forever
}

range over arrays, slices, and maps

for i, num := range numbers { ... }
for city, pop := range population { ... }

Not shown: break, goto, continue, fallthrough

Functions

Regular functions

func Sin(x float64) float64
func AddScale(x, y int, f float64) int

Multiple return values

func Write(data []byte) (written int, err error)

Variadic parameter lists without magic

func Printf(format string, args ...interface{})

Functions are first-class values

var delta int
return func(x int) int { return x + delta }

Methods

Methods are functions with a receiver parameter:

func (p Point) String() string {
    return fmt.Sprintf("(%d, %d)", p.x, p.y)
}

The receiver binds the method to its base type (Point):

type Point struct {
    x, y int
}

Methods are invoked via the usual dot notation:

// +build OMIT

package main

import "fmt"

// Point START OMIT
type Point struct {
	x, y int
}

// Point END OMIT

// String START OMIT
func (p Point) String() string {
	return fmt.Sprintf("(%d, %d)", p.x, p.y)
}

// String END OMIT

func main() {
    p := Point{2, 3}
    fmt.Println(p.String())
    fmt.Println(Point{3, 5}.String())
}

Methods can be defined for any user-defined type!

For the Weekday type:

type Weekday int

Define String method on Weekday:

func (d Weekday) String() string { // ...

// +build OMIT

package main

import "fmt"

// type START OMIT
type Weekday int

// type END OMIT

const (
	Mon Weekday = iota
	Tue
	Wed
	Thu
	Fri
	Sat
	Sun
)

var names = [...]string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}

// String START OMIT
func (d Weekday) String() string { // ...
	// String END OMIT
	return names[d]
}

func main() {
    fmt.Println(Mon.String())
    fmt.Println()

    for d := Mon; d <= Sun; d++ {
        fmt.Println(d.String())
    }
}

Method calls via non-interface types are statically dispatched.

Interface types

Abstract
Define (possibly empty) set of method signatures
Values of any type that implement all methods of an interface can be assigned to a variable of that interface.

Examples:

interface{}  // empty interface

interface {
    String() string
}

interface {
    Len() int
    Swap(i, j int)
    Less(i, j int) bool
}

Using interfaces

type Stringer interface {
    String() string
}

Both Weekday and Point define a String method, so values of both can be assigned to
a variable of Stringer type:

// +build OMIT

package main

import "fmt"

type Point struct {
	x, y int
}

func (p Point) String() string {
	return fmt.Sprintf("(%d, %d)", p.x, p.y)
}

type Weekday int

const (
	Mon Weekday = iota
	Tue
	Wed
	Thu
	Fri
	Sat
	Sun
)

var names = [...]string{"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"}

func (d Weekday) String() string { // ...
	return names[d]
}

// Stringer START OMIT
type Stringer interface {
	String() string
}

// Stringer END OMIT

func main() {
    var x Stringer
    x = Point{2, 3}
    fmt.Println("A", x.String())

    x = Tue
    fmt.Println("B", x.String())

    fmt.Println("C", Point{2, 3}) // fmt.Println knows about Stringer!
    fmt.Println("D", Tue)
}

Method calls via interface types are dynamically dispatched ("virtual function call").

Goroutines

The go statement launches a function call as a goroutine

go f()
go f(x, y, ...)

A goroutine runs concurrently (but not necessarily in parallel)
A goroutine is a thread of control within the program, with its own local variables and stack. Much cheaper to create and schedule than operating system threads.

A simple example

func f(msg string, delay time.Duration) {
    for {
        fmt.Println(msg)
        time.Sleep(delay)
    }
}

Function f is launched as 3 different goroutines, all running concurrently:

// +build OMIT

package main

import (
	"fmt"
	"time"
)

// f START OMIT
func f(msg string, delay time.Duration) {
	for {
		fmt.Println(msg)
		time.Sleep(delay)
	}
}

// f END OMIT

func main() {
    go f("A--", 300*time.Millisecond)
    go f("-B-", 500*time.Millisecond)
    go f("--C", 1100*time.Millisecond)
    time.Sleep(20 * time.Second)
}

Communication via channels

A channel type specifies a channel value type (and possibly a communication direction):

chan int
chan<- string  // send-only channel
<-chan T       // receive-only channel

A channel is a variable of channel type:

var ch chan int
ch := make(chan int)  // declare and initialize with newly made channel

A channel permits sending and receiving values:

ch <- 1   // send value 1 on channel ch
x = <-ch  // receive a value from channel ch (and assign to x)

Channel operations synchronize the communicating goroutines.

Communicating goroutines

Each goroutine sends its results via channel ch:

func f(msg string, delay time.Duration, ch chan string) {
    for {
        ch <- msg
        time.Sleep(delay)
    }
}

The main goroutine receives (and prints) all results from the same channel:

// +build OMIT

package main

import (
	"fmt"
	"time"
)

// f START OMIT
func f(msg string, delay time.Duration, ch chan string) {
	for {
		ch <- msg
		time.Sleep(delay)
	}
}

// f END OMIT

func main() {
    ch := make(chan string)
    go f("A--", 300*time.Millisecond, ch)
    go f("-B-", 500*time.Millisecond, ch)
    go f("--C", 1100*time.Millisecond, ch)

    for i := 0; i < 100; i++ {
        fmt.Println(i, <-ch)
    }
}

Packages

Packages define boundaries for compilation and reuse.
Packages are directories containing source code.
The unit of compilation is the package, not the file.
You import a whole package, not a type, or a symbol.

Packages you import are referenced by their package's prefix.

import "fmt"

func main() {
    fmt.Printf("Hello %s\n", "world)
}

Import cycles are not permitted.

Small, well polished standard library

The usual libc/libm cast of characters.
Support for networking, HTTP, TLS.
Support for common encodings, XML, JSON.
Support for compression, tar, etc.

golang.org/pkg/

To a first order approximation, the std lib provides only the things needed to build Go itself.

Excellent cross platform support

Windows, OS X, Linux, {Free,Open,Net,DragonFly}BSD, Solaris
NaCl, Google's Native Client runtime
Experimental support for writing some class of Android application coming in Go 1.4

Cross platform is defined as the super set of all platforms with some not supporting a particular feature, rather than the lowest common denominator.

Two production compiler implementations

gc toolchain supports arm (32bit), amd64 and i386. Support for power64 and arm64 in the works.

gccgo toolchain supports all of the above and more.

Other implementations, llgo, tardis-go, etc, keep us honest by writing to the spec.

Tools

/usr/bin/go

Simple, zero configuration, build tool.

All commands and paths are relative to your $GOPATH workspace.

Supports conditional compilation via suffixes and build tags.

Support for cross compilation.

GOARCH=386 GOOS=windows go build mycmd

More tools

Read package documentation

godoc $PKG

Lint your code

go vet $PKG

Solve code formatting issues, once and for all

go fmt $PKG

Built in testing framework, including benchmarking and coverage reports

go test $PKG
go test -cover $PKG

Built in race detector (based on ThreadSantizer)

go {build,test,install} -race $PKG

Questions

This talk is online

talks.godoc.org/github.com/davecheney/presentations/introduction-to-go.slide

All the links inside the talk are clickable, I encourage you to follow them.

Also, please take the time to visit

Rob Pike's Gophercon 2014 Keynote

Francesc Campoy Flores' Go for Pythonistas and Go for Javaïstes