Schedule

TBA

TBA

TBA

TBA

TBA

Why do Go developers obsess over variable names, error handling, and interfaces, even when your approach does the job, too? Whether gently or not so gently, they'll remind you there's a right way to write Go.

In this talk, I'll walk through frequent code review comments to show what looks like nitpicking is a window into Go's design philosophy. These aren't arbitrary style debates; they're about writing clear, deliberate, and unapologetically pragmatic Go. You'll leave with a better understanding of the "why" behind the rules and how embracing them can sharpen your code.

LEVEL: Introductory and Overview

Iterators are a powerful tool for traversing custom data structures, enabling clean, reusable, and efficient code. In this talk, we’ll explore how iterators work in Go, from the familiar `for-range` loop to advanced patterns like pull-based iterators and mutation during iteration.

LEVEL: Intermediate

As a backend engineer, I always found myself struggling to build a full-stack web application on my own. I seemed to always get lost, in the JavaScript ecosystem. Or even simple things like how to structure a more complicated application.

So when I learnt about HTMX, I decided to give it a go (no pun intended ;) ). So I tried to build a Web app without needing to write any (or very little JavaScript) and see how far I could get.

In the end, I had a joyful developer experience building an app with Go, HTMX, templ, tailwindcss and Postgres, KISS - keep it simple stupid.

LEVEL: Introductory and Overview

Go's native plugin system has existed since 1.8, but it's restrictive and rarely used in real-world projects. While alternatives like HashiCorp's go-plugin offer more flexibility, they come with the overhead of managing separate processes. In this talk, I'll show how we built a lightweight plugin system using WebAssembly (Wasm). We'll explore the architecture, trade-offs, and restrictions of using Wasm for high-performance plugins.

LEVEL: Intermediate

TBA

TBA

Using XDP and eBPF, we can directly read and write the Ethernet frames from the network card and parse them ourselves, gaining complete control over the data and significantly improving performance, basically bypassing all the Linux network layers.
And all this can be done directly from a normal Go application run by the user... How beautiful is it?

LEVEL: Advanced

Performance optimization is a skill that everyone wants on their resume today. It's an essential arrow in your quiver if you want to stand out from the average developer.

The goal is to make your software faster or use fewer resources.

Even if you don't care about it now, there may come a time when your software starts running slow, consuming too many resources, or getting killed by the dreaded OOM issue. Not knowing where to begin investigating, how to read the metrics, or how to fix the code could keep you awake at night. And usually, when performance optimization is needed, the situation is far from ideal. At that point, we either save the boat or sink it.

LEVEL: Intermediate

TBA

TBA

Have you ever thought about creating a game in Go? How about creating it for a classic console like a PlayStation 2, with its 160 million units sold worldwide? Well, think no more, because now you can do it! Join me on the journey of understanding this great console and adding support for it on TinyGo, a Go compiler for embedded systems.

LEVEL: Intermediate

Using sqlc in Go is great for generating type-safe database access — but using its generated models / records directly in your service layer ties your domain to the database structure. To keep things flexible, a repository layer is still needed to handle mapping and transactions — but writing that by hand gets repetitive fast.

LEVEL: Intermediate

Configuration is an interface between the system and its user. Complex systems can require complex configuration, causing the user to reach for programmatic concepts to make their config files more manageable. All too often, these programmatic concepts are applied in an unplanned way, leading to awkward, accidental Turing completeness and hacky-feeling formats. In this talk, we explore providing config as code, preserving elegance, maintaining safety and giving users superpowers.

LEVEL: Advanced

Event-driven systems are everywhere, but choosing the right approach can be tricky. Should you use simple webhooks, a message queue like Kafka, or something Go-native like Watermill? This talk explores the trade-offs between webhooks and pub/sub systems, focusing on scalability, reliability, and maintainability in Go applications. We'll walk through real-world scenarios—such as SaaS integrations, real-time notifications, and high-throughput data pipelines—and provide clear decision-making guidelines. Whether you're building a small Go service or architecting a large event-driven system, you'll leave with a solid framework for making the right choice.

LEVEL: Intermediate

I am the lead maintainer of go-ios a OSS project to work with iOS devices that heavily relies on networking code. For this and other projects I built and maintain WebSocket, WebRTC and other networking production services. Recently, the need arose to run a full blown network stack as part of the project entirely in user space.
Google gVisor implements its own network stack called netstack. All aspects of the network stack are handled inside the Sentry — including TCP connection state, control messages, and packet assembly — keeping it isolated from the host network stack. While the primary use case is sandboxing containers, you can use netstack to run your own userspace wireguard network interfaces without installing interfaces, drivers or system user privileges.
Learn how companies like fly.io or tailscale build VPNs that do not require `sudo` by creatively
using Google's powerful gVisor netstack.

LEVEL: Intermediate

Ever wondered what happens when too many goroutines fight over the same lock? In Go 1.24, sync.Mutex got a clever upgrade: smarter spinning!
In this talk, we’ll peek under the hood of the Go runtime to see how the new spin loop works, why it’s faster, and how it helps your services scale more smoothly. Expect runtime internals, benchmarks, and a few lock-heavy demos where the new behaviour shines!

LEVEL: Advanced

TBA

TBA

While Go's compiler is efficient, there are still some rare but critical cases where performance matters enough to trade Go’s safety for the raw power of assembly. Some areas that call for this level of control include cryptography, systems programming, and, of course, performance optimization. In this talk, we’ll start with an introduction to Go assembly and SIMD, and then dive into writing assembly code using SIMD instructions, where we’ll walk through a practical example. Finally, we’ll benchmark our SIMD implementation against its non-SIMD counterpart to see just how much performance is on the table and when it’s worth reaching for.

LEVEL: Advanced

Scaling Go applications isn't just about speed—it's about structure, clarity, and thoughtful design. In this talk, we'll explore modern Go patterns that power robust, high-performing systems.

LEVEL: Intermediate

Is programming itself a creative act? Or is a programming language a medium like a tube of paint, existing only to bring a creative object into being? Both notions are accurate, but they are often in tension. This talk explores that tension and Go's place in it via the various Go projects created by the speaker over the years ranging from colorful CLI applications like the GitHub CLI to tooling for experimental poetry.

LEVEL: Introductory and Overview

As quantum computing advances, classical encryption will become increasingly vulnerable. With the arrival of the finalised NIST standard last year, Go 1.24 now includes the crypto/mlkem package, providing post-quantum encryption features.

LEVEL: Advanced

In this talk, Bill will share how to use Go’s trace tooling to examine a Go programs performance. Along the way, Bill will live code a Go program, adding different levels of concurrency to see how the performance changes.

We will cover:  
• Go’s trace tooling.  
• Goroutines and Concurrency semantics.  
• Performance exploration.

LEVEL: Advanced