The State of Go
Where we are in May 2015
27 May 2015

Andrew Gerrand
adg@golang.org


* The State of the State of Go

I gave a similar talk at FOSDEM in February 2015.

.link https://talks.golang.org/2015/state-of-go.slide

This talk builds on that talk.


* Go 1.5


* Release schedule

Go 1.5 is scheduled for release in August 2015.

The major work is done.
We are now in the "feature freeze" period.


* From C to Go

The `gc` tool chain has been converted from C to Go.

Machine-translated `compile` tool replaces `6g`, `8g`, etc.
Machine-translated `link` tool replaces `6l`, `8l`, etc.
New `asm` tool replaces `6a`, `8a`, etc.

Go 1.5 has *no* C code in the tool chain or runtime.

Rob will talk more about this.


* Concurrent Garbage Collector

Goals:

- Limit GC latency to less than 10 milliseconds.
- Run Go application code for at least 40ms out of every 50ms.

.image state-of-go-may/gc.png

.link https://golang.org/s/go14gc


* Concurrent GC trade-offs

The new GC spends a little more memory and CPU time
in exchange for significantly shorter GC pause times.

.image state-of-go-may/gc2.png


* Better concurrency performance

Setting `GOMAXPROCS=N` (where `N` is your number of CPUs) works well in Go 1.5.

Better performance executing goroutines in parallel:

.image state-of-go-may/conc-sieve.png _ 800

Better perfomance switching between goroutines in serial:

.image state-of-go-may/conc-chain.png _ 800


* Better concurrency performance (bottom line)

Better performance under practical workloads:

.image state-of-go-may/conc-practical.png _ 800

And our benchmark suite:

.image state-of-go-may/conc-bench.png _ 500


* Go 1.5 overall performance 

.image state-of-go-may/gcperf.png


* Go 1.5 overall performance (continued)

.image state-of-go-may/perfchart.png


* OS/Arch ports

Go 1.5 supports some new `GOOS/GOARCH` combinations:

- `darwin/arm`, a.k.a iOS
- `darwin/arm64` (newer iDevices)
- `linux/arm64` (cgo is supported, but only with external linking)
- `openbsd/arm` (no cgo or external linking)

And retires some old ones:

DragonflyBSD dropped support for i386; `dragonfly/386` was removed from Go.

Apple no longer supports OS X 10.6 (no security updates since 2013);
the Go port to OS X 10.6 (Snow Leopard) is no longer actively maintained.


* Shared libraries

Go 1.5 can produce Go shared libraries that can be consumed by Go programs.

Build the standard library as shared libraries:

	$ go install -buildmode=shared std

Build a "Hello, world" program that links against the shared libraries:

	$ go build -linkshared hello.go
	$ ls -l hello
	-rwxr-xr-x 1 adg adg 13926 May 26 02:13 hello


Go 1.5 can also build Go programs as C archive files (for static linking)
or shared libraries (for dynamic linking) that can be consumed by C programs.

.link https://golang.org/s/execmodes

(Demo)


* Go programs as C libraries

Given a package:

	package p // import "p"

	import "C"

	//export Foo
	func Foo() int32 { return 42 }

And a main package that imports it:

	package main // import "m"

	import _ "p"

	func main() {} // ignored

You can build an archive file that can be linked into a C program:

	$ go build -buildmode=c-archive m
	$ ls $GOPATH/pkg/linux_amd64
	m.a  p.a  p.h


* A minor language change

You may now omit the key type from a map literal.

This map literal

	m := map[Point]string{
		Point{29.935523, 52.891566}:   "Persepolis",
		Point{-25.352594, 131.034361}: "Uluru",
		Point{37.422455, -122.084306}: "Googleplex",
	}

may now be written as:

	m := map[Point]string{
		{29.935523, 52.891566}:   "Persepolis",
		{-25.352594, 131.034361}: "Uluru",
		{37.422455, -122.084306}: "Googleplex",
	}


* "go doc"

The `go` tool has a new implementation of the old `doc` subcommand,
with a much improved command-line interface:

	$ go doc zip.reader
	package zip // import "archive/zip"

	type Reader struct {
		File    []*File
		Comment string
		// Has unexported fields.
	}

	func NewReader(r io.ReaderAt, size int64) (*Reader, error)

	$ cd $GOROOT/src/archive/zip
	$ go doc reader
	# same output as above

(Demo)


* Execution tracing

The new execution tracer collects data to produce diagrams of process execution.

.image state-of-go/trace.png 350 _

Front end is the Android/Chrome trace-viewer. ([[https://github.com/google/trace-viewer][github.com/google/trace-viewer]])

.link http://golang.org/s/go15trace


* Analysis and Refactoring Tools

We have been working on tools for analyzing and manipulating Go source code.

Analysis tools:

- `oracle`: a tool for answering questions about Go source code (w/ plugins for Sublime Text and Emacs).
- `callgraph`: display the call graph of a Go program.
- `godoc`-analysis=pointer:` see pointer analysis details in godoc.

Refactoring tools:

- `eg`: a template-based refactoring tool
- `gorename`: type-safe renaming of identifiers in Go source code.


* Builder infrastructure

We have been hacking away at our continuous build infrastructure.

Now running Linux, Windows, OS X, FreeBSD, OpenBSD, and Plan 9 builders
on Google Compute Engine.

Spin up builders to do work, spin up many in parallel.
Gives us results much faster.

Sharding of tests on slower platforms (eg, ARM).

Trybots test pending changes. (Demo)


* Mobile

Go 1.5 provides support for Android and experimental support for iOS.

.image state-of-go-may/iphone.jpg 500 _


* The gomobile tool

The `gomobile` tool simplifies toolchain installation and app
deployment.
(It only supports Android right now.)

To install the Android compiler toolchain:

	$ gomobile init

To build an Android APK and install on a device:

	$ gomobile install

To build a shared library for an Android or iOS app:

	$ gomobile bind

(Demo)


* Go community events

- GoCon, Tokyo, June
- GopherCon, Denver, July
- GolangUK, London, August
- GothamGo, New York, October
- dotGo, Paris, November

And more to be announced.

.image state-of-go-may/gophercon.png