Gophercon 2016!

I’m a big fan of Go. The simplicity, performance, and tooling make it easy for a relative beginner to software engineering to perform like someone with years of experience. The language and tooling also provides for a great community: interfaces make it easy to tap into powerful functionality, and easy library management (go get) makes it easy for people to share code, and as a result, a lot of people do. The simplicity of the language make it easy for anyone to pick up, and very easy for those who have spent a small amount of time with the language to follow talks on even quite advanced topics, and as a result, Go has nearly a half-dozen conferences devoted to it around the world each year.

This year’s Gophercon has a lot of great talks, and below I’ve listed the few which I’m especially interested in. As soon as they’re posted, I will be posting them here.

Communicating Sequential Goroutines

Adrian Cockcroft
The goroutines and channels of golang have roots in Communicating Sequential Processes by C.A.R.Hoare (1978). Golang idioms and common usage tend to neglect some interesting channel and process based constructs. This talk starts by taking a look at some CSP and Pi-Calculus related papers, then explores two applications structured to use channels and goroutines intensively.

Navigating Unfamiliar Code with the Go Guru

Alan Donovan
In this talk, I will present the Go Guru, an “editor-integrated tool for code comprehension and navigation”. This tool provides traditional editors such as Emacs, Vim, Sublime, and Atom with code navigation features not usually found outside a heavyweight IDE. I’ll demonstrate how to use it to answer the kinds of questions that come up all the time during a typical day of coding.

Go for Data Science

Daniel WhitenackTrending languages for data science/engineering work are python and R, but can Go provide something special and relevant in this developing space? The answer is definitely yes. In this session, I will discuss several major go-based efforts in the field of data science and use cases for Go over python/R in a data processing context. I will also discuss go-based data science workflows and tools, including Go notebooks, to help your get your feet wet.

Don’t Just Check Errors, Handle Them Gracefully

Dave Cheney
Go deeper into error handling than you’ve ever been before.

Understanding nil

Francesc Campoy Flores
Is it a constant? A variable? Where is it defined? What is its type? It has no type? It has all the types? Those are usual questions that people learning Go ask and this talk answers all of them and more. The talk covers the different contexts where nil is used, what it means, the gotchas to be aware of, and some patterns where nil becomes essential. In parallel to the exploration of how nil can be used I will also discuss the origin and history of nil in those contexts.

Go for Crypto Developers

George Tankersley

You’ve heard don’t implement your own crypto! and taken it to heart. Great! Go has very robust crypto packages. But even the standard library offers plenty of ways to make mistakes. We’ll talk you through the options and explain the right answers.

Visualizing Concurrency in Go

Ivan Daniluk
Concurrency in Go has been explained many times in a variety of articles, but there is time to explain it visually using the power of 3D modeling and animations. I’ve built a tool that can visually represent concurrent Go programs using WebGL in a browser. We’ll watch common concurrency patterns in real time 3D animations and will learn visually how does parallelism differ from concurrency.

Practical Advice for Go Library Authors

Jack Lindamood
This talk will go in depth into the decisions popular existing libraries make about how to structure their code for users and the tradeoffs of different solutions. Included is advice on the best way to write public libraries that are easy to use, test, configure, and extend.

Packet Capture, Analysis, and Injection with Go

John Leon Learn about packet capturing, analysis, manipulation and injection using the gopacket package. Useful for port scanning, monitoring, routing, and ensuring your network is secure. The gopacket package provides several interfaces that let you work with existing network layers as well as the power to create your own layers.

Inside the Map Implementation

Keith Randall Ever wondered how maps work in Go? This talk will describe the current Go map implementation in detail and discuss some of the design tradeoffs. I’ll compare Go maps with maps in other languages, comparing the guarantees they provide and how that affects the implementations.

Building Microservices with gRPC – A Practical Introduction

Kelsey Hightower
gRPC is a general RPC framework focused on performance and interoperability across a wide range of programming environments. In this session we will demonstrate, through a series of live demos and code walkthroughs, how to design, build, and deploy a collection of microservices using gRPC from the ground up. Key gRPC concepts will be covered including authenticating gRPC services and clients, service discovery, monitoring, and troubleshooting.

goa: A New Approach to Microservice Development in Go

Raphael Simon 

This tutorial introduces a novel approach to building microservices in Go that uses code to describe the design of the service API. The design is then fed to generation tools that produce not only actual service modules but also other outputs such as client Go packages, command line tools, Javascript and documentation via Swagger specifications and JSON schemas. In this tutorial we will use goa to build a microservice from scratch complete with UI, client tool and documentation. We’ll also take a look at how to leverage the goa request context at runtime to implement the API endpoint.

The Design of the Go Assembler

Rob Pike
The Go assembler was rewritten for the 1.5 release, replacing a suite of C programs, one per architecture, with a single binary, written in Go, that supports all architectures. The usual variables, GOOS and GOARCH, are sufficient to configure it for any environment. This talk will explain how this extreme portability is achieved for such a non-portable problem. The answer lies in the structure and origin of the Go compilation tool chain, a mostly machine-independent input language, and a lot of automation. Even for non-assembling Gophers, there are lessons in the design.

Go Vendoring Deconstructed

Wisdom Omuya
Vendoring has been a major struggle for Go developers. Many of us have had to vendor packages to build dependences into our projects – usually by performing ugly rewrites of import paths. Go 1.5 introduced the GO15VENDOREXPERIMENT environment variable which simplifies this process and avoids those rewrites. In this talk, I’ll demonstrate why and how we switched to the vendor experiment at MongoDB, and I’ll give practical advice on how you can use this feature in your projects.


Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )


Connecting to %s