Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
314 lines (236 sloc) 19 KB
title date tags guid
GopherCon 2018
2018-09-04 00:30:46 -0700

This year I went to GopherCon. This post is a grab bag of what I thought was interesting and some thoughts on this conference vs others and conferences in general.

I've been going to YAPC since 2009, and I had planned to go again this year, but my boss said, more or less: "fREW, you probably are not actually learning a lot there, and should try going somewhere else. I suggest GopherCon." So I went.

Before I get into the nitty gritty I have a few thoughts about the conference as a whole. It was super polished; there was live closed-captioning, excellent A/V, swag that included a stuffed gopher, and even my hotel had a Gophercon branded keycard. On the other hand, this is probably why it was so expensive. I could and would personally go to YAPC on my own dime. I would not go to Gophercon on my own dime.

Another really impressive thing about Gophercon was the diversity. Both the audience and the speakers were way more diverse than a typical tech conference, which is both refreshing and encouraging. Maybe things are getting better?

Finally, the community was new to me, so while at YAPC I always look forward to seeing Rik JellyBean Signes, Fitz Elliott, Henry Van Styn, Michael Conrad, some of my coworkers from my last job, and lots of other people, this time I arrived and knew no one except the two other ZR employees. I did have some great conversations with Kayla Kasprak, Dan Moore, and Jamie Luck, but it was still a far cry from YAPC.

If I personally had one takeaway from the conference it would be that it's worth looking over the documentation for the various flags that can be used when building Go binaries. There are a ton of them and they are kinda sprawling. I suggest looking over go help build, go doc cmd/compile, go doc cmd/link, go tool compile; there's an overview of some of the flags here.

The following is a chronological list of talks that I went to and found interesting. I went to others that were fine, but just not for me or whatever.

If you read this in the future after the videos have been published, feel free to let me know or submit a PR to add relevant links.


The Scheduler Saga [liveblog, slides, video]

This was a great intro talk where Kavya Joshi discussed how the Go Scheduler, which is what allows go to run many goroutines without the same amount of threads, basically. She had various simplified implementations and added extra details and refinements until she built up to the actual scheduler. A great start to the conference, and an accurate keynote.

An Over-Engineering Disaster with Macaroons [liveblog, slides, video]

This was maybe my favorite talk of the whole conference. Tess Rinearson went over how Chain used Macaroons (pdf) (think layered cookies, ha ha) to solve authn and authz. I love hearing about the limits of a technology, especially when it involves taking on surprising or frustrating tradeoffs.

Asynchronous Networking Patterns [liveblog, slides, video]

In this talk Filippo Valsorda went over the basics of implementing a server in Go. In the talk he showed some serious pitfalls while implementing a proxy that could reveal parts of the TLS handshake. The pitfalls are worth listing:

  1. Immediately go whatever() when you receive a connection
  2. Make sure you Close your connections.
  3. Set timeouts before reading any data.

Allocator Wrestling [liveblog, slides, video]

In this talk Eben Freeman discussed how the Go allocator works. I have read a few articles about how the normal Unix allocation works so it was interesting to hear how the Go allocator works. One takeaways was that you should limit pointer use not only because it slows down access, it also makes the garbage collector do more work. On a related note, if the garbage collector is busy enough goroutines may be forced to do some of their own garbage collection, slowing them down.

This talk highlights what I meant about the fact that The Scheduler Saga was a good keynote in that much of this conference was about how the Go compiler actually works. Here's a quote from memory from this talk:

The way the compiler works is inherently interesting.

Sure, it's interesting to me, and maybe even everyone at the conference, but that is absolutely false on a universal scale and indeed should be false. It's great to know how things work, but most programmers are (or maybe should be) more interested in solving a business or life problem than how their compiler works.


The following were talks I couldn't make and intend to watch the videos for when they are published.


Writing Accessible Go [liveblog, slides/transcript, video]

In this fascinating and somewhat painful talk Julia Ferraioli discussed what it is like to be a sometimes partially visually disabled programmer. She had a variety of recommendations that help with screen readers, but I also think that an unstated benefit (which she discussed just not directly) was that this can help everyone else when, for example, they are distracted and can't keep a huge system in their head. Or more concretely, consider getting paged at 2am, even focussing your eyes can be difficult, so code that doesn't require intense effort to read is great.

Go in Debian [liveblog, slides, video]

Michael Stapelberg went over four major topics:

  • Go libraries for working with Debian
  • Generic tools written in Go that are relevant for Debian users
  • Services that are written in Go that are relevant for Debian users
  • How Go module authors can ensure that modules are easy to package for Debian

I'm interested in these:

C L Eye-Catching User Interfaces [liveblog, slides, video]

James Bowes showed what is involved in writing nice (interactive) commandline interfaces. He explained a ton of TTY stuff, much of which I already knew but I'd never seen it all presented in one place. Not specifically relevant to Go, but very fun. I might try to use the information here to have more information dense console tools.


Thu (Lightning Talks)

Unlike YAPC, Gophercon puts all Lightning Talks on one day (Community Day.) I think the idea is that you can leave a day early if you want to skip these. I personally prefer that they be more spread out, but I get it.

Lazy JSON Parsing [slides]

JSON parsing in Go is super common and a huge stumbling block to new users. Aidan Coyle discussed the frustrating issue where you have to parse JSON like this:

   "Users": [{
      "Name": "frew"
   }, {
      "ID": 1

Note that the fields in the Users array vary. The magic sauce for this situation is json.RawMessage (see related example).

Modular Audio Synthesis with Shaden

In this fascinating talk Brett Buddin showed how he does audio synthesis with some C, Go, and an LISP interpreter (that I think he wrote) full of live demos. Gotta watch the video for this when it comes out.

Keeping Important Go Packages Alive

Tim Heckman discussed an effort called Gofrs to ensure that important packages stay maintained. The effort has apparently only just started, with just one package in the list. I hope it takes off though, and will gladly volunteer to help out, as I've already run into many abandoned Go packages.

The nuclear option, go test -run=InQemu [slides]

Brad Fitzpatrick discussed an elaborate system he built for testing some code that needed root to resize volumes. He built a system that would let him run his test as pid 1 under a kernel in qemu. Very cool.

Geohash in Golang Assembly [post]

Michael McLoughlin discussed some work he did to optimize Geohashish in Go by manipulating the generated assembly. Given how short the lightning talks are he was only able to touch on some of the instructions used to speed it up. I intend to read the relevant blog post and see how one does this kind of tweaking.

Code search tailored for Gophers

Daniel Martí introduced a tool he wrote called gogrep which allows you to grep your code with a fairly straightforward pattern language modeled on the Go syntax, but instead of searching for bytes it searches for matching syntax. He presented it as a middle ground between grep(1) and Go linters. He also mentioned a linter (there are a huge amount of Go linters) I had never heard of called rangerdanger which seemed cool.


I missed the following talks because I had to attend a remote meeting and intend to watch the videos.

  • Linux, Netlink, and Go in 7 minutes or less!
  • Dynamic distributed tracing for the Edge using Go
  • router7: a pure-Go home router
  • A day in the life of rob Pike
  • Serving GraphQL via Code Generation: gqlgen
  • The Container Network Interface and Go
  • RBAC Manager: Extending the Kubernetes API with a Custom Go Operator
  • Have 7 minutes before lunch? Learn How to Extend the Kubernetes API with Kubebuilder

Athens - the module proxy for Go

Aaron Schlesinger introduced Athens which is a proxy for Go modules. Unfortunately it sounds like it can only download by major version, so if an author adds a new feature but does not break backwards compatibility you cannot tell Athens to pull the new version. Definitely a space to watch though.

Migrating The Go Community

Marwan Sulaiman introduced a tool he built called mod which can automatically create Pull Requests for modules you depend on which do not yet work with the new modules system. It was pretty cool and I suspect that this will help all the non-abandoned packages get migrated. Not so sure how we resolve the abandoned ones though.

What's new in VS Code for Go?

Ramya Rao showed off some new features for Go integration in VS Code. I don't use VS Code but some of the stuff she showed inspired me to figure out if vim-go can do similar things. Another really cool thing she mentioned was that eight of the nine features she showed were actually implemented by members of the community. Awesome.

Linux Delay Accounting [slides]

André Carvalho discussed a rarely exposed but relatively old feature of Linux that lets you find out how much a given process has been delayed. Processes may be delayed because they are blocking on IO, a higher priority process monopolizing the CPU, etc. He built a tool in Go that would let you query the status of a process pretty simply. I intend to try this out.

Evans: more expressive gRPC client

Taro Aoki discussed the difficulties of debugging gRPC vs REST and the introduced a really cool interactive client called Evans that has tab completion via introspection and more. I don't intend to use gRPC any time soon but I love these kinds of tools.

That's all I've got. Overall the conference was good. It is unlikely I'll be able to make it in 2019 since it's such a tax on the family but if it's an option for you, maybe give it a shot.

If you don't already know Go, you should read The Go Programming Language. It's not just a great Go book but a great programming book in general with a generous dollop of concurrency.

I've mentioned in the past that I enjoy good coffee and that I even have a travel setup. As a quick refresher, if you want good coffee at a conference you can get:

They pack nicely (the grinder fits inside of the Aeropress) and the coffee is great. Highly recommend.