Speakers

Opening Keynote

Panel with the Go Team

Panel with the Go Team

HTTP Routing Enhancements

Go 1.22 added two enhancements to the routing patterns for http.ServeMux: methods and path wildcards. I'll describe the new features, explain our search for a good rule for deciding which pattern wins in case of a conflict, and talk about how the changes affect performance.

Panel with the Go Team

Accelerate Your Applications with KEDA: A Beginner's Guide to Auto-Scaling and Event-Driven Architecture

In the fast-paced world of modern application development, optimizing resource utilization and responsiveness is crucial. Kubernetes Event-Driven Autoscaling (KEDA) offers a game-changing solution by seamlessly integrating event-driven architecture with Kubernetes. Join us in this informative talk, where we'll guide you through the process of getting started with KEDA. Discover how to harness its power to automatically scale your applications, making them more agile, cost-effective, and responsive. We'll explore the fundamentals of KEDA, its key features, and practical examples of its implementation. Whether you're a seasoned developer or just embarking on your Kubernetes journey, this beginner-friendly session will equip you with the knowledge and tools needed to supercharge your applications. Learn to leverage KEDA's capabilities and embrace the future of event-driven, auto-scaling architecture. Don't miss out on this opportunity to accelerate your applications and stay ahead in the ever-evolving tech landscape.

Building AI Applications in Go

Join us on a journey through the dynamic intersection of Go and AI/LLM technologies. As we unpack the AI/LLM ecosystem, you'll see how Go's robustness and agility make it an ideal tool for the next generation of AI-driven applications. This talk is designed to showcase Go's unique capabilities, from handling high concurrency to ensuring application scalability, proving it's more than equipped to meet the demands of modern AI development.

Leveraging Go for Efficient Infrastructure and Data Handling

Astronomer is a platform that streamlines Apache Airflow's deployment, management, and scaling, a tool for orchestrating complex data workflows. In this talk, we'll delve into why the Astronomer team chose Go for their cloud-native development. We'll highlight Go's simplicity, performance, and scalability as key factors in this decision and discuss how it enhances the platform's functionality.

This session is designed for seasoned Go developers and those interested in its capabilities. We will explore best practices and provide practical insights for improving workflows, particularly those involving data processing with Go.

Technical Documentation - How Can I Write Them Better and Why Should I Care?

Gathering pieces of information for a task to deliver/modify a feature in your Go service, or dev project in any scale - is a wasteful act and could result in duplicated work done by different people. Onboarding, your ability to maintain your Go code or infrastructure and systems handover - Documentation plays a crucial part in all these processes. So... how can we write technical docs in an easy way & why should we even do it? In this talk, I'll show you a structured way to write technical docs, without being a technical writer - So you will deliver highly valuable information to your audience (your fellow gophers, users, or anyone else), to your best ability. I'll explain why you should care about these docs, how do they serve your best interests (Yes, there's more than one!) and what impact it could make on employees or even on your entire organization.

How to Win Frames and Influence Pointers

Go's execution tracer (aka go tool trace) has suffered from high overhead since its inception in 2014. Historically this has forced potential users to worry about up to 20% of CPU overhead when turning it on. Due to this, it's mostly been used in test environments or tricky situations rather than gaining adoption as a continuous profiling signal in production. This talk will explain the contributions we made to the go1.21 release that reduced this overhead to less than 1% for most applications using frame pointer unwinding. It will discuss the technical challenges we faced, the collaboration with the Go runtime team at Google, and how Go users can benefit from this work and improve the performance of their own applications. Last but not least we'll discuss upcoming changes in go execution tracing and frame pointer unwinding in Go 1.22 and beyond.

A Deep Dive Into the DB Connection Pool

The database/sql package is the gateway to interact with a database. But do you know how it works internally? How does the connection pool work? How are the `maxOpenConns` and `maxIdleConns` limits respected?

In this talk, we will unpack all of that and more as we dive deep into the innards of the `database/sql` package. You will leave the room with a much better appreciation of all the things that happen behind the curtain the next time you write `db.Query`.

It will start off with the WHY. I will give a bit of context into the situation that forced me to build a custom connection proxy: https://github.com/mattermost/perseus.

The problem was that our software wasn't written with multi-tenancy in mind. So when we had to share multiple internal instances with the same DB instance, we faced a unique challenge. One can obviously use pgbouncer to share the connections between multiple processes. But then it wasn't possible to share the connection from multiple schema without some signalling mechanism.

So we were faced with 3 choices:

- Either rewrite Mattermost to be multi-tenant

- Modify pgbouncer

- Or build something of our own.

This talk will focus on the learnings that I ran into while taking the 3rd option.

We will then start with a very high level diagram of the flow of how a connection appears to be used from the outside. Then we will go one level deeper and give a brief overview of different components of the whole connection pool - the idle connection slice, the connection request queue, and the connection cleaner among other things. After this, we will explain each component in detail along with a little bit of code as well. We will wrap up the talk with the important takeaways. Eventually, we decided not to run this in production due to an inherent security vulnerability of the architecture, but this whole exercise gave us a much better understanding of the db stats panel used in our monitoring dashboard. And now our SRE team can easily detect and tune the connection pool settings just by looking at the metrics.

Rethinking Domain-Driven Design in Go: From Myths to Reduced Project Complexity

Splitting problems into smaller ones can be a good strategy for tackling complex problems. But sometimes, instead of making project development faster, the opposite happens. Ultimately, developing the simplest feature requires the heroic work of 10 teams on a dozen microservices over half a year. Sounds familiar?

"Divide and rule" is not the only strategy that we can implement in complex projects. One of the most established approaches that can simplify implementing functionalities with complex domain logic is Domain-Driven Design (DDD).

I found DDD very useful in multiple projects with complex domains that I could work on. On the other side, I know that people believe in many myths about DDD used in Go. Most of them are sourced from using DDD in projects that don't require such a sophisticated approach or from projects implemented by people who didn't understand the principles of DDD.

During this talk, I will demystify DDD and give you a real-life example of where empowering DDD helped simplify them and increase development velocity.

If you don't work on a project with complex domain logic now, this presentation may still be helpful for you if you want to work on more challenging projects in the future. I will also give you some hints on which parts of DDD you should start from and what techniques work with DDD well.

Unraveling Go Anti-patterns: Best Practices for Clean and Efficient Code

Embark on a journey to enhance your Go programming prowess by unraveling common anti-patterns that can sneak into your codebase, hindering maintainability and efficiency. In this insightful talk, I will explore real-world scenarios, providing not just a diagnosis of these anti-patterns but, more crucially, prescribing practical solutions to elevate your Go coding practices.

Discover the pitfalls of global state misuse and how to structure state for better maintainability. Dive into the intricacies of error handling, learning how to gracefully manage errors and fortify the resilience of your code. Navigate the challenges of concurrent programming, unveiling the mysteries of race conditions and synchronization techniques to write efficient and robust concurrent code.

Cleanliness is paramount in code readability. Explore the importance of decluttering your codebase by eliminating unused imports and variables, fostering a collaborative and efficient development environment. Optimize your string handling code by steering clear of inefficient concatenation practices, and strike the right balance in using interfaces for code flexibility without unnecessary complexity.

Finally, demystify the nuances of dependency management, avoiding common mistakes that can compromise the stability of your projects. Learn version control best practices and ensure a secure and well-maintained codebase.

By the end of this talk, you'll not only be able to identify these anti-patterns but will also be armed with practical strategies to weave clean, maintainable, and efficient Go code. Join us for an exploration into the heart of Go anti-patterns and emerge a more adept Go developer.

Pack Your Bytes, We're Building: Memory Optimization Through Structure Packing

Overall, the talk is about optimizing code in applications where every byte matters. I will start with a quick introduction to memory layout in Go with a small example in a few slides. This will be to revise how Go structures occupy memory, explaining concepts like padding and hardware sympathy, followed by an explanation of what simple structure layout manipulation can do to improve performance, how Go memory allocator uses different memory blocks (mspans) to store variables of different size. This will be accompanied by a simple real-life analogy to better understand the utility of optimisation for beginners.

Next, we will take a look at a real-life demo (pre-recorded to be safe). In the demo, we will run benchmarks on the code that uses identical structs with different layouts. The demo along with the explanation should take around 5 minutes. After that, we will take a look at the utility and use cases of such code optimisation—when it is needed and when it's best to avoid it. We will take a look at how the compiler can do a similar optimisation for us and why sometimes it doesn't.

This will lead us to the concept of mechanical sympathy, which will be briefly mentioned. And last but not least, we will review a use case from researching this optimisation on the scale of a Go observability library. With this example, we will see a 5–40% improvement in the memory usage of certain "heavy" structures that are created or stored millions of times per minute, and the subsequent performance wins.

From Java to Go: I Have a Hammer and See Nails Everywhere

I want to talk about fallacies you might run into as someone who spent most of his developer career with Java and tries to apply the same train of thought to writing Go. Some of the topics I want to address are: - layers of abstraction and their impact on readability and performance - When ignoring pointers and always copying by value is maybe not the best idea - project structure - lets talk about overusing structs; putting each in its own file vs using the same to improve memory footprint. For each topic, I want to present a comparison of performance metrics.

Using Formal Reasoning to Build Concurrent Go Systems

Go is popular for making concurrency easy through great language support for Goroutines and Channels, but getting it right is still up to you. In order to verify your design is truly correct, you need to look above the code and at the intent, but how does one do that? That’s where TLA+ comes in.

Securing Containers Against Known Go Vulnerabilities

In this talk, we'll discuss the recent results on analyzing publicly available Google Cloud containers for known Go vulnerabilities. We’ll discuss what kind of Go vulnerabilities are prevalent in the containers, how often they present themselves, and how we can guard against them.