Gophercon 2023 San Diego

Last September I had the chance to attend Gophercon 2023 in San Diego, California. The conference featured a wide range of topics, from home projects, to high-level scalable software designs and abstract maths topics. The conference was absolutely worth the travel effort and jet lag, and I would recommend it to anyone interested in the Go programming language. Here is how it went.

The travel

The alarm clock rang at exactly 1:00 AM on Sunday 23.9.2023. Soon after breakfast, I was on a bus to Helsinki Airport. The queues at the airport were manageable and at 8:00 I departed to London, where a 4-hour-long layover would wait me. After a 2-hour delay, I embarked on an 11-hour flight to San Diego, which would land at 6:00 PM. After a surprisingly short queue at the border control, I took a taxi to the hotel and went to sleep, as I had been awake for more than 24 hours.

The venue

Being my first time in the USA, San Diego looked exactly how I imagined California to be: Sunny, lively and full of palm trees and taco stands. The city was surprisingly walkable and very clean, resulting in me racking up more than 15000 steps each day of my stay.

The conference was held in the Marriott Marquis hotel in San Diego Marina, a lovely hotel with a great view of the bay. The conference was held in the hotel’s conference halls, which were spacious, but sometimes they got quite crowded and people had to stand up.


Tuesday was workshop day for who bought additional workshop tickets. I have attended two workshops: Supercharged microservices with NATS in the morning and Introduction to Rust in the afternoon.

Supercharged microservices with NATS

This 4 hour workshop was held by Jeremy Saez, senior software engineer at Synadia. The workshop was a hands-on introduction to NATS, a high performance messaging system, built with scalability and clustering in mind. The workshop was very well-structured, starting with the basics and ending with a more complex example of a distributed system. The workshop was divided in 4 one-hour long sessions which included theory and hands-on exercises. I attended this workshop as my customer work is using NATS heavily and being taught by a very knowledgeable person helped me a lot in upping my game.

The best part of the workshop was using the micro package, which allows to create microservices that communicate through NATS, and have builtin observability and load balancing.

The main takes from the workshop were:

  1. NATS is very simple in nature, but allows for very complex distributed systems that span multiple geographical regions
  2. NATS is very fast, with a single server being able to handle roughly 1 million messages per second in the best scenario
  3. A NATS server can be started in seconds, and configured easily with a simple configuration file
  4. NATS is written in Go, and has client libraries for most programming languages
  5. NATS micro allows to spawn microservices in Go, simplifying the development of microservice heavy systems

Introduction to Rust

Wait what? A Rust workshop at a Go conference?

After a generous Mexican lunch I attended the introduction to Rust 4 hour-long workshop, held by Herbert Wolverson, Rust trainer at Ardan Labs. His workshop was very good introduction to the Rust world, starting from the basics to the creation of a small HTTP server template. The workshop was divided in units, where each unit would build on top of the previous ones.

I felt the workshop was too fast-paced, so that I could not fully grasp the concepts before moving on to the next one, even though afterward I revisited the notes I had taken and everything made sense, but I understand that Rust is a complex language and was is hard to fit everything in a 4-hour workshop.

My main takes from the workshop were:

  1. Rust is complex, but once grasped it is a very powerful language
  2. Rust’s compiler is one of the strictest I have seen, and the error messages are the best I have ever seen
  3. Rust’s borrow checker is a powerful tool, but it takes time to get used to it


Wednesday and Thursday were the main conference days, split into two parallel tracks. Between the talks it was possible to visit the sponsor stands, where the sponsors would give away swag and talk about their products. Among the sponsors, Jetbrains and Google had the best stands, but not the coolest gadgets!

Conference loot Some of the conference’s loot

Here are some highlights from the talks I attended.

Building a distributed system in Go

The talk was about how to build a distributed systems in Go using Raft and Raft consensus to sync data across distributed nodes, and why it is no easy task.

The main take from this talk was that setting up a distributed systems might be easy nowadays, but making it perform and be reliable is a very hard task. To achieve this, testing is essential, especially storage level tests, as well as fault tolerance and node stability testing.

Cleaning up your GoOOP

This talk was about how to write better Go code by avoiding the use of OOP patterns and instead using Go’s interfaces and structs. The speaker showed us the most common pitfalls of OOP in Go, and how to avoid them, as well as how to refactor the code to abide to the Go way of doing.

The main take of this talk was that Go is closer to C than it is to Java, and should be treated as such. Go’s interface is a powerful tool, but should be used with care, as it can lead to code that is hard to read and maintain, as it is easy to slip into OOP with too many abstraction layers. Furthermore, Go programmers should abide to the SOLID principles.

Understanding supply chain threats with static analysis

This talk focused on the dangers of dependencies in Go software projects, and how to mitigate them. Go’s philosophy is to be easy to read and write, and to have as few dependencies as possible. This lead to a consistent package management system and to well-defined and coded packages. However, this does not mean that Go is immune to supply chain attacks, as the speaker showed us.

The main problems with dependencies have to do with trust: do you trust the package you are importing? How can you be sure that when you update it, it doesn’t turn into malicious code? The speaker introduced us to capslock, a static analysis tool that focuses on analysing the capabilities of a dependency. For capability the speaker intended a core functionality, like reading/writing files, opening network connections, etc. With these tools it is possible to detect if a dependency is doing something it shouldn’t, and to eliminate that in favour of a more trustworthy alternative.

Building a community

In this light talk the speaker talked about how to build a community from scratch with no prior experience. The speaker talked about how he started the Go community in his city, and how he managed to grow it to a point where it is self-sustaining.

The main takes of this talk were to be patient and keep trying and learning from past mistakes. Building a community is not easy, and it takes time and effort, but it is very rewarding.


Overall, this trip was worthwhile and I would do it again. I met lots of interesting and motivated people from different backgrounds and had the chance to learn a lot about Go. I would recommend this conference to anybody who is familiar with Go and wants to meet experts in the field.