Derek Parker

This talk will cover all the new features and changes in Delve since the last in-person FOSDEM and then go right into a deep-dive into how Delve enables extremely low-overhead tracing of Go programs using eBPF. Attendees will learn not only how to use this new feature of Delve, but also how they can leverage eBPF in their own Go programs. I will start by introducing this new feature, showcasing how it can be used, and then I will take the audience into an in-depth look at how it is implemented under the hood. The talk will feature a code walkthrough and detailed explanation of the technical details that went into making this feature a reality. I will also talk in depth about the libraries and approaches used to enable Go programs to leverage eBPF, which will empower attendees to implement such a feature in their own applications as well.

This talk is accessible to any level of Go programmer, from novice to advanced. Novice users will get a lot of benefit from learning how to use the tracing feature in Delve to track down problems in their code, while intermediate to advanced users will get a lot of information from the technical deep dive and will also walk away with the knowledge of how to integrate eBPF programs into their own codebases. The information in this talk will be practical and immediately applicable to attendees in their day-to-day Go development.

In this talk I will begin by delivering the "State of Delve" update. In similar fashion to the popular "State of Go" talk I will begin by discussing all of the exciting new features and changes that have happened over the past year, since last FOSDEM. Following that I will go into a live demo showcasing how Delve can leverage Mozilla RR in order to perform deterministic debugging. This talk will begin by introducing users to the concept of deterministic debugging and the power that comes with it. Following that I will launch into a demo showcasing how to leverage this concept to debug an otherwise unpredictable highly concurrent program. Users will walk away with immediate practical knowledge they can begin applying in their day to day debugging.

It's been a year since last FOSDEM and a lot has changed with Delve! I will discuss all the new features and changes that have been implemented in the last year.

Following the "State of Delve" introduction, I will dig into how Delve can be utilized to perform deterministic debugging. This style of debugging enables users to record the execution of their process and "play it back" in a deterministic fashion in order to more quickly and efficiently perform root cause analysis on a bug that may otherwise be difficult to reproduce or track down. This section of the talk will begin by introducing the concept of deterministic debugging and why it is so useful and powerful. Once everyone is familiar with the concept I will launch into a live demo showcasing how to leverage this debugging approach to track down and fix a bug which is hard to reproduce and happens only intermittently.

Attendees will walk away with practical knowledge that they can begin applying to their debugging problems immediately.

Hands on Go debugging with Delve. Less slides, more substance: this talk will be focused on live demos that the audience is invited to participate in. Come learn advanced debugging techniques and the intricacies of the Delve debugger.

In this talk I will present several demos, all of which will be available online. Each demo will target a specific use case of Delve. The goal is for audience members to walk away with an expert level understanding on the usage of the Delve debugger. During the course of this talk users will be guided through basic to very advanced usage of Delve, exploring features they may not have used, or known existed!

Topics covered will include basic debugging, tracing, advanced Goroutine debugging, panic debugging, general advanced debugging and low-level debugging (exploring registers, disassembly, etc). Each demo will have an accompanying program that will be hosted online and available for everyone to download to enable everyone to follow along.

Learn how to utilize the Delve debugger to dig into and solve complex bugs in your code.

Delve is a powerful yet simple open source debugger for the Go programming language. In this talk, I will discuss what makes both Go and Delve different from other languages / debuggers, and then dive into real world usage. I will begin by introducing the tool, and showing the basics of how it works. From there I will use specific example problems to show how to use some of the most powerful features of Delve to solve even the most complex bugs.

This talk will be beneficial to beginners and advanced users alike.

Learn how to utilize the Delve debugger to dig into and solve complex bugs in your code.

Delve is a powerful yet simple open source debugger for the Go programming language. In this talk, I will discuss what makes both Go and Delve different from other languages / debuggers, and then dive into real world usage. I will begin by introducing the tool, and showing the basics of how it works. From there I will use specific example problems to show how to use some of the most powerful features of Delve to solve even the most complex bugs.

This talk will be beneficial to beginners and advanced users alike.

I will start with a deep dive into the Go programming language. Topics of discussion will include the runtime, DWARF, scheduler, and more. From there, I will introduce Delve and discuss how it is different from other debuggers and walk through basic usage. After that I will switch over to a terminal where I will work through several pre-made bugs, highlighting certain features of Delve. The goal of this talk is to equip users with all of the knowledge and confidence they need to use Delve to effectively debug their programs.

Learn about debugging Go programs from the creator of Delve: a debugger for the Go programming language.

Debugging programs can be extremely difficult. Start mixing in massive parallelism and the task quickly devolves into a frustrating exercise that challenges your patience and sanity. During the course of this talk I will show how Delve can take the pain out of debugging Go programs. Concretely, I will explain the problems Delve solves, and present the features unique to Delve.

Go programs can be very difficult to debug. During this talk I will explain why that is true, and in the process why I created Delve and how it makes debugging Go programs easier.

I will begin by explaining why Go is difficult to debug, and why existing debuggers are incompatible with Go. Following that I will take a deep dive into Delve explaining how it works, and how it solves the problems discussed in the beginning of the talk. Following that I will launch into a demo, showing how to use Delve and how to leverage the specific features of Delve to debug Go programs.

This talk is aimed at people of all skill levels. There will be several 'usage' examples that can benefit everyone, as well as very technical deep dives into Go and debuggers which will appeal to intermediate / advanced Go developers.