Let’s Go! : GopherCon Singapore 2023


I first encountered Go or Golang at a talk in GDG DevFest 2013, and it got me curious back then. Fast forward ten (10) years later, I’m working on the Goat application, primarily using Go. Coding using other programming languages, the transition or learning is not that easy; one way to bridge the knowledge gap is by joining developer communities. Developer communities usually host events like meetups or conferences, which helped me learn Ruby/Ruby on Rails. Still, I have not heard of an active community related to Go in the Philippines. Last year, some of the Likha members attended Ruby Conf Thailand, which made me interested in attending conferences overseas. Then, I found GopherCon SG early this year. The workshop and conference topics are exciting, and I’m interested in how big organizations utilize Go to develop reliable systems.

Ultimate Go Workshop

The workshop aims to teach about having a production-ready application from Day 1; it emphasizes the objective of creating a production-level application using Go.

The workshop provided this repository as a guideline for discussing each topic. The application setup was straightforward; all the commands for setting up the application can be found in the `makefile.`

Here’s some of what I learned in attending this workshop:

  • The application’s project structure emphasizes keeping things simple and intuitive; the files should be in appropriate places, and the separation of concerns is well defined.
  • An overview of using Kubernetes to manage pods; this reminds me of the development setup we employ in freee, making me more interested in learning Docker and Kubernetes.
  • Concurrency in Go is a superpower when used correctly; the discussion clarifies the difference between parallelism and concurrency. Here’s a reference link to the topic.
  • Aside from the technical discussion, it also reminds me of the mindset of being a sound engineer. As software engineers, we are responsible for bringing value to our users and ensuring that the applications we develop are reliable and easy to use. A software engineer’s role significantly impacts our society; the application/system we develop might be related to finance, healthcare, and infrastructure, which requires reliability.

Here are some tools that I discovered during the workshop:


Here are some of the talks that I liked:

Go and LLMs by Chang Sau Sheong

This talk is about utilizing LLMs by creating an application using API.

  • The speaker presented an application that extracts details from a photo of a business card and generates a JSON.
  • Another one is an application that serves as a health assistant. It reads the food’s nutrition label and, based on it, will give food product advice.
  • This is a great use case for utilizing LLMs to develop valuable applications. I realized that these tools are available to craft an application much faster, which leads to providing value to users at an incredible speed.

Building a high-performance JSON parser by Dave Cheney

The speaker discussed creating an alternative JSON parser; he provided a walkthrough of his process and the reason for building one. A few inputs I learned from this talk:

  • API design affects performance. This phrase reminds me of how critical application design is in developing a product, and having a good design and proper execution reduces the time spent on development.
  • JSON parsing is a complex process that involves reading, parsing, and tokenization, to name a few.
  • Performance improvement requires finding the problem’s bottleneck, investigating the root cause, and deep diving if a better solution(tool/package/library) is available or creating one if necessary.

(Link to his presentation: https://dave.cheney.net/paste/gophercon-sg-2023.html)

Keeping Myself Alive with Go by Matt Boyle

The speaker discussed his journey as a Type 1 diabetic and how he managed it. He presented the observability he crafted using Go and other tools that helped him keep track of his blood sugar. He discussed an overview of how he made this happen. First, he has a glucose tracker in his arm; this tool sends the data collected to an app. Then, he parses the values and passes them to his observability tools.

Here are a few things I realized from this talk:

  • Observability was usually used in application, but applying it to personal health is fantastic.
  • Creating a system that involves health is very useful and, at the same time, requires integrity, security, and reliability. Using practical tools is essential to make sure it works properly.
  • A lot of tools are available to create valuable applications/systems.


As a developer still new to using Go, the opportunity to attend an event like GopherCon SG is incredible. I learned a lot from the event, and it made me more curious about Go. As for application in my work, here are some items I have in mind:

  • Having more awareness of the decisions that affect performance.
  • Makes me look into the bottleneck in my current project and plan on how to improve performance.
  • Explore more tools that can help improve the process, not limited to development.


Attending GopherCon SG makes me look for a Go community here in the Philippines and maybe co-organize an event since Likha-IT has tech events.