Registration & Breakfast Reception

From inception, Go has been designed to scale from the small to the very large; Go packages together with import and export are key language features for achieving that software scalability. Sprinkled with historic tidbits, this talk explains the inner workings of import and export, and how these mechanisms enable robust separate compilation of packages. We conclude with a discussion of how our design trade-offs affect scalability.

Robert Griesemer

Go is known for its powerful concurrency primitives but why? Why is concurrency in Go so powerful and an important aspect of future software development? In this talk we will discuss the importance of having languages that provide concurrency support and see how Go’s constructs make it easy to use and reason about for modern software

William Kennedy

In LINE engineering efficiency team, we solve organization scale problem by building tools which improve engineer productivity and unified processes. In this talk, we discover how small tools and automation of development process can help improve your company engineering efficiency, reduce repeatable work and stresses.

Huy Do

Coffee and snacks

Go has no generics. That makes things a lot harder. Or does it? This talk looks at various attempts in creating multidimensional arrays (think matrices and tensors) which are useful in deep learning and mathematics heavy applications. Even better - making them generic so they can take any type.

Chewxy

Containers are the future for all Microservice based apps. Where do you deploy them? How do you manage them? This talk will walk the audience through how distributed schedulers are built, and how the popular ones work. We will drill into details of how to build a distributed scheduler.

Matthew Campbell

Ian and Shilin will tag team in this presentation. The talk will demonstrate(via Kubernetes) how well golang is supported in Cloud Platforms from development, API integration to deployment and operations. In addition, a deep dive into Golang context package and best practices in high concurrency programming will also be covered.

Ian Lewis

Shilin Wu

Food for the brain

When we migrated from our Rails monolith to multiple smaller Go apps, one of the things that we missed the most was the ability to trace a request, a feature that has in the past helped us pinpoint problems quickly. In this talk, I will be sharing how we are bringing this feature back into our Go apps.

Ryan Law

Goroutines are amazing - They work across multiple cores and spawn multitude of threads. While we all love to use the Goroutines, I feel not much time has been spent in explaining upon what concepts they are built - Green Threads & Coroutines. This talk is an attempt to bridge that gap by discussing the above mentioned topics in great detail. The talk will cover Lifecycle of a Go binary GIL (or lack thereof), Green Threads, event loops and Coroutines as well as goroutine gotchas

V N Nikhil Anurag

For the longest time, I didn’t write tests. Writing tests is a chore, a waste of time, and doesn’t GTD. The snobbery of the test community only turned me off even more; discouraging good developers from trying TDD. Now, I write tests first. This talk explains what clicked for me (and maybe it will for you too)

Chew Choon Keat

Learn how to design your own interfaces in Go that are simple yet powerful – just like io.Reader and error. Discover the techniques for correctly identifying the places where interfaces will improve our code, and the specific steps to ensuring that our interfaces are as powerful as they can be.

Aditya Mukerjee

Coffee and snacks

Writing and managing cross-platform CLI applications are hard. Thanks to varying configurations and dependencies every single installation and update can be flaky. Diagnosing causes, reproducing them and applying fixing are usually a time sink. In this talk, you will learn how Go can help to alleviate many of those pains with its statically compiled binaries.

Lakshan Perera

Dgraph is a native and distributed graph database written entirely in Go. Efficient distributed joins is a hard problem and Dgraph tackles it head on. Since v0.1 release in Dec’15, Dgraph has seen a lot of activity, reaching close to 2000 Github stars and featuring on the front page of Hacker News multiple times.

Manish Rai Jain

Introduction to chromedp: a faster, simpler way to drive browsers in Go using the Chrome Debugging Protocol (for Chrome, Edge, Safari, etc) without external dependencies. Includes overview of using chromedp to rapidly author complex task hierarchies for scraping and unit testing/profiling web apps.

Kenneth Shaw

Learn how a Go programmer can get started with the hottest blockchain technology on the block with an easy tutorial that will demonstrate creating a simple smart contract and accessing it from a Go server as well as an Ethereum Wallet.

Dave Appleton

Go’s headline feature is its simple, lightweight concurrency, but most Go programmers that stick with the language for a while tend to look back on their early efforts and say things like “wow, I really went overboard with channels” or “I went crazy with goroutines, it was impossible to understand what the program did”. Clearly there is a disconnect between the concurrency primitives that the language offers, and the expectations of many why come to Go for exactly those features. This talk will explore some strategies for using with concurrency in Go without the pitfalls.

Dave Cheney