December 3rd, 2020

All times are in PST

9:00 AM

Event kick-off + welcoming

Arrive early for a special surprise!

9:05 AM

High Performance Manual Memory Management in Go

Manish Jain, Founder & CEO of Dgraph Labs

9:40 AM

Floating-point number parsing with perfect accuracy at a gigabyte per second

Daniel Lemire, Professor & Computer Scientist at TELUQ-Université du Québec

Talk Abstract:Parsing decimal numbers from strings of characters into binary types is a common but relatively expensive task. Parsing a single number can require hundreds of instructions and dozens of branches. Standard C functions may parse numbers at 200 MB/s while recent disks have bandwidths in the gigabytes per second. Number parsing becomes the bottleneck when ingesting CSV, JSON, or XML files containing numerical data. We consider the problem of rounding exactly to the nearest floating-point value. The general problem requires variable-precision arithmetic. We show that a relatively simple approach can be many times faster than the conventional algorithms often present in standard C and C++ libraries. We break the gigabyte per second barrier without sacrificing safety or accuracy. To ensure reproducibility, our work is available as open-source software. Our approach has been adopted by the standard library of the Go programming language for its ParseFloat function.

10:10 AM

Serializing Data in Go

Klaus Post, Senior Backend Team Lead at Minio

Talk Abstract:Serializing data can be crucial for maintaining fast and reliable systems. In this talk we will look at options beyond JSON and examine the pros and cons of various serialization options available in Go.

We will look at specific pitfalls when writing custom serializers when designing or choosing between flexible, fast and compact serializers. We use real life examples to examine the Go tools that are available to help out and how they can be connected up.

10:35 AM

Intuitive Performance

Egon Elbre, Senior Software Developer at Storj Labs

Talk Abstract:Performance optimization with 20% of the effort.

10:55 AM

Goroutines and Thread Safe Data Structures

Eleni Fragkiadaki, Staff Engineer, Tech Lead at Monzo Bank

Talk Abstract:Goroutines are a powerful tool that can be used to make code run faster. But is using them always safe or can they create hard to find, hard to reproduce race conditions? In this talk we cover goroutines, wait groups and locks in order to create thread safe data structures for our applications.

11:25 AM

Goroutines: Under the Hood

Vicki Niu, Software Engineer at Byte

Talk Abstract:Goroutines are a key part of Go’s powerful concurrency model, but what really happens when you kick off a goroutine? We’ll walk through what go func() really does, while noting some of the common pitfalls when working with goroutines.

11:45 AM

The Dark Side of Go: Go’s Runtime Related Problems in TiDB Production Environment

Dongxu (Ed) Huang, Co-founder & CTO at PingCap

Talk Abstract:TiDB is a distributed NewSQL database written in Go from the ground up. As the system becomes more complicated, some problems related to Go’s runtime have emerged when applied in production environments. These problems are typical and profound, covering important areas such as memory management, garbage collection, and goroutine scheduling. In this talk, Ed Huang will introduce specific cases in real production environments and share how they reproduced, located, and analyzed these problems.

12:40 PM

Can We Panic Yet? Error Handling in Go

Raphael ‘kena’ Poss, Member of Technical Staff at Cockroach Labs

Talk Abstract:Golang’s “one-size-fits-all” error handling is not a panacea. Alternatives provide good performance, and perhaps more surprisingly, are actually cheaper from a software engineering perspective.

In this talk, we will dive into the Go calling convention and quantify experimentally the mandatory performance overhead of Go’s return value handling, as well as that of handling Go’s panics, a variant of exceptions found in other languages. There is a surprising inflection point with regard to performance between error returns and panic-based exceptions to signal errors, which challenges the programming idioms recommended by the Go team. In fact, we will see how panic-based exceptions can not only improve performance, but generally improve code quality and reduce software engineering costs. These insights will be illustrated through the software patterns found in a major open source project written in Go, CockroachDB.

1:05 PM

Low Coordination Distributed Time Series Database - Thanos

Frederic Branczyk, Founder & CEO at Polar Signals

Talk Abstract:Distributed systems are hard, and we should avoid them at any cost. Arguably Prometheus’ success can in part be linked to its dead simple operational model: a single monolithic binary and everything is in-process, not distributed, and it has its purpose-built local time-series database. While a single Prometheus server can get an organization very far, at scale it is inevitable that Prometheus will need to be scaled out. Thanos is a project that aims to solve the pains of scaling Prometheus. In this talk Frederic will demonstrate how Thanos achieves sane operational complexity by employing distributed systems techniques that minimize the need for coordination.

1:45 PM

White Water Rafting

Danielle Lancashire, Staff Software Engineer at VMware

Talk Abstract:Consensus is a fairly tricky, but critical, distributed systems problem. The classical solution to consensus Paxos is incredibly difficult to implement and is greek to many engineers. Fortunately however, we have Raft - an understandable alternative.

In this talk, I’m going to walk you through the basics of Raft and then build a practical example application using a popular Golang Raft library that we all depend on every day.

2:10 PM

NATS All The Way Up: The Evolution of the NATS Protocol

Wally Quevedo & Jaime Piña, Software Engineers at

Talk Abstract:In this talk, we will give you an overview of the architecture of NATS Server, and an evolution of the internals of the implementation of the NATS protocol (which is now 10 years!). We’ll introduce you to the NATS Adaptive Edge Architecture pattern which gives a distributed system the flexibility to be composed of both nodes that form a cluster in a cloud and edge nodes as well as multi-tenancy. We’ll show how this translates into the implementation of the server (gateway and leafnode connections) to be able to create a global network of servers where the applications can just forget about the endpoints and be developed in terms of available streams and services instead.

2:45 PM

import “chaos”

Ana Margarita Medina, Senior Chaos Engineer at Gremlin

Talk Abstract:As engineers we expect our systems and applications to be reliable. And we often test to ensure that at a small scale or in development. But when you scale up, the assumption that conditions will remain stable is wrong. Reliability at scale does not mean eliminating failure, failure is inevitable. It matters when it impacts our users and it matters how we handle it.

Ana will talk about the practice of Chaos Engineering and how we can proactively embrace failure as we scale our systems.

3:05 PM

Designing for Failure: Fault Tolerance in Distributed Systems

Verónica López, Senior Software Engineer at Digital Ocean

Talk Abstract:In this talk we will explore how fault-tolerance looks like in real world systems, and why it’s better to design strategies with failure in mind, rather than striving for a system that never crashes. We will discuss the current tooling, and what can Go borrow from other ecosystems to achieve this goal.

3:40 PM

Finding a Needle in Haystacks and Chaotic Systems!

Emmanuel Odeke, Founder of Orijtech

Talk Abstract:Building high performance systems can either be made or broken by the lack of high quality and proactive tools. Unfortunately, even today in the age of cloud computing, we still suffer from issues related to lack of good observability to determine the internal states; our tools require very expensive and highly skilled engineers, yet the available tools still have a high cognitive overload and aren’t proactive. In this talk, I’ll show how to find needles in haystacks in common scenarios that you’ve most definitely encountered, but perhaps hadn’t been able to successfully debug without the right tools, or perhaps hadn’t noticed!

4:10 PM

Observability and Measurement in an Active Environment

Jesús Espino, Full Stack Engineer at Mattermost

Talk Abstract:One of the most interesting challenges of the Mattermost project is how to keep adding functionality to our users without affecting the performance. Detecting performance degradations and finding the bottlenecks is key to continue providing our users a smooth and rich experience. As part of this, Mattermost leverages some techniques and tools provided by the Go language and the Go ecosystem, which we will discuss in this talk.

4:40 PM

Taming Vault’s Tests

Nick Cabatoff, Software Developer at HashiCorp

Talk Abstract:Big software projects need big test suites. Vault’s test suite suffered from problems common to big test suites: it took too long to run, and some tests were unreliable but too valuable to throw out. This talk is a retrospective of how we improved it.

5:15 PM

Group Q&A + closing remarks