Go Systems Conf SF 2020
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...
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...
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...
In this talk, Egon discusses performance optimization with 20% of the effort.
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...
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...
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...
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...
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...
High Performance Manual Memory Management in Go
In this talk, Manish expands on his Manual Memory Management in Go using jemalloc blog (https://dgraph.io/blog/post/manual-memory-management-golang-jemalloc/). He also announces Slash Enterprise.
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...
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...
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.