Video recording and production done by GopherCon
Since the very beginning CoreOS bet the farm on Go, even before it became the popular language it is today. CoreOS builds and ships components that enable users to create distributed systems from the ground up. Just about everything CoreOS builds including our popular open source projects such as etcd, fleet, and rocket are built using Go; this also holds true for most CoreOS commercial offerings.
But how did we do it? What challenges did we face?
In this talk we will answer these questions and provide a retrospective, if you will, on using Go at CoreOS over the years.
Timehop Engineering has made real strides thanks to using Go in production for two years now and we’ve made plenty of mistakes along the way. Typed nils, bloated interfaces, runaway goroutines, mysterious closure states… you name the mistake, we’ve made it.
Go has emerged as the language of the server, but it remains underrepresented in large, consumer-focused companies like Facebook, Twitter, Netflix, and SoundCloud. These organizations have largely adopted JVM-based tech stacks for their business logic, owing in large part to libraries and ecosystems that directly support their service-oriented architectures.
To reach its next level of success, Go needs more than simple primitives and idioms. It needs a comprehensive toolkit, for coherent distributed programming in the large. This talk describes Go kit, a toolkit for Go in the modern SOA.
The mantra of the Go community is “keep it simple”. Sometimes, this idea is distorted to justify poor engineering decisions. In this talk, we’ll explore what simple really means, and what Go brings to the table.
A good debugger is an essential tool for any software engineer – but Go has some unique characteristics (the runtime scheduler, for instance) that make traditional debuggers unfeasible. So I wrote Delve, a debugger tailored specifically for Go.
When your software misbehaves, how can you glean insight into its unruliness?
To answer that we’ll take a deep dive into Delve. We’ll explore what makes software like Delve work, how it aims to solve problems with existing debuggers, and how you can leverage Delve.
Many lessons have been learned from more than two years of developing Prometheus. Most of its components are implemented in Go, and we run them at their limits during our day-to-day work at SoundCloud. This talk will shed light on various aspects of Prometheus from the perspective of a Go developer, from the instrumentation library all the way to the storage backend.
How cool would it be to write an app for your Android or iOS phone in your favorite language, Go?
Since Go 1.4, Android on ARM is one of the officially supported platforms, and Go 1.5 will include iOS support for ARM. I will present the status of Android/iOS support in Go 1.5, and the efforts around the golang.org/x/mobile repository, which hosts tools and libraries for mobile app development in Go.
Written in Go, Cayley is a graph database based on technology behind Freebase.com. Starting with a short history of the inspirations behind Cayley, this talk will deep-dive into the moving parts of building a graph database, between the various query languages, the storage engines, and the iterator trees.
Communicating Sequential Processes (CSP) are a foundational element of writing Go code. Our Go application, Pillar, processes 15 gigabits per second, packages over 3000 channels, serves millions of users, and runs on more than 450 servers nationwide.
While writing Pillar, we developed five guidelines for the use of Go and CSP. Guidelines that helped us prevent deadlocks, prevent resource leaks, and simplified our code. Go developers will find lasting value in these battle-tested guidelines.
Dynamic tools can provide significant value for small time investment. But frequently they are underappreciated by developers. In this talk I will describe three dynamic tools for Go: data race detector, fuzzing system and execution tracer. The first two tools are related to bug finding, and the tracer can give insights into performance and latency issues of Go programs. I will also share our experiences of systematically applying such tools at scale.
Go can be seen as a language that is too difficult for beginner programmers. The resources and documentation for the language seem too technically advanced for the beginner to pick up fundamental programming concepts. Nevertheless within 5 weeks of looking into Go I taught myself how to build my first CRUD web application and a week later, an API client. In this talk I will share my thoughts about why I think Go is a fantastic teaching tool, and why beginners should not be afraid to learn it.
Learn how Parse.com a backend platform for mobile app developer reinvented its backend stack without breaking compatibility with the existing API using Go as the primary tool. One can say this is upgrading the engine of a plane mid-flight. Come hear about all the war stories.
Find out how at times we did not do things the “Go-Way”. Learn how we were inspired by the Facebook PHP stack
Maintaining consistency within a growing project is a challenge. I have struggled with my company’s Go web API as it has grown over the past two years, trying to find a nice solution to this intra-project consistency problem without resorting to a large-scale framework.
In my mind, there are three general layers to project consistency:
consistency in implementation among similar bits of code
consistency in black-box behavior among similar endpoints or commands
consistency between actual behavior and documented behavior (documentation accuracy)
This talk will outline how I have leveraged small-scale code and documentation generator tools for each of the three layers outlined above, specifically for the sake of consistency in a growing Go application without using a large-scale framework.
Long garbage collection (GC) pauses stand directly in the way of Go’s growth. It is an important, and often times the only, technical reason practitioners give for not migrating to managed runtimes such as Go. If Go is to live up to its promise of providing a better place for developers it must eliminate long GC pauses. This talk presents and discusses the new 1.5 low latency concurrent GC. Motivations will be given, performance numbers will be presented, we will deep dive into some technical challenges, but more importantly we will discuss why this approach fits well with the Go language.
Every once in a while, a new programming language comes up that fundamentally changes how we think about computing. But even more so often, the core ideas behind a “new” language are hinged upon ideas that were first propounded by languages or systems which are much older.
Often our understanding of a language’s features and the intentions thereof are limited by our understanding of its roots.
In this talk, BG will talk about the origins of the core ideas behind Go and will take you on a “language-archeology” tour where we’ll trace the roots of Go.
Go gives us powerful abstraction through interfaces with no bureaucracy. In my quest to find the right balance between pragmatism and abstraction, I have developed some useful patterns that leverage Go’s interfaces to make code modular, lean and clean.
This is a hands-on opinionated talk about software craftsmanship and sane abstraction techniques. This is a talk where you’ll learn how to embrace the interface.
Hear about Fog Creek’s first production Go service: a rewrite of their Git and Mercurial SSH reverse proxy from Python. See how they monitor memory, who’s currently connected, what actions they’re performing, what their code is doing, and how they implement drain-and-die so a connection is never forcefully closed. Response times halved. Scheduled daily restarts were replaced with multi-month uptime, and shoulder shrugging about recent crashes were replaced with detailed forensic logs.
Pick up some tips on how to write resilient services with Go!
Struct tags are a great feature of Go, but in the general Go community they receive almost no attention. In this talk we want to show you some of the cleverest and weirdest uses of struct tags we’ve seen. Specifying json and xml fields in struct tags is commonplace, but have you thought about using tags for object-relational mapping, validation functions, defining middleware, or command line options? Come join us for a tour of our favorite practical and impractical uses of an underutilized part of Go.
Single Static Assignment (SSA) is an intermediate representation of code that many compilers use for analysis and optimization. This talk will look at how the go/ssa package is used in existing Go static analysis tools like eg and oracle and how we can use it to build our own tools.