Go Systems Conf SF 2020


import "chaos"

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

Ana Margarita Medina


Low Coordination Distributed Time Series Database

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

Frederic Branczyk


Floating-point Number Parsing w/Perfect Accuracy at GB/sec

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

Daniel Lemire


White Water Rafting

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

Danielle Lancashire


Intuitive Performance

In this talk, Egon discusses performance optimization with 20% of the effort.

Egon Elbre


Finding a Needle in Haystacks and Chaotic Systems!

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

Emmanuel Odeke


Go's Runtime Related Problems in TiDB Production Environment

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, co...

Ed Huang


Serializing Data in Go

Serializing data can be crucial for maintaining fast and reliable systems. In this talk, Klaus looks at options beyond JSON and examine the pros and cons of various serialization options available in Go. He looks at specific pitfalls when writi...

Klaus Post


Designing for Failure: Fault Tolerance in Distributed Systems

In this talk, Verónica explores 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. Verónica discusses the current tooling and w...

Verónica López


Observability and Measurement in an Active Environment

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

Jesús Espino


High Performance Manual Memory Management in Go

In this talk, Manish expands on his Manual Memory Management in Go using jemalloc blog ( He also announces Slash Enterprise.

Manish Jain


Group Q&A

Wally Quevedo, Vicki Niu, Emmanuel Odeke, Manish Jain, Jaime Piña, Arthur Mao, Daniel Lemire, Nick Cabatoff, Verónica López


Can We Panic Yet? Error Handling in Go

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, Raphael dives into the Go calling co...

Raphael 'kena' Poss


The Evolution of the NATS Protocol

In this talk, Wally and Jaime 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!). They introduce you to the NATS Adaptive Edge Architecture...

Wally Quevedo, Jaime Piña


Goroutines and Thread Safe Data Structures

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, Eleni covers goroutines, wait groups and locks in order to cre...

Eleni Fragkiadaki


Taming Vault's Test

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. Nick's talk is a retrospective of how he and hi...

Nick Cabatoff


Goroutines: Under the Hood

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

Vicki Niu