more edits

Author: davecheney

3-compiler-optimisations/1-compiler-optimisations.md

@@ -27,7 +27,7 @@ However, a goroutine's stack exists as a cheap place to store local variables; t
 In some languages, for example C and C++, the choice of allocating on the stack or on the heap is a manual exercise for the programmer--heap allocations are made with `malloc` and `free`, stack allocation is via `alloca`. Mistakes using these mechanisms are a common cause of memory corruption bugs.
 
 In Go, the compiler automatically moves a value to the heap if if lives beyond the lifetime of the function call. It is said that the value  _escapes_ to the heap.
-```
+```go
 type Foo struct {
 	a, b, c, d int
 }
@@ -235,15 +235,9 @@ Adjusting the _inlining level_ is performed with the `-gcflags=-l` flag. Somewha
 
 ### Inlining future (Go 1.12)
 
-We're using Go 1.10 for this workshop. A bunch of work happened under the hood for 1.11, but the rules around what is inlined and when have not changed substantively with one exception
-
-A lot of what we've discussed with respect to leaf functions _may_ change in a future release of Go.
-
-There has been work going on in the background since Go 1.8 to enable, so called, mid-stack inlining.
-
-As a Go programmer, this should not be a cause for alarm, mid-
+We're using Go 1.10 for this workshop. A bunch of work happened under the hood for 1.11, but the rules around what is inlined and when have not changed substantively with one exception, mid stack inlining. 
 
-.link https://github.com/golang/proposal/blob/master/design/19348-midstack-inlining.md Proposal: Mid-stack inlining in the Go compiler
+Mid stack inlining is not enabled by default, even in Go 1.11 or tip, but at some point it will be. A lot of what we've discussed with respect to leaf functions _may_ change in a future release of Go.
 
 ## Dead code elimination
 

7-tips-and-tricks/1-tips-and-tricks.md

@@ -1,6 +1,6 @@
 # Tips and Tricks
 
-This final section contains a number of tips to optimise Go code.
+This section contains a number of tips to optimise Go code.
 
 ## Reduce allocations
 
@@ -141,6 +141,10 @@ In your design, some goroutines may run until the program exits. These goroutine
 
 **Never start a goroutine without knowing how it will stop**
 
+A good way to achieve this is to use something like [run.Group][4], [workgroup.Group][5], or similar.
+
+Peter Bourgon has a great presentation on the design behing run.Group from GopherCon EU
+
 ### Further reading
 
 - [Concurrency Made Easy][0] (video)
@@ -206,13 +210,13 @@ defer func() {
 	mu.Unlock()
 }()
 ```
-`defer` is expensive if the work being done is small, the classic example is `defer` ing a mutex unlock around a struct variable or map lookup. You may choose to avoid `defer` in those situations.
+`defer` can be expensive if the work being done is small, the classic example is `defer` ing a mutex unlock around a struct variable or map lookup. You may choose to avoid `defer` in those situations.
 
 This is a case where readability and maintenance is sacrificed for a performance win. 
 
 #### Always revisit these decisions.
 
-.link https://github.com/golang/go/issues/9704#issuecomment-251003577
+However, in revising this presentation, I have not been able to write a program that demonstrates a measurable cost from using `defer` -- the compiler is getting very good at eliminating the cost of using defer.
 
 ## Avoid Finalisers
 
@@ -260,17 +264,17 @@ Old versions of Go will never get better. They will never get bug fixes or optim
 - Go 1.5 and 1.6 had a slower compiler, but it produces faster code, and has a faster GC.
 - Go 1.7 delivered roughly a 30% improvement in compilation speed over 1.6, a 2x improvement in linking speed (better than any previous version of Go).
 - Go 1.8 will deliver a smaller improvement in compilation speed (at this point), but a significant improvement in code quality for non Intel architectures.
+- Go 1.9, 1.10, 1.11 continue to drive down the GC pause time and improve the quality of generated code.
 
 Old version of Go receive no updates. Do not use them. Use the latest and you will get the best performance.
 
-.link http://dave.cheney.net/2016/04/02/go-1-7-toolchain-improvements Go 1.7 toolchain improvements
-.link http://dave.cheney.net/2016/09/18/go-1-8-performance-improvements-one-month-in Go 1.8 performance improvements
-
 ## Discussion
 
 Any questions?
 
 [0]: https://www.youtube.com/watch?v=yKQOunhhf4A&index=16&list=PLq2Nv-Sh8EbZEjZdPLaQt1qh_ohZFMDj8
 [1]: https://dave.cheney.net/paste/concurrency-made-easy.pdf
 [2]: https://golang.org/pkg/bytes
-[3]: https://golang.org/pkg/strings
+[3]: https://golang.org/pkg/strings
+[4]: https://github.com/oklog/run
+[5]: https://github.com/heptio/workgroup