Registration & Breakfast Reception


Opening Remarks


Opening Keynote: Exporting Go

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.


Go Concurrency Live

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


Engineering Efficiency powered by Go

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.



Coffee and snacks


Writing Efficient Generic Multidimensional Slices

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.


Distributed Scheduler Hell

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.


Native Go Development on GCP with the Context Package

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.



Food for the brain


Distributed Tracing in Grab

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.


Runtime & Concurrency in Go.

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


TDD for those who don't need it

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)


The Hidden Power of Humble Interfaces (lightning talk)

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.



Coffee and snacks


Building CLI apps with Go (lightning talk)

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.


Dgraph - A distributed graph database written in Go

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.


chromedp: A New Way to Drive the Web

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.


Getting started on Ethereum for Go programmers

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.


Concurrency made easy

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.


Closing Keynote: Go get go-jek


Closing Remarks



7.00pm to 11.00pm