blob: cd5146938d8f427f66b089e30a52661c7d393955 [file] [log] [blame]
The State of Go
Where we are in February 2016
Francesc Campoy
Gopher at Google
* Time flies
Go 1.4 is one year old (happy birthday!)
Go 1.5 is already 6 months old!
Go 1.6 to be released sometime in February.
Go 1.6 Candidate Release 1 was released on January 28th
* Notes
The slides are available on [[]]
Most of the code examples won't run except locally and using Go 1.6.
The playground still runs Go 1.5.
* Agenda
Changes since Go 1.5:
- the language
- the standard library
- the runtime
- the tooling
- the community
* Changes to the language
* Changes to the language
This is a feature.
* Changes to the standard library
* Changes to the standard library
A couple of new things, in order of excitement.
- net/http
- {text,html}/template
- sort
Also more speed and fewer bugs.
* net/http
- you're using HTTPS
- and Go 1.6
you're using HTTP/2!
* HTTP/2
At a high level, HTTP/2:
- is binary, instead of textual
- is fully multiplexed, instead of ordered and blocking
- can therefore use one connection for parallelism
- uses header compression to reduce overhead
- allows servers to “push” responses proactively into client caches
* text/template
Imagine that given a slice of strings:
[]string{"one", "two", "three"}
We want to write a template that will generate:
What template would you write?
* text/template: first try
Naturally, I write this:
.play state-of-go/template/old.go /`/,/`/
But unfortunately it's not exactly what I want!
* text/template: let's fix it
We need to be careful with the line breaks.
.play state-of-go/template/fixed.go /`/,/`/
This works now, but ... I don't really like my code!
* text/template: meet {{- and -}}
Go 1.6 brings two new delimiters:
- `{{-`
- `-}}`
Similar to `{{` and `}}`, but _all_ white space on the `-` side will be trimmed.
The template:
{{23 -}}
{{- 45}}
* text/template: back to our problem
We can now have:
- the result we expected
- without sacrificing the readability of our templates.
.play state-of-go/template/new.go /`/,/`/
* text/template: the block action
Go 1.6 brings also a new action named `block`.
Let's see what it is useful for.
* Factoring out repetition in templates
Both `<ul>` share the same structure.
{{define "presentation"}}
{{range .Authors}}
{{range .Topics}}
Templates can be used to avoid repetition.
* Factoring out repetition with templates (cont.)
We can define a new template:
.code state-of-go/template/define.go /define "list"/,/^{{end}}/
And use it where needed:
.code state-of-go/template/define.go /define "presentation"/,/^{{end}}/
* Factoring out repetition with templates (cont.)
We can parse that template and execute it.
.play state-of-go/template/define.go /func main/,/^}/
* Template redefinition
We made also our template easier to reuse, as we can redefine `list`.
.play state-of-go/template/redefine.go /func main/,/^}/
* Meet the block action
The `block` action defines and executes a template in place.
.code state-of-go/template/blocks.go /define/,/`/
That template defined by `block` can be:
- referenced later by the same template,
- redefined with `define`.
* Why do we need it?
It is more compact when
- we're not factoring out repetition,
- but we need to provide an extension point.
We can make the following template more compact with `block`.
{{define "content" .}}
{{define "page"}}
{{template "content" .}}
* Why do we need it? (cont.)
We can make the following template more compact with `block`.
{{define "page"}}
{{block "content" .}}
And still easily redefine `content`.
* sort.Sort is faster
`Sort` sorts your data by calling `Less`, `Swap`, and `Len`.
We reduced the number of comparisons and swaps by about 10%.
Sort `[]int` with Go 1.5
BenchmarkSort_1-4 20000000 67.2 ns/op
BenchmarkSort_10-4 10000000 227 ns/op
BenchmarkSort_100-4 500000 3863 ns/op
BenchmarkSort_1000-4 30000 52189 ns/op
Sort `[]int` with Go 1.6
BenchmarkSort_1-4 20000000 64.7 ns/op
BenchmarkSort_10-4 10000000 137 ns/op
BenchmarkSort_100-4 500000 2849 ns/op
BenchmarkSort_1000-4 30000 46949 ns/op
* sort.Sort is faster - plot
.image state-of-go/img/bench-sort.png _ 800
* Sort order and sort.Stable
Reminder: sort.Sort is not a _stable_ sort.
.play state-of-go/sort/unstable.go /byLength/,
Use `sort.Stable`:
.play state-of-go/sort/stable.go /func main/,
* Minor changes
.image state-of-go/img/minorchanges.png _ 900
.caption too many to discuss: find them [[][here]]
* Let's just discuss one
`time.Parse` is smarter!
.play state-of-go/time/time.go /func main/,/^}/
* Changes to the runtime
* Detection of concurrent map accesses
Detection of unsafe concurrent access to maps.
.play state-of-go/runtime/crash.go /const/,/Wait\(\)/
fatal error: concurrent map read and map write
fatal error: concurrent map writes
* Does it make it slower?
Let's benchmark it - with a correct solution.
.code state-of-go/runtime/good/good.go /func count/,/^}/
* Benchmark results
Go 1.4 - GOMAXPROCS = 4
BenchmarkCount_1 1000000 1862 ns/op
BenchmarkCount_10 100000 21214 ns/op
BenchmarkCount_100 1000 1602507 ns/op
BenchmarkCount_1000 10 141712948 ns/op
Go 1.5 - GOMAXPROCS = 4
BenchmarkCount_1-4 2000000 867 ns/op
BenchmarkCount_10-4 200000 6909 ns/op
BenchmarkCount_100-4 1000 1025092 ns/op
BenchmarkCount_1000-4 20 94093719 ns/op
Go 1.6 - GOMAXPROCS = 4
BenchmarkCount_1-4 2000000 750 ns/op
BenchmarkCount_10-4 200000 6582 ns/op
BenchmarkCount_100-4 2000 1113790 ns/op
BenchmarkCount_1000-4 20 87998054 ns/op
* Benchmark results plot
.image state-of-go/img/bench4.png _ 800
* Benchmark results
Go 1.4 - GOMAXPROCS = 1
BenchmarkCount_1 100000 1370 ns/op
BenchmarkCount_10 20000 8622 ns/op
BenchmarkCount_100 500 362725 ns/op
BenchmarkCount_1000 50 31378803 ns/op
Go 1.5 - GOMAXPROCS = 1
BenchmarkCount_1-4 2000000 776 ns/op
BenchmarkCount_10-4 200000 6288 ns/op
BenchmarkCount_100-4 3000 345037 ns/op
BenchmarkCount_1000-4 50 31751625 ns/op
Go 1.6 - GOMAXPROCS = 1
BenchmarkCount_1-4 2000000 767 ns/op
BenchmarkCount_10-4 200000 6041 ns/op
BenchmarkCount_100-4 5000 329328 ns/op
BenchmarkCount_1000-4 50 30176034 ns/op
* Benchmark results plot
.image state-of-go/img/bench1.png _ 800
* Garbage Collector in Go 1.5
At [[][GopherCon 2015 Rick Hudson gave a presentation]] about the Go 1.5 low latency collector
.image state-of-go/img/gc345.png 500 _
* Garbage Collector in Go 1.6
At [[][QCon SF in November Rick Hudson]] gave an updated presentation which showed this comparison of Go 1.5 to the upcoming Go 1.6
.image state-of-go/img/gc56.png 400 _
* Garbage Collector on tip
Right now it's even better!
.image state-of-go/img/gcgotip.png _ 600
* People loved it with Go 1.5
.image state-of-go/img/twitter1.png _ 550
.caption [[][original tweet]]
* People love it even more with Go 1.6
.image state-of-go/img/twitter2.png _ 600
.caption [[][original tweet]]
* Oops
.image state-of-go/img/twitter3.png _ 600
.caption [[][original tweet]] and [[][video]]
* New ports
Experimental ports to Linux on 64-bit MIPS (linux/mips64 and linux/mips64le).
Experimental port to Android on 32-bit x86 (android/386).
On Linux on little-endian 64-bit PowerPC (linux/ppc64le), Go 1.6 now supports cgo with external linking and is roughly feature complete.
On NaCl, Go 1.5 required SDK version pepper-41. Go 1.6 adds support for later SDK versions.
* Changes to the tooling
* The cgo tool
Go is garbage collected, can C and Go share memory?
In short:
- Go can pass a pointer to C
- the referenced memory can't have pointers to Go allocated memory
- C can't keep pointers to the memory after the call returns
In more detail:
- the `cgo` [[][docs]].
This is checked by the runtime at execution.
You could disable the checks, but you probably shouldn't.
* Sharing pointers between Go and C
.code state-of-go/cgo/main.go
panic: runtime error: cgo argument has Go pointer to Go pointer
* The go tool
GO15VENDOREXPERIMENT is now enabled by default.
How does it work?
main.go (import "")
main.go (import "")
`server-one` uses the `mux` package in `$GOPATH/src/`.
`server-two` uses the `mux` package in `vendor`.
* Vendoring demo
* go doc
Go 1.5 added the possibility of searching by name
go doc math Pi
Go 1.6 defines priority of packages with import paths with less elements.
Non vendored packages appear first.
* go vet
Go vet warns if the code prints a function instead of its result.
.play state-of-go/govet/main.go
`go`vet` output:
main.go:8: arg foo in Println call is a function value, not a function call
The warning can be removed using `%p` in the format string.
* The community
* The community
Code of Conduct announced on November 24th 2015
Go meetups:
- [[]]
Women Who Go - 7 chapters already!
- [[]]
* Conferences:
- [[][GopherGala]] Jan 22-24th (judging proposals now)
- [[][FOSDEM]] Right here, right now. Hello!
- [[][GopherCon Dubai]], Feb 23rd
- [[][GopherCon India]], Feb 19-20th
- [[][Gophercon Denver]], Jul 11-13th
- [[][dotGo]], Nov 9th
* Go 1.6 release party, February 17th
Go 1.6 ships soon!
Go meetups are organising to hold a [[][release party]] on the 17th of February.
.image state-of-go/img/party-gopher.png _ 300
.caption Join the party!!!