eBPF: modern introspection features in Linux or the Kernel is no longer a black box.
For an "average" programmer, the Linux kernel has always been a kind of black box. It is difficult to understand what is going on inside. For non-trivial problems on a server, we'll either call "experienced specialists" or give up.
This situation changes dramatically with the arrival of eBPF. Processes inside the kernel and inside your programs become much easier to understand. The infrastructure around eBPF makes it possible to write convenient and powerful utilities. It gives everybody powerful abilities previously available to the "elites" only.
You'll learn what eBPF is, why it came into existence, and what features it provides. You will see how to use it to introspect programs written in Go, and how we can use Go to introspect other programs.

GoLand Tips & Tricks.
In this session, Florin will go over 40 tips & tricks to boost your productivity while using GoLand.
From basic editing tips to advanced debugging options, no section of the IDE will be left untouched.
Watch this session and see how many of these did you knew and used already.

Continuous profiling in Go applications.
Sooner or later, every developer is facing application profiling.
We have a handy pprof tool for that. But in real life it can be challenging. For example, you have to collect profiles from all instances of the application at the same time?
How to investigate the issue that happens at 3 am during stress testing?
You don't have access to the production server at the moment but have to solve the issue right now. What shall you do?
After solving numerous challenges like those, we created a better tool, which makes your profiling great again.

Generic Programming in Go.
Go detractors usually point to its lack of generics as a reason for not adopting the language. Starting in 2019, however, the Go community rallied around a new proposal to introduce generics in Go. This proposal has culminated in the release of the experimental implementation of the latest proposal. In this session, speaker Vladimir Vivien will explore programming using generic constructs in Go and why this approach to programming is important.

Illustrated Tales of Go Runtime Scheduler.
Concurrency in Go in the form of goroutines and channels is a very convenient means for writing modern concurrent software. It may seem like magic; but how does your Go program run these goroutines efficiently?
In this talk, Ankur will peek under the hood to help you understand how the Go runtime scheduler implements this magic and how to use it to interpret scheduler trace information from a Go program during performance debugging.

Intro to AI for software engineers using go-learn.
AI is a 2020 buzzword. There is an ever-growing need for the Software Engineer to understand how these models work. This talk I explain AI/ML basics in the context of Go dev. It is a hands-on demo using the go-learn library to explain of classing ML techniques. As the industry explodes with potential, there is an ever-growing need for Software Engineers to understand how Machine Learning models work. For most people, Machine Learning seems complex, academic, and even unreachable, but with some detailed explanation, it can become a valuable tool on the Software Engineer's tool belt.

How to use code generation in Go.
What is a code generator? When do you need it?
How to write your custom code generator? Is it worth your time?
At Open mobile platform we optimized our microservices development using custom code generators.
In this talk I want to discuss the topic and share our experience with you.

"Go, please": language server under a microscope.
We will discuss the basic principles of gopls and LSP protocol: the pros and cons, compare the features of the language server with VSCode and features of IDE GoLand. Also, we are going to implement one of the protocol commands as an example.

Stop worrying about the required fields and start writing contracts!
Backend-Driven UI involves working with a large number of different contracts. Requirements (as well as new interface elements) change at lightning speed. It is especially true if for product development.
In this talk, I'll let explain how to prepare contracts using protobuff, how it helps to work with the required fields, and how to check whether they are formed correctly. We will also discuss what awaits us in APIv2.

Debugging concurrency programs in Go.
Recently the interest in concurrent programming has grown dramatically. Unfortunately, parallel programs do not always have reproducible behavior. Even when they are run with the same inputs, their results can be radically different.
In this talk I'll show you different approaches on how to debug concurrency programs in Go.
I'll start from showing how you can debug your gorotines using delve and gdb debuggers. Then I'll try to visualize goroutines using different scenarios, sometimes it helps to better understand how things work.
Next part of the topic will be about dumping a goroutine stack trace of your application while it's running and inspect what each goroutine is doing.
And finally I'll demonstrate how to debug leaking goroutines by tracing the process of how the scheduler runs goroutines on logical processors which are bound to a physical processor via the operating system thread that is attached.
As a bonus i'll cover debugging tips on how to find deadlocks and how to avoid race conditions in your application.

Growth of the open source project community: problems and solutions.
Open source maintainers have a lot of problems as their projects grow. How to write more and more required features? How to fix more and more issues, and still have time to manage more and more pull requests? Using the example of WAL-G (golang open source project), I'll tell you about our solutions to these problems. We started a class about open source development at the University and involve students in our work. I'll introduce our achievements and vision for the next steps.

Getting started with application observability, a workshop.
Observability - one of the key properties for modern applications. Typically, when we talk about it, we mean logs, metrics, and traces. However, according to the definition, observability is a measure that shows our ability to understand the current state of the system or any component of the system. In this workshop, we will see how applications themselves can contribute to observability of the whole system.
We will discuss the importance of observability and the role of application in building observable systems. During the workshop, we will focus on practical examples and cases. We will start with an application that doesn't provide any observability and will see how to improve the situation step-by-step. At the end of the workshop, our application will achieve a significantly better level of observability. The ideas and techniques of this workshop are applicable to different tools but for simplicity, we will use DataDog to analyze the data. If you would like to work with your own code, feel free to bring it to the workshop. Otherwise, you will be provided with a typical web service.

Workshop: TLA+ / TLC: a practical tool for formal verification of algorithms that every gopher should know.
Developing concurrent systems is challenging. Tests can easily miss obscure errors in an algorithm.
Such errors occur in edge cases and will blow up your production system. There are ways to guard against thjs, without writing any extra lines of Go; of these so-called formal verification methods, TLA+ and TCL are ideal for verifying concurrent systems written in Go.
In this talk we explore TLA+/TCL and also PlusCal - a high-level language which translates into TLA+, elaborating on the practice of using such tools Go projects specifically.