October 5th, 2025
Lungarno del Tempio, 44,
50121 - Firenze (FI)
Italy
Registration
Register your ticket
Ultimate Software Design and Engineering
This class teaches you how to engineer production-level software in Go leveraging the power of a domain-driven, data-oriented architecture that can run in Kubernetes. From the beginning, you will pair-program and read code with the instructor as he walks through the design philosophies and guidelines for engineering software in Go.
LEVEL: Intermediate
This is a whole day workshop.
According to the speaker, there will be pauses at 11:00 and 16:00 for coffee breaks and at 13:00 for lunch.
Welcome coffee
Lunch
Coffee break
October 6th, 2025
Lungarno del Tempio, 44,
50121 - Firenze (FI)
Italy
Registration
Register your ticket
Conference presentation
Conference presentation by Gregory Eve
Welcome coffee
Writing Better Go: Lessons from 10 Code Reviews
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
Unchaining Charm: Making Developer Tools Speak Every Language
As developer tooling becomes more essential across ecosystems, popular libraries like Charm.sh’s Bubble Tea and Lip Gloss are seeing demand beyond their original Go roots. This talk explores the process of porting these libraries to multiple programming languages, highlighting the technical challenges, design decisions, and strategies for preserving their unique developer experience. Attendees will gain insights into building cross-language libraries, handling platform-specific constraints, and creating tooling that feels native—no matter the language. LEVEL: Intermediate |
Tug-of-Code: The battle for efficient iteration in Go
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
What I learnt building a web app with Go and HTMX
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
Lunch Leonardo
Building a Plugin System with WebAssembly
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
Lunch Michelangelo
Deep dive into the select statement
The select statement is a cornerstone of Go's concurrency model, enabling developers to coordinate multiple channel operations with precision. This talk provides a deep technical exploration of its implementation across Go's compiler and runtime layers. We examine how the compiler transforms high-level select syntax into executable code through IR manipulation, including special-case handling for zero, single, and multi-case scenarios. The runtime implementation reveals a sophisticated selection algorithm featuring randomized polling order, channel locking, and goroutine scheduling mechanics. Come to my talk and gain some insight into how select works under the hood. LEVEL: Advanced |
Colors, images and gifs: bring on the fun with Go!
Let's walk through how we can put some color to our programming with Go. LEVEL: Introductory and Overview |
Bypassing the Linux net stack with Go
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
Become a 10x Developer with Go Performance Optimization
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
Coffee break
Social Event: GoLab's 10th Anniversary
October 7th, 2025
Lungarno del Tempio, 44,
50121 - Firenze (FI)
Italy
Registration
Register your ticket
Becoming a Game Developer 25 Years Too Late
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
Beyond sqlc: teaching AI to generate repositories and integration tests in Go
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
Welcome coffee
Safe Arbitrary Code Execution is the Future of Config
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
Push vs. Pull in Go: Webhooks, Pub/Sub, and Making the Right Choice
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
Leverage Google gVisor for a userspace network stack in pure Go
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
Smarter Locks: Diving into Go 1.24’s Mutex Spin Optimisation
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
Lunch Leonardo
Weak References in Go 1.24: Memory Management Superpowers
Go 1.24's new weak package brings powerful memory management capabilities to Go developers. This session takes you on a deep dive into weak references - a feature that allows you to reference objects without preventing garbage collection. |
Lunch Michelangelo
SIMD Support via Go Assembly
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
Beyond Basics: Modern Go Patterns for Large-Scale Applications
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
Goetics: On Go as a Tool for Creative Expression
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
Post-Quantum Cryptography in Go: The Arrival of the `crypto/mlkem` Package
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
Coffee break
Go’s Trace Tooling and Concurrency
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
Goodbye, Gophers!
Farewell to Gophers by Gregory Eve and some anticipations about new edition