Conference start & housekeeping matters


Welcome address


Opening keynote: Clear is better than clever

Well socialised Gophers often cite readability as one of Go’s core tenets, I disagree.

In this talk I’ll discuss the differences between readability and clarity, show how to write clear Go code, and argue that Go programmers should strive for clarity, not just readability, in their programs.


High(er) Reliability Software Patterns for Go

Software reliability is often neglected, but is increasingly important. This talk discusses why certain high-reliability software engineering practices exist and how they can be implemented in Go. This talk features real world software failures and describes how such instances can be prevented.



Coffee and snacks.


Understanding Allocations: the Stack and the Heap

Like C, Go uses both stack and heap memory. How can a Gopher know which is being used? Can you influence this decision? What effect does it have on your program? Are there any tools to help? This talk answers those questions and more.


Going Secure with Go

Natalie will discuss a broad range of aspects of Go application security by taking on writing secure code, dependency management and Docker images and containers security.


Using and Writing Go Analyses

The Analysis API is used to write analyses (like those in go vet and go lint) that can help surface bugs and show code improvements to users. I’ll show how to use and write analyses, and see their results, so you can help improve your code quality.


Deep learning in Go - Present and future

After hypnotizing the large scale cloud software community with its capabilities, Go now starts to stare at the exciting area of deep learning. Deep learning in Go?!! But why? And how? What’s next? Curious? Let’s explore it with a fun-filled, fast-paced deep dive into deep learning in Go.


Sponsor lightning talks




Garbage Collection Semantics

Garbage collectors have the responsibility of tracking allocations on the heap, freeing up allocations that are no longer needed, and keeping allocations that are still in-use.

How a language decides to implement this behavior is complicated and it shouldn’t be important for application developers to understand. Plus, with different releases of a language’s VM or runtime, the implementation of these systems are always changing and evolving. What’s important for application developers is to maintain a good working model of how the garbage collector for their language behaves and how they can be sympathetic with that behavior without being concerned as to the implementation.

In this talk, I will explain how to be sympathetic with the Go garbage collector, regardless of the current implementation or how it changes in the future. This will make you a better Go developer.


Go, pls stop breaking my editor

This talk will cover the motivation behind, implementation of, and future plans for gopls, the Go implementation of the Language Server Protocol. This tool is currently being developed by the Go team and Go tools community, and it will ultimately serve as the backend for any LSP-compatible editor.


Optimizing Go code without a blindfold

Making code faster is exciting, and benchmarks in Go make that easy to do!

Not really. Optimizing a program can be complex and require careful consideration to do properly. This talk will demonstrate techniques and tools which are a must for any performance aficionado.



Coffee and snacks.


Controlling Distributed Energy Resources with Edge Computing and Go

With advancing technologies, energy distribution model has changed from being centralised to being distributed. We created a platform for distributing and running IoT apps, written in Go, on edge devices to monitor and control distributed energy resources such as photovoltaic and battery systems.


Data Journey with Golang, GraphQL and Microservices

A unique experience from one of the big online travel agents in SEA, Traveloka, in migrating the internal data platform from a monolith Java app into microservices app in Golang & GraphQL. I will also discuss how we use Kubernetes & Istio to efficiently deploy, monitor and scale this system.




Writing Microservice Integration Tests in Go (Finally)

Integration testing microservices is an extremely difficult task when systems are large, but it doesn’t have to be that way. Golang’s native concurrency enables developers to easily run and communicate with mocked versions of downstream dependencies within their integration test code.


GOing to Sydney

In this talk I will: help to raise awareness of what employers typically look for when hiring for Go developers; pin point the red flags; talk about Sydney’s Go Community.


Engineering Luck: Essential and Accidental Complexity at GOJEK

The talk covers what is to me the most nuanced and difficult to apply concept in software engineering — distinguishing between essential and accidental complexity, and learning to mitigate the latter, while solving for the former.


Closing remarks & group photo



7.00pm to 11.59pm