Schedule

Outline
1. Introduction to Threat Modeling
2. Why and When to Use Threat Modeling
3. Threat Modeling in Agile Environments
4. Who Can Perform Threat Modeling?
5. Writing Effective Threats (+ Hands-on Exercise)
6. Requirements for Effective Threat Modeling
7. Deep Dive: STRIDE Threat Modeling (+ Hands-on Exercise)
8. Deep Dive: PASTA Threat Modeling (+ Hands-on Exercise)
9. Applying Threat Modeling in a Practical, Low-Key Manner
10. Threat Modeling as Code
11. Q&A and Closing Remarks

LEVEL: Introductory and Overview

The Go source code is a very interesting piece of software that we use every day, but most Go developers overlook it. In this workshop, we will introduce you to the main concepts in the Go source code with a hands-on workshop where we will have fun modifying the Go compiler and runtime.

Join me for this workshop if you want to learn more about the Go compiler and runtime code and have some fun while we explore it.

LEVEL: Advanced

Building modern applications requires systems that can retrieve, process, and act on information intelligently. This workshop introduces Retrieval-Augmented Generation (RAG) to improve responses in Go applications by fetching relevant data dynamically.

It then expands into Tool Calling (Function Calling), allowing AI-powered applications to execute predefined actions, interact with external systems, and automate workflows.

By the end of this hands-on, full-day workshop, you’ll have a working knowledge of how to ingest and retrieve documents, integrate with APIs, and use function calling to control external
systems—all within Go and the AI system of your choosing.

LEVEL: Intermediate

This is a whole day long workshop.
According to the speaker, there will be pauses at 11:00 and 16:00 for coffee breaks and at 13:00 for lunch.

Ollama is a popular tool to run large language models on your own machine or infrastructure. Since its first release (and support for two models) in Summer 2023 it went on to become a widely used tool supporting various state of the art open weights models. With a standardized API, it can serve as a testing ground for applications or alternative to other LLM service providers.

In this workshop we follow the question of what happens when you type a prompt into ollama in detail. We look at the different layers, preprocessing stages, customization and integration options, llama.cpp wrapping and text and structured output generation and will illustrate parts of the architecture with various code examples.

LEVEL: Intermediate

Are you writing Go programs that run on Linux or MacOS? Then you're writing Go programs for a UNIX environment! But how much does that figure in your daily experience?

This talk provides an introduction to programming for the UNIX environment using Go. It will focus on code examples and build from a simple beginning to more advanced use cases, providing a springboard for further exploration.

LEVEL: Intermediate

Kubernetes native applications embrace the declarative approach of the platform: observe a desired state, and reconcile the state of the system using that desired state.
A Kubernetes controller is a program which encapsulates this behavior in a non-terminating loop.
This hands-on workshop will introduce the few concepts required to build and deploy a controller on their laptop, and then will help the attendees to write their first controller exposing a custom API. This workshop will explore the best practices to implement a solid controller, and the most common options for frameworks and testing methods.

LEVEL: Intermediate

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

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

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

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

Let's walk through how we can put some color to our programming with Go.

We will explore how to work with colors to create palettes and images, we will see how to fill pixels in a rectangle and make a matrix of numbers become a forest or a map, we will see how to layer images and texts on top of each other to make some colorful banners and add a pinch of creativity to animate them into playful gifs.

LEVEL: Introductory and Overview

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

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.
What you'll learn:
- Understanding weak pointers and how they differ from regular references
- Practical implementation patterns for caches, canonicalization maps, and circular reference handling
- Performance implications and memory optimization techniques
- Common pitfalls and best practices
- The journey of weak references in Go: years of community discussion and design evolution

LEVEL: Intermediate

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