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.

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.

Bernerd Schaefer

Go lets you to compile your program into stand-alone binaries which can be safely shared across systems without worrying about a missing dependency.

But there’s one thing even a stand-alone executable depends on: the operating system. What if you could remove that dependency, too?

AtmanOS is a project built to explore that question.

It allows you to compile ordinary Go programs and run them on cloud providers like Amazon’s EC2, without a traditional operating system.

Let’s explore how it works, how to use it, and some considerations for putting it into production.

Bill O'Farrell

At the IBM Linux on z Systems Open Source Ecosystem team, we have ported the Go language tooling (compiler, assembler, linker) to the Linux on z platform.

This tutorial will cover both the process we followed in doing so, some of the challenges we faced, and some of the performance hiccups and opportunities we encountered along the way.

The challenges included bootstrapping a compiler and runtime themselves written in the target language, designing a strategy for relocation, and finding ways to exploit z architecture strengths.

Carolyn Van Slyck

You may not realize it but there are a lot of Windows developers moving into your neighborhood.

They are using and contributing to open source projects, even those that aren’t just for Windows.

But here’s the rub: Often tools are written Unix first, shoehorning Windows support in later. This approach can shut out potential users.

Lucky for us, Go has strong support for cross-platform development. So let’s start writing cross-platform first and welcome our Windows neighbors.

Learn some of the Windows quirks that you should take into account, and the Go goodies to help you conquer them.

Daniel Whitenack

Trending 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.

Dave Cheney

Donnie Berkholz

Based on my experience with open source, community and Go, I’ll dig into the traction of Go relative to competing systems languages, examples in production, and the health and growth of Go’s community.

Emily Gu

Developers are often told reflection is bad and should be avoided. However, when reflection can help reduce the amount of code needed to solve a problem, it should be considered.

Reducing complexity while preserving maintainability must always be a priority. Reflection can be a tool that helps makes this possible.

In this talk I am going to show you the power and elegance of the reflection package.

Filippo Valsorda

cgo is a powerful tool, but using it right becomes subtle when memory starts to be shared between C and Go.

Thankfully since Go 1.6 the rules to follow are clear and the cgo behavior well defined.

In this talk we will look at cgo’s capabilities and functioning, understand the issues related to memory management and garbage collection, and learn to develop safely around them to build bindings, but also static binaries and even C libraries.

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.

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.

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.

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.

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.

José Carlos Nieto

Lantern is a circumvention tool that people can use to access the Open Internet without restrictions. Lantern uses Go on its desktop client, server infrastructure and on its Lantern Mobile application for phones.

We’ll focus on Lantern Mobile: this talk begins with our experiences working with Go Mobile and ends on a list of gotchas and suggestions on how can you start writing backends for mobile apps as well.

Katrina Owen

How do you learn Go? First do the tour. Then read the language spec. Then write a lot of code.

This works for a lot of people, but for some the gap between the tour and the spec is a vast chasm.

In his GopherCon 2015 keynote, Russ Cox said: Go needs everyone’s help, and everyone isn’t here.

This talk draws on two years of iterative exploration. It examines one way to bridge this gap, aiming to make Go accessible to a broader audience.

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.

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.

Marcel van Lohuizen

Human languages are more often than not messy, inconsistent, and full of surprises. Although this can make languages interesting, it is not something you want to deal with in your code.

The golang.org text repository provides a collection of packages for dealing with the intricacies of human languages at a high level.

This tutorial teaches the basic principles of dealing internationalization and localization in Go code and presents many of the high-level concepts you need to know.

Michael Matloob

Interested in contributing to the Go Programming Language open source project, but don’t know where to start? Come learn how you can get involved and find something to work on.

If you’re already contributing, come learn how to more effectively review CLs and help make the contribution process smoother for others.

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.

Renee French

Everyone is familiar with the Go Gopher but who is he really? What is he thinking about? What gets him motivated in the morning? And how does he hold that Champagne glass?

Come to this talk and find out.

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.

Takuya Ueda

Go Mobile (golang.org/x/mobile) is a project which shows new possibilities for mobile apps development.

Especially, for mobile games which requires high performance processing, Go can be expected to be an alternative to C and C++.

This session explains how to develop game apps using some packages such as app, event and sprite provided by Go Mobile project.

Furthermore the session introduces a way to call Android API from Go codes, and solutions for some problems which occurs when we distribute apps on Google Play.

I would like to show current capabilities and future potentials of Go Mobile.

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.