A tour of xbar code.
Mat Ryer takes you through the xbar project monorepo explaining key technical decisions and why they were made. All the way from the front end code that delivers the native app UI, through the service layers and native API integration, down to the xbar data APIs that power the app, and the website. Mat will explain how the focus on pragmatism and minimalism allowed him to deliver the new project within a couple of months.

Building an Autoscaling HTTP Proxy for Kubernetes.
You probably already know generally how HTTP proxies work. You might have even built one! Out of the box, Go comes with a ReverseProxy type in the standard library, but a production deployment -- especially in Kubernetes or similar distributed systems -- needs to do more than the standard library. Some additional requirements include autoscaling systems, connection backoffs, request rewriting, and more.
We ran into these requirements in building the open source KEDA HTTP Addon project. In this talk, I'll briefly review the requirements of such a proxy and we'll proceed to live code a comparable one from scratch.
You'll walk away with a deeper understanding of the net, net/http and net/http/httputil packages as well as several relevant concurrency patterns you can use to build your own proxies - and other robust and performant networking systems in Go.

Go Profiling from Bottom Up.
The Go language ships with many fantastic profiling tools. There is CPU, Heap, Mutex, Block and Goroutine profiling. It also includes the wonderful pprof visualization tool for inspecting the data.
However, using these tools on real world applications can be a challenge because there is a lot of data, yet very little information on what any of it actually means. So you might find yourself wondering, oh, this is weird! How is the data collected? Why is my profile showing more time than my application was running for? What's the accuracy of the data? Is there any bias in the data? What known issues might impact the results in my particular environment? How much performance overhead should I expect? Are there any other side effects that could harm my application?
If you ever found yourself asking these kinds of questions while profiling, this talk is for you. Instead of introducing Go's profiling tools as magic black boxes to inspect your application, we'll look behind the curtain of the Go internals, OS and Hardware level to gain a deep understanding from the bottom up.

Learning Unsung Gotchas of Go.
GO is one of the simplistic, neat, and effective languages, but it has few gotchas. These gotchas run the gamut from minor syntactic annoyances to psychological behavior. By sharing the invaluable references - this talk will cover them, which will conserve Go programmer's time and wasted effort. From beginner to expert level, everyone is warmly welcomed as the examples shared will cover a breadth of opportunities to learn.

Testing in Go with Ginkgo and Gomega.
In this talk we will explore testing options in Go beyond the `testing` package.
We will go over the most useful features of Ginkgo BDD testing framework and Gomega, the accompanying matcher library.
If you feel that your tests could be more expressive, better structured and less repetitive, this talk is for you.

Transparent one-to-many gRPC proxy. (in Russian)
Sometimes there is a task of proxying gRPC requests with changing requests on the fly: this can be a shared authorization layer, ensuring compatibility of API versions, load balancing, or a high-availability scenario. Since the gRPC protocol uses protobuf and strong typing, you can code a proxy, implementing each API method manually or using code generation, but this is inconvenient. In this talk, I'll show you how to make a transparent proxy for requests with their changes on the fly, in a case where the proxy server does not know the structure of each request and response. In particular, we will consider the case of sending a single incoming request to several backend nodes with the assembly of all received responses into a single response for the client.

A second before calling main (). (in Russian)
I offer you to discover what happens in the Go runtime before our code starts executing in main (). Let's analyze what is being created and checked there, and why these things are working like this. The talk will be useful for both beginners and experienced developers. Only a few people have wondered what happens there in this couple of milliseconds.

Embed package: unpacking knowledge. (in Russian)
In this talk, we will look at the novelty in Go 1.16: the new embed package. Let's compare its implementation with existing solutions for static packaging using examples and live demos.

From Python to Go and back. (in Russian)
Back in 2014, I changed my coding language from Python to Go. I had been working with Go for more than 5 years. At the end of 2020, I returned back to the world of Python.
In this talk, I want to compare the two ecosystems, share my impressions, insights, and problems I've met. I'll tell you what (in my opinion) is wrong with Go, how both languages have changed during this time. Let's discuss what is missing in Python and what is missing in Go.
My story is based on personal experiences, insights, the path I've traveled, and mistakes I've made.

PostgreSQL optimization in Go: from 50 to 5000 RPS. (in Russian)
Let's analyze how to optimize the communication of the database with a Go service. Let's take a closer look at the borderline area, which is usually not covered by either database specialists or application programmers. Let's go from the general approach to optimization to the bloody nuances.

Crafting Kubernetes Operators on Go. (in Russian)
Operators are a great tool for simplified deployment and automatic
management of complex applications in Kubernetes.
This is a workshop for engineers who develop applications and system administrators who want to learn how to create operators for Kubernetes.
Participants will receive step-by-step instructions on how to create Kubernetes operators for complex stateful applications (such as databases) in Go (operators in Ansible and Helm will not be considered). We will show you the workflow for the current version of the operator-SDK, which includes both code generation capabilities and a set of library calls for various operations with Kubernetes objects.

Crafting linters using ruleguard. (in Russian)
In this workshop, we will understand what ruleguard is and how to use it to write diagnostics for our projects.
What's new we'll learn:
* What are" rules " and how to create, test, debug, store, and version them.
* Learn how to set up non-trivial projects.
* Learn how to analyze common integration problems and errors.
* We will discuss how to simplify the idea of diagnostics so that they become expressible through ruleguard.
* Learn the specifics of working with go / * packages in the context of ruleguard.
* We will understand what to do if the features of ruleguard are still not enough.

Fuzz and Property-Based tests in Go. (in Russian)
You write tests all day long, yet your code still crashes with a strange bug after a week? Brakes have failed when you decided to turn on a radio?! You heard about fuzzing but didn't understand how to apply it to your code?
During this workshop, we will:
* put our hands to randomized testing approaches: property-based and fuzz testing;
* discuss their differences, pros, cons, and pitfalls;
* help you decide when these approaches are the right tool for the job;
* learn to swiftly discover properties fit for checking without racking your brains for hours;
* touch on writing data-generators for complex data structures;
* go through the code examples of varying complexity: from fuzzing and checking elementary properties in form of ∀ X: decode(encode (X)) ≡ X to checking whether a system is equivalent to a stateful model.