Schedule

A Go server is running. Everything looks fine. Then something breaks.

Latency jumps. CPU climbs. Memory starts behaving in ways you didn’t expect. And now you need answers fast.

In this workshop, we take a real Go application behind Caddy and turn it into something you can actually understand in production.

LEVEL: Introductory and Overview

In recent years new laws in the UK and EU have imposed an obligation on internet services to protect the privacy of their users, and to restrict access to adult content based on age. Legislators have mandated outcomes, but they haven't provided a roadmap for developers to get there. So where does someone without a background in cryptography and data security turn for insight?

I've been a researcher in the field of Digital Identity for more than twenty years now, and in secure communications of one form or another for over thirty. There are plenty of commentators who'll share their opinions with you, I share code.

LEVEL: Intermediate

This is a hands-on, full-day workshop where you'll build a complete AI-powered application in Go — from first prompt to production-ready system.

You'll start by connecting your Go application to a language model and grounding its responses in real data using Retrieval-Augmented Generation (RAG).
Then you'll give it the ability to act on the world through Tool Calling, Function Execution, and the Model Context Protocol (MCP).
With the core system working, you'll learn the advanced optimization techniques that separate prototypes from production - speculative decoding, semantic caching, and intelligent model routing.
Finally, you'll harden everything against the security threats unique to LLM-powered systems, from prompt injection to data exfiltration.

Each part builds on the last.

By the end of the day, you won't just understand these concepts - you'll have built, optimized, and secured a working system that retrieves, reasons, and acts.

LEVEL: Intermediate

Running inference against LLM models that run on your own local hardware means no API costs, no data leaving your machine, and no vendor lock-in. Having the ability to do this with Go has traditionally been painful.

In this workshop, Bill will introduce Kronk, a Go SDK that lets you embed local model inference directly into your Go applications with full GPU acceleration — no CGO required. Whether you are building chat, vision, audio, embedding, or tool calling applications, Kronk gives you the same power as a model server without needing one.
To prove it, Bill built a model server using the Kronk SDK, complete with caching, batch processing, and agent support. You'll see live demos from writing your first chat app to driving a coding agent with a local model.

LEVEL: Advanced

GoProxy is an open source library to create a customized HTTP/HTTPS proxy server using Go.
The proxy itself is simply a net/http handler, so you can add multiple middlewares, and It can be easily integrated with any existing Go code (e.g. you can even call external APIs).
Are you ready to write your custom proxy server?

LEVEL: Intermediate

Go is designed to be simple, but the runtime is complex. To write truly high-performance code, you need Mechanical Sympathy—an understanding of how your code actually hits the metal.

This hands-on workshop pulls back the curtain on the Go compiler and runtime. We will move beyond "tips and tricks" to explore the underlying mechanics of Memory Allocations, Stack vs. Heap, and Goroutine Scheduling.

LEVEL: Advanced

TBA

5 years after the first working proposal, what changed in the ecosystem? What can be achieved with modern Go?

From iterators, to type-safe testing, to a pure-Go RPC library with no code generation, this session will delve into all things achievable in Go thanks to its generics implementation.

LEVEL: Advanced

What would happen if your Go program could "see" every network packet, every file opening, and every Linux system call in real time, without altering a single line of kernel code? Welcome to the world of eBPF. In this talk, we'll demystify how Go can be used to orchestrate this revolutionary technology, enabling the creation of ultra-low latency security and monitoring tools.

LEVEL: Introductory and Overview

In this talk, we introduce a Go framework implementing the Taguchi method, enabling structured experimentation in systems engineering workflows. The framework uses orthogonal arrays to efficiently sample parameter spaces, reducing the number of experiments while preserving the ability to extract meaningful structure from results.

Through a concrete example: tuning a parallel workload by varying goroutine count, workload characteristics, and execution configuration - we explore how parameter interactions surface in practice, including trade-offs between concurrency, scheduling, and infrastructure such as multi-core scaling versus isolated-core execution.

LEVEL: Intermediate

TBA

Green Tea's insight is elegant: scan spans, not objects. But how do you actually implement that? What data structures track which objects are marked vs. scanned? Why does the ownership protocol use three states? And how did span-based scanning unlock SIMD optimizations that were impossible before?

LEVEL: Advanced

In this talk, we'll explore why Go has become our platform of choice for developer tooling. We'll start with the fundamentals: what language servers are, what problems they solve, and the core data structures that power them. From there, we'll examine where tooling based on other software stacks have fallen short as codebases scale: limited shared-memory parallelization, unpredictable JIT performance, and mounting memory pressure.

We'll then show how Go addresses each of these challenges: Through goroutines and channels for safe parallel execution, a type system that maps naturally onto AST structures, and binary compilation that delivers raw, predictable performance across platforms - even on the web via WASM. Finally, we'll introduce an open source framework we've built to encapsulate these capabilities and make high-performance tooling more accessible.

LEVEL: Intermediate

Continuous Integration has become a standard practice in modern development, and Go provides a rich set of tools to support it: go vet, unit tests, benchmarks, and fuzz testing. Building a CI pipeline that maintains a baseline of quality is straightforward.
But how do we know we're writing good tests? A test that calls a function and discards the result still contributes to coverage. You can hit 100% coverage with zero assertions.

LEVEL: Intermediate

TBA

Zero-touch observability for Go is finally becoming real. In this talk, we’ll walk through the different strategies you can use to instrument Go applications without changing a single line of code, and what they cost you in terms of overhead, stability, and security.

LEVEL: Intermediate

TBA

With the compression changes introduced in Go 1.27 get to know all the details on when and how to select the best compression options for your Go application.

We will look at the overall picture of different algorithms and how each trades off size, cpu, memory and compatibility so you can make the best decision on which suits the needs you may be looking at.

LEVEL: Intermediate

You can write firmware in vanilla Go.

TamaGo is a Go distribution capable of producing bare-metal binaries, while retaining compatibility with existing libraries and most tooling.

I wrote a completely self-contained FIDO2 USB token implementation (think Yubikey) running off a USB Armory Mk. II without a single line of C.

LEVEL: Intermediate

TBA

In this talk, I’ll show how Go’s tooling, profiling, and fast iteration helped me build a WebAssembly VM from scratch, then push it far enough to run Doom, covering the internals like parsing, execution, memory, debugging, and performance tuning.

LEVEL: Intermediate

Your users are leaving before you know they had problems. A slow signup flow, a failing payment endpoint, or a broken onboarding step. By the time you hear about it from support tickets, you've already lost trust and revenue.

Most Go applications start with great intentions: fast iteration, clean code, and rapid shipping. But without the right observability foundations from day one, teams end up flying blind. Metrics live in one place, logs in another, and there's no way to connect a spike in error rates to actual user impact.
In this talk, I'll share hard-won lessons from building production systems at scale and show you how to instrument Go applications with user journeys at the center. You'll learn how to build a minimal, effective observability stack using OpenTelemetry, connect technical signals to business outcomes, and establish SLOs that Product and Engineering can co-own.
This is not a talk about adding more dashboards. This is about shipping fast with confidence.

LEVEL: Intermediate

PostgreSQL is probably the most loved database to work with Go, for good reasons!
As someone helping to scale many terabytes-large postgres environments, some seemingly innocent choices like using session variables or savepoints end up being silent bottlenecks limiting the database possibilities.

In this talk we will discuss less common tips on how to keep your postgres running happy with your go application.
The goal is to guide you on how to stay flexible and prevent you from getting stuck in a position that would prevent you from scaling postgres in the future.

LEVEL: Intermediate

Your dashboard says everything is fine. Average latency: 100ms. QPS: stable. Error rate: 0.1%. But users are complaining the app is slow - and they're right.
In this talk, we'll investigate three real production bottlenecks in Go services: a memory issue that caused an OOM kill by Thursday, a goroutine leak invisible to standard metrics, and the deceptive nature of average latency. 

LEVEL: Introductory and Overview

SQL-compiler or sqlc generates type-safe Go code from SQL migrations and queries. Most developers use it as a black box, but understanding how it works matters because great engineers don’t just use tools — they understand them, question them, and get better by knowing what’s happening under the hood.

We are going trace the compilation pipeline inside sqlc: how it delegates parsing to PostgreSQL’s own parser via pg_query_go, builds an in-memory schema catalog, performs query analysis and type inference across joins, CTEs, and subqueries, and finally generates Go code for PostgreSQL and pgx driver.

LEVEL: Intermediate

The `log/slog` package has been part of the standard library since v1.21 (Aug 2023). Yet, many Go projects are still scratching the surface of its potential. Are you truly making use of all its features?

This talk moves beyond the basics of `Logger` and `Handler` to explore how `slog` transforms logging from a tedious chore into a powerful, maintainable, and testable system. We’ll quickly review `slog`'s robust stack, then dive deep into practical, production-ready patterns.

LEVEL: Intermediate

TBA

Received a Go binary with no source?

Learn to audit Go binaries without source via eBPF tracing and static analysis. We will cover a practical workflow to spot unexpected HTTP, filesystem, or network activity and explain how Go's binary structure aids analysis. We will briefly use Ghidra to visualize internal structures without deep reverse engineering skills.

LEVEL: Introductory and Overview

Go on the backend? Check
Go on the web frontend? Check*
Go on the desktop GUI frontend? Check
Go on the mobile frontend? Without web and webviews? Check

Follow me on my crazy adventure of putting Go at every level of my stack because I'm a monomaniac gopher.

* with WASM

LEVEL: Intermediate

My dashcam records road trips as hundreds of 1 minute MP4 clips. A recent 9 hour road trip across Western Canada produced 540 tiny files and inspired me to create a timelapse video. That’s far too many clips for any video editor to handle so I built a tool in Go to turn them into timelapses automatically.

This started as a simple ffmpeg wrapper but after some nerding away it turned into a real world coding problem: I needed to validate all 540 video files, detect trip boundaries from the metadata, and orchestrate a multi-stage processing pipeline, ideally without taking a full 30 minutes to run.

LEVEL: Intermediate

## Setting the scene - 3min

## Technologies and Architecture - 5min

## Implementation of the basics - 8min

## Integrations - 6min

## App suite for our desktop - 5min

## Try it out and contribute - 3min

LEVEL: Intermediate