GopherCon Talks

This repo contains slides and other presentation materials from GopherCon talks over the years, submitted by the speakers themselves. Each year is organized into two sections, one for main theater talks and a second for lightning talks. The content is organized based on the agenda from that year.

If materials are available for a talk, the title will be a link to a sub-folder in this repo. See CONTRIBUTING.md if you are a speaker and would like your content included.

<hr/>

2025

Main Theater

Go's Next Frontier - Cameron Balahan

Go is more than just a programming language—it's an industry pioneer. From its revolutionary concurrency model to its leadership in open-source security, Go's enduring focus on modern software engineering compels us to not just keep pace with industry advancements but to actively define and lead them.

In this keynote, we’ll explore Go's legacy of leadership and how its core design principles make it well-positioned to lead us into the next frontier: the convergence of AI and programming languages. By examining what the Go team is working on now, we’ll also share a vision of Go’s future developer experience and what we’re most excited about in the AI era.

LLM Agents in Production: Why Go is the Missing Piece - Kartik Ramesh

You might have heard of this thing called AI agents that have been transforming our industry lately. While there exist a plethora of ways to prototype agents, operating these in production brings a new set of challenges. This talk demonstrates why Go is uniquely suited for building scalable, production-ready agent systems. We'll build an LLM agent from scratch without using any agent frameworks, scale our system out to a multi-agent architecture, and leverage Go's cloud-native ecosystem to operate agents at scale.

Goroutines and Cells: Lessons in Goal-Directed Systems - Carlisia Campos

This talk explores a new way to approach concurrency in Go by drawing inspiration from bioelectric signaling in cells. It contrasts how biological systems achieve scalable, decentralized coordination with traditional concurrency patterns such as worker pools and fixed-rate limiters, which often struggle to adapt to dynamic workloads.

Biological systems use graded communication, rhythmic synchronization, and localized interactions to coordinate without centralized control. By applying these principles to Go concurrency, developers can design adaptive, nature-inspired systems that improve efficiency, fault tolerance, and self-organization.

Through conceptual models and real-world analogies, this talk will illustrate:

How graded signaling enables dynamic resource allocation, reducing bottlenecks in goroutine coordination
How rhythmic synchronization helps orchestrate periodic tasks more efficiently than independent timers
How decentralized interactions lead to emergent consensus without centralized control

Attendees will leave with new mental models for designing concurrent systems, gaining insights into how nature-inspired approaches can make Go applications more resilient and scalable.

Go: A "Tailor-Made" Language for AWS Lambda - Travis Bale

At Capital One, we're building scalable, high-performance services with Go and AWS Lambda.

This talk will walk through why Go feels like it was designed specifically to work well with AWS Lambda. Attendees will learn about AWS Lambda concepts such as runtimes, cold starts, and extensions, and how Go as a language pairs exceptionally well with them.

The Code You Reviewed is Not the Code You Built - Jess McClintock

Ken Thompson's "Reflections on trusting trust" highlights the potential disparity between source code and the final built product, cautioning developers to question their trust model right down to the compiler itself. This principle is crucial when dealing with intricate trust models, as code reviews alone can not provide sufficient assurance in the behaviors of the build artifact.

Earlier this year, a malicious typosquat of the boltdb package was identified on the Go module proxy. There were several things of note about this typosquat, most prominent being the way that the attackers modified the git tags to obfuscate the malicious behavior. Even a security-minded developer who reviewed the code present on GitHub could have been tricked into using this package. In a sense, there were two levels of deception used to ship this code - the typosquat itself and the decoy code present on GitHub. This attack exposes the real-world practicality of deceiving traditional source reviews, threatening the foundation of open source consumption.

My Protobuf Module is Faster than Yours (Because I Cheated) - Tom Lyons

When handling over 2 trillion messages every day, every ounce of performance matters. This talk outlines the (over) optimizations that went into making our Go protobuf module as efficient as possible.

Building a Decentralized Social Media App with Go and ATProto - Gautam Dey

Bluesky is an exciting new decentralized social media platform, powered by the ATProtocol (ATProto). What makes ATProto so revolutionary, and how can Go developers leverage it to build scalable social apps?

In this talk, we’ll explore ATProto's core components and their interactions. Then, we’ll put theory into practice by building an AppView—a key part of the ecosystem—using Go. Our project will be a photo-sharing app with likes and comments, demonstrating how Go developers can contribute to the growing ATProto ecosystem.

By the end, you'll have a strong foundation in ATProto and a roadmap for building your own decentralized social applications.

Analysis and Transformation Tools for Go Codebase Modernization - Alan Donovan

In this talk, Alan will report recent progress in analysis and refactoring tools for Go. The talk will cover:

The principles of the Go analysis framework, which powers batch tools like cmd/vet and interactive tools like gopls, and enables problems to be precisely reported and fixed in real time;
a discussion of recent tools to "modernize" your codebase so that it uses the most efficient, clear, and idiomatic features of the newest Go releases; and a demonstration of how our algorithm for precise inlining of function calls is at the heart of a powerful tool for codebase migration.

Plowing Through Data: Building Flexible Pipelines with Go - Mindy Ratcliff

In modern agriculture, data flows in from everywhere—fields, labs, applications—and needs to be processed, transformed, and delivered to a wide range of destinations. Using Go’s parametric polymorphism, we have been able to build quickly with scalability and maintainability.

This talk will cover practical insights into building flexible pipelines with Go—and maybe even inspire you to plow through your own data challenges with a bit more ease.

Understanding Escape Analysis - Bill Kennedy

???

Scaling LLMs with Go: Production Patterns for Handling Millions of AI Requests - John Wang

At Assembled, we serve tens of millions of LLM requests, powering customer support AI for companies like Canva, Etsy, and Patreon. While most teams build LLM infrastructure in Python, we found Go's type system, concurrency features, and interfaces solve many production challenges more elegantly.

This talk shares concrete patterns from our experience deploying Go-based LLM systems at scale: from handling structured outputs to parallel RAG pipelines. You'll learn practical approaches for building performant, reliable AI applications leveraging Go's strengths.

Porting the TypeScript Compiler to Go for a 10x Speedup - Jake Bailey

From the beginning, the TypeScript compiler has been self-hosted, evolving alongside a growing ecosystem of millions of developers. As time went on, we faced challenges with the compiler's performance, largely inherent to the implementation language itself. Through experimentation and testing, we found Go to be an excellent language for our specific needs; a perfect porting language. In this talk, we will explore the process of porting the 150,000+ line TypeScript compiler and its 90,000+ tests to Go, the challenges we faced, lessons we learned, all leading to an overall 10x performance improvement over our previous implementation.

From Chaos to Cohesion: A Community of Practice Story - Moieed Ahmed and Seth Lumnah

An exploration of the challenges of managing languages in a large enterprise and the role that communities of practice play in providing standardization from a diverse set of opinions.

An Operating System in Go - Patricio Whittingslow

We’ll answer the age-old question — “Is Go a systems programming language?” — by showcasing TinyGo’s rise as the unexpected contender in embedded systems, upending assumptions about a space long thought settled.

Go’s Trace Tooling and Concurrency - William Kennedy

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

Throughout this talk, we will cover:

Go’s trace tooling
Goroutines and Concurrency semantics
Performance exploration

Talks

Install / Use

README