Rob Pike opens the conference in the way that only Rob can.
Go is the language of the cloud. Here’s why we chose Go and how we’re using it to develop high-performance systems.
We discuss the Go Circuit project and set it in the context of an inevitable and oncoming shift in the development and runtime stacks of the Internet age. We argue that the programming language is the right place to abstract access to a hardware clusters as a "Single-System Image". On the way, we appeal to the success of Erlang in the Telecom industry and discuss why it has not yet inspired Internet-age counterparts. Somewhat unlike Erlang, where the distributed operating system OTP is below the language, we assert that the distributed OS should be built above and using the language. We conclude with an important high-level observation that single desktop machines are qualitatively identical and only quantitatively different than distributed hardware clusters, in terms of the semantics of their behavior in the presence of failures.
Channels are Go's communication mechanism and the standard way for goroutines to communicate. But there are many uses of a channel that go beyond simply sending data to a goroutine.
This talk will start with the basics of channel communication and work through examples of channels as buffers, channels as memory managers, channels as signaling devices, channels for coordination, for load balancing and the many uses of channels of channels.
The talk will be suitable for beginners and for intermediate Go programmers. All the code shown in the talk will be released.
PayPal Beacon is a small piece of custom hardware powered by Go. I'll discuss the design and implementation, including:
A simple, custom network stack that integrates with net/http cross-compilation and portability
Using composition to maintain sanity in an unreliable operating environment
This will be an intermediate level talk. It assumes comfort with Go; experts may be mildly bored
As a Sysadmin, why should you learn more about Go? Well, imagine not having to mess around with old versions of Python or Ruby(I’m looking at you RHEL 5), or fall back to C when you need to improve performance. Imagine being able to deploy self-contained binaries that don’t require yet another runtime to be installed on the target system. If that sounds awesome to you, then you’re going to love Go.
Using packages found in the standard library and Go’s unique language features, I’ll show you how to solve common Sysadmin problems in new ways, and set the stage for tackling a whole new set of problems that our current tools have made way too complicated.
Attend Go for Sysadmins and learn how to:
Leverage the Go standard library for everyday system administration tasks
Make practical use of goroutines and channels in system utilities and scripts
Follow best practices for managing, building, and distributing Go projects
Heka is a high performance data collection and processing tool built by Mozilla's Services team. This talk will start with a brief overview of Heka the product, describing what it is and how it works. This will be followed by an overview of Heka the project, addressing questions such as why Go was chosen, and how that choice has worked out for our developers, administrators, and users.
Google App Engine is a highly scalable web app platform, and its Go runtime is fast, efficient and a natural fit for many kinds of Go web apps. Come hear the origin story of Go on App Engine, the latest news, and see how it fits together with ordinary Go tools.
Databases have traditionally been the domain of C and C++ because of their need to squeeze every last clock cycle out of a system. But writing a whole database in C is not for the faint of heart. Luckily, we don't need to.
In this talk, I'll describe why I chose Go to write SkyDB, an open source behavioral analytics database, and some of the design choices that go into high performance Go code. We'll look at pure Go optimizations in stream processing and data access. We'll also look at integrating with cgo and external JIT tools to optimize the most performance critical code. And finally, we'll look at how to utilize Go to distribute processing across multiple cores and multiple machines.
From Node.js to Go discusses the wins and pain points when switching from a majority Node.js codebase to a majority Go codebase. I will discuss the pragmatic framework we used to make the decision to switch and the outcomes related to our experience having a 90% Go backend.
NSQ is a realtime distributed messaging platform, built entirely in Go, that promotes distributed and decentralized topologies without single points of failure, enabling fault tolerance and high availability coupled with a reliable message delivery guarantee.
It was built to support bitly's data engineering systems and has continued to grow in adoption to power infrastructure at Path, Hailo, Life360, Trendrr, Simplereach, and others. It is a vibrant member of the Go open source community.
Building easy-to-operate, large scale, high volume distributed systems for production tends to present unique and interesting problems that stretch ones assumptions.
This talk is the product of our experience developing NSQ and operating Go services in production.
It covers the evolution of bitly's infrastructure to the design and implementation of NSQ, a match made in heaven for Go. This includes the challenge of optimizing a garbage collected language, managing those pesky goroutines, and a healthy dose of distributed systems.
As developers, our day is spent interacting with command line applications in the terminal. Originally these tools were written in C or C++. Of late, there has been a move to languages such as Ruby, Python or Java as a way ease development of these command line applications. This move has come with increased cost to the end users in the form of OS incompatibilities or runtime interpreters that they needed to install.
What if you could get the ease of development without the increased cost? This talk will make the case that Go is a viable replacement for writing these command line tools. It will present real life lessons learned from the rewrite of the Cloud Foundry CLI tool from Ruby to Go. It will also show patterns that the team used to make the tool easy to test and understand from both the UI and the API interaction layers. It will finally show how to cross compile dependency free, statically linked binaries so that you can provide the users of your tool with one standalone binary to run.
If you are tired of sacrificing ease of end use for ease of development in command line tools, this talk is for you.
Camlistore is your personal storage system for life. It's one of the oldest large Go programs, developed in concert with the Go standard library from June 2010 until present, and has had many gophers hack on it. It's seen and helped shaped the standard library from before r56 to r60, to Go 1 (the first stable release in March 2012), 1.1, 1.2, and 1.3. Hear about Camlistore's goals, see it in action, see fun code, and hear some of the Go standard library history.
It's time for the Go compilers to be written in Go, not in C. I'll talk about the unusual process the Go team has adopted to make that happen: mechanical conversion of the existing C compilers into idiomatic Go code.
Announcement of the winners of the Go QML Contest.
Find out why some people claim Go and MongoDB are a "pair made in heaven" and "the best database driver they've ever used" in this talk by Gustavo Niemeyer, the author of the mgo driver, and Steve Francia, the drivers team lead at MongoDB Inc.
Go is a simple language. Sometimes, that simplicity means that common, peripheral tasks are deferred to other tools to solve. This talk will explore some of the questions that we've asked ourselves at SoundCloud about writing, building, deploying, running, and maintaining Go code in a production environment, focusing on the areas where the Go ecosystem doesn't offer clear guidance. We also hope to provide at least a few answers.
Big data and analytics is becoming incredibly important as information on people and their lives become more readily available. Companies are looking for ways to acquire, store and process personal information on their users to help provide intuitive experiences and sell products or services. Using Go and Mongo, you can build these analytic engines with all the flexibility, scalability and performance you need. In my talk I will show how you can leverage Go and MongoDB to load customer data and both public or personal offer feeds at runtime. Then using a simple Go based web tool and service, build rules to identify products and services your customers will want.
Docker is one of the faster growing open source project. Less than 5 months after launching, the project had 60K+ users, over 6000 github stars, over 100 derivative projects, and over 150 significant contributors from around the world. Docker has been integrated into a number of key projects (Chef, Puppet, Jenkins, Travis, Vagrant, OpenStack), and has been deployed at some of the largest web properties, stirring hype and controversy in the open-source community in the process. But what the hell does a “container engine” do, and why is everyone so excited?
In this presentation, Victor Vieux, one of the core engineer of Docker, will explain the philosophy and history behind Docker, show examples of the projects built by the Docker ecosystem, and paint a picture of how Docker can change the way we think about software distribution and deployment. He will also speak about the rationale for writing Docker in Go, and the impact that has has on the project growth. In the presentation, he will show a number of examples, including how to build a open source playground for Go.
We have recently been working on a game called hackerbots whose server-side component we chose to author in go. We learned quite a few lessons about how to write server-side code in go along the way. A few of the things we will discuss include:
How to test for (and solve) leaking go routines
How to use the profiler to uncover issues with your code
Mixing websockets and http for game play and game control
Go concepts that help us separate game state, player updates, and network traffic
Optimizing JSON serialization for minimal traffic while maintaining human readability
How go got in our way, and what we did to make it less painful- how to debug and fix 'frozen' server code
We will discuss what it is about go that really helped us write our game, with a focus on sharing stories that stand apart from the typical anecdotal reasons for choosing go.
Come learn how we used the go tooling to keep our game within the constraints of a tiny virtual machine whilst having a blast doing so.
The robotics revolution has already begun. You can buy drones and robotic devices at local retail stores. Unfortunately, it’s hard to develop code for robots, and nearly impossible to create solutions that integrate multiple different kind of devices. Introducing Gobot, a set of robotics libraries written in the Go programming language. Gobot can communicate with many different kinds of hardware devices, and integrate them together. With surprisingly few lines of code, you can write interesting applications that tie together Arduinos, ARDrones, Spheros, and more… even all at the same time! The time has come for Go powered robotics, and Gobot is here to help!
Presented with the realization that his thunder for his original talk had been covered by the presenters from the previous day Blake switched it up and conducts an insightful panel with the Go team, instead of his original presentation:
Go's stdlib is filled with interesting solutions to fun problems. I will surface them for your amusement and also in hopes to give everyone a better understanding of Go's use of its own simple, yet powerful features.
I will show how to use Go's database/sql package, with MySQL as an example. Although the documentation is good, it's dense. I'll discuss idiomatic database/sql code, and cover some topics that can save you time and frustration, and perhaps even prevent serious mistakes.
Go is well-known as a rising star in building infrastructure and networked services. But it also makes an excellent choice for building developer tools that are downloaded and run on diverse, uncontrolled environments around the world. I will briefly cover why Go makes such an excellent choice for creating developer tools, but the talk will focus primarily on how to solve the most common problems unique to these tools. I will cover how to bundle non-code asset files, safely cross-compile release builds, remotely auto-update, gracefully handle crashes and more by drawing on lessons and techniques learned building my own developer tool, ngrok.
Despite what many compiler-fearing communities may say, Go is a fantastic language in which to build web services. This talk will start by catching everyone up on the Go standard library's HTTP packages, their strengths, and their weaknesses. We'll talk about JSON and its relationship with Go data structures, learn about Go's excellent support for reflection and how we can use it and the Go compiler to create safe APIs. Using some choice open-source packages we'll create higher-level APIs, collect metrics, and write tests. Finally, we'll get our Go web services into production and talk about stopping gracefully and restarting without downtime.