Schedule

Social Day: Organized tour in Berlin (Optionally booked in addition)

Tickets will be available for purchase in May, follow the updates

Social Day: Contributors Summit - round table discussions

Topics will be published in early June.
If you have a request for a topic, or would like to apply to lead a topic, email us at team@gophercon.eu

Workshops Day (available with the combined ticket)

Click here to get to book workshops. Alternatively, you can hack with the TinyGo team at the venue throughout the day.

Talks

Social mixer with local musicians

Interviews Day, conducted by the User Experience Researchers of the Go team

Interested in participating? Fill out this form by April 21: this form. We will send out invites on April 24, and all the responses by April 28.

Breakfast

Opening Words

Coffee Break

Lunch Break

Networking

Break 15 minutes

Break 10 minutes

Opening Words

Closing Words

Keynote - State of the Go Nation

Go has come a long way in recent years: From the IDE to package management to changes in the language itself, Go today provides a more productive, coherent experience than ever before. In this talk, we'll review the last several years of advancements in the Go language and the Go toolchain, as well as how the Go team leverages its portfolio of projects to create complete, developer-centric solutions. By digging into examples of what we're working on now, we'll also share a peek of what we're most excited about in the years to come.

Reaching the Unix Philosophy’s Logical Extreme With WebAssembly

Programming has become more and more complicated as more languages and toolchains have been introduced. Sometimes you need to integrate with a library written in another language and this is fraught with peril. In this talk, I will propose a better way of handling these foreign dependencies so that you can focus more on writing your services: compiling that third party library to WebAssembly and then invoking it every time you want to use that feature. I will also cover the performance differences and the toolchain simplicity that such an approach provides. This lets you end up with static binaries like every other Go program so that you can focus more on shipping your code and less on making sure that custom dynamic libraries are installed, memory-safe, and correct. Along the way I’ll explain the UNIX philosophy and how doing this lets you take it to its logical extreme in ways that can permanently transform how you understand composing things together.

Towards Modern Development of Cloud Applications With Service Weaver

Service Weaver is a programming framework that makes it easy to write, deploy, and manage high-performance distributed applications in Go.

Key ideas:

- Development

The developer doesn't have to worry about finding the right boundaries to split the application binary into microservices. They can split the application into as many modules as desired. Service Weaver decides which modules run together in the same microservice and which run in separate microservices.

- Deployment

Deploy it as a single application binary. Service Weaver tooling preserves the impression of a single application binary, while it allows to easily run and test the application locally, before deploying it in the cloud.

- Telemetry

Service Weaver provides libraries for logging, metrics, and tracing that are automatically integrated into the cloud where the application is being deployed.

- Performance

Service Weaver improves application latency by 15x while reducing the cloud bill by 9x based on our benchmarking on some representative applications.

API Optimization Tale: Monitor, Fix and Deploy

I saw a green build on a Friday afternoon. I knew should push it to production before the weekend. My gut told me it was a trap. I had already stayed late to revert a broken deploy. I knew the risk.

In the middle of service extraction from a monolithic platform, we were had to replace a slow REST API with GraphQL and optimize its usage. This let us, notice patterns of a predictable GraphQL consumer.

Deploy on Friday? Testing on production? Big refactoring in a safe way? But why and how? I’ll tell you a tale of incremental changes, monitoring, and good old tricks in a new setting. Hope, despair, and broken production included ;-).

Go Right Ahead! Simple Hacks To Cut Memory Usage by 80%

The backbone of our open source Kubescape project that sees more than 100K invocations daily is written in Go. We found ourselves getting to maximum memory usage often––and had to dig deeper and understand what was happening under the hood in Go that was impacting our memory and performance.

In this talk we’ll share what we discovered - everything from how and when to use pointers in Go (and the impact of heap allocation: spoiler - this is NOT always the best practice), and yes! struct field alignment matters. We’ll then provide a brief overview of tools for performance profiling where and how this matters for your application’s performance. We’ll wrap up with some caveats about surprisingly heavy operations you should be aware of when designing your apps such as JSON decode, regex compilation and much more. If time allows, we’ll also cover a bit on thread management, goroutines, and best practices for working with Go REST APIs. Code examples will be showcased as part of this talk, and hopefully you’ll come away with a better understanding of your Go internals to optimize your app’s memory usage and performance.

Writing a TSDB From Scratch: Performance Optimizations

Time series data generated by monitoring systems is usually measured in millions of samples per second. To keep up with the load, TimeSeries database needs to be as efficient with resources as possible. The talk will review performance optimizations we learned while writing a TSDB from scratch.

How To Avoid Breaking Changes in Your Go Modules

It’s a deeply satisfying moment in the life of an open-source developer if the code they have put out there actually finds some users. But with great popularity comes great responsibility. Now that you have users, you cannot simply change your code at will. Breaking changes will make your users very sad. Semantic versioning comes to the rescue, but much better than a major version bump is to avoid breaking changes in the first place, ideally without slowing down feature development. Go itself and the Go standard library are once more a great role model in this regard. Let’s study a few good practices and also pitfalls, helping you to find the right trade-offs for your library. We’ll start with an informed definition of your public API surface and how to draw the lines between packages, modules, and repositories. We will learn about the marvel that is the interface upgrade – and how it isn’t even needed if you follow a few fundamental design principles.

Go Sync or Go Home: Advanced Concurrency Techniques for Better Go Programs

Go is known for being fast and efficient, enabling developers to write concurrent programs with lightweight threads and easy-to-use API. In order to take advantage of goroutines and synchronize between them, you’ve probably used bits of the sync package. But to get the most out of Go’s concurrency model, knowing the basics isn’t enough. In this talk we will dive into the standard sync package and the x/sync package, getting to know lesser-known features that can be used to improve your code. We will discuss several use cases for each synchronization pattern, and how to take your existing code and make it more robust by using these features.

Panel With the Go Team

Vulnerability Management for Go

A Fast Structured Logging Package

Go Beyond the Console: Developing 2D Games With Go

If you’re like me, you love Go for its simplicity and performance, but have you ever considered using it for game development? In this talk, I’ll explore how to leverage the power of Go to build a 2D game. Right from the basics of game development, including game loops, rendering, physics, and collision detection, and explore how Go can make these tasks simpler and more performant. I’ll also dive into how to use third-party libraries like Ebiten and Pixel to build the game faster. During the talk, I’ll build a simple 2D game in Go, walking through the code and discussing the design choices and cover topics including entity-component-system architectures, tilemaps, and level design. By the end of the talk, attendees will have learned how to leverage Go’s simplicity and performance to build high-quality games and be inspired to explore the world of game development with Go.

Gentle Introduction To eBPF

eBPF (Extended Berkeley Packet Filter) is the hottest technology now a day and it makes talking to the Linux kernel far easier without actually changing the kernel itself. Now it is possible to make additional changes to the kernel related to security, networking, and observability.

As an eBPF program is loaded into the kernel, a verifier ensures that it is safe to run, and rejects it if not. Once loaded, an eBPF the program needs to be attached to an event so that whenever the event happens, the program is triggered.

eBPF allows us to collect customized information about how an app is behaving without having to change the app in any way, by observing it from within the kernel. We can build on this observability to create eBPF security tools that detect or even prevent malicious activity within the kernel. And we can develop powerful, high-performance networking capabilities with eBPF, handling network packets within the kernel and avoiding costly transitions to and from user space.

eBPF programming is incredibly powerful, but it’s also complex. For most of us, the utility of eBPF is going to come not from writing programs ourselves but from using tools created by others. There are an increasing number of projects and vendors building on the eBPF platform to create a new generation of tooling, covering observability, security, networking, and more.

The Road To Cgo-less Is Paved

We love pure-Go programs, don’t we? Set `CGO_ENABLED` to `0`, and Bob’s your uncle. The resulting binary is self-contained, portable, and may be known as: static. It depends on nothing but itself. We love the smell of `not a dynamic executable` from `ldd` in the morning! We can confidently cross-compile the program on one OS and ship the executable to another OS. The program shall also behave the same on every platform. Or does it?

Useful Functional-Options Tricks For Better Libraries

Functional options is a creational pattern that remains divisive in the Go community: loved by some, loathed by others. However, the pattern can tremendously improve a library’s API design. Throw in a few twists and unleash the full power of functional options on your Go libraries!

Why Integration Tests Might Be Better Than Unit Tests

Go developers are widely encouraged to write unit tests to independently verify individual components within an application. This ensures that the application logic is correct and issues can be resolved early on.

However, in our case, we encountered a challenge where our unit tests were not reliable in detecting issues, leading to a false hope that the application was working correctly.

In this talk, we will share how we addressed this issue by shifting our focus towards integration tests. We will discuss the types of tests we chose to write and why.

Lightning Talks

GoTime Podcast Live

Workshop: Ultimate Go: Service With Kubernetes

Find all the details at the workshop page: Ultimate service with Kubernetes

Workshop: Getting Started With gRPC & Security

Find all the details at the workshop page: /workshops

Workshop: Object Oriented Design With Go

Find all the details at the workshop page: /workshops

Workshop: Building Modern CLI Applications In Go

Find all the details at the workshop page: /workshops