CF

The Ultimate Guide to Debugging With Go

3h 41m 59s
English
Paid

The most important skill you were never taught. The ability to debug code locally and in production is critically important for any Go engineer, yet it is almost never directly taught. It took me years of working with Go in production to truly master debugging, and now I want to accelerate your learning by sharing everything I wish I had known at the start of my journey.

Course Highlights

This course is designed to be concise and practical, focusing solely on essential debugging skills.

  • No unnecessary information: Brief lessons with practical recommendations ensure that you stay focused on what's important.
  • Beginner-friendly approach: Debugging experience is not required. We start with the basics and progress to advanced topics, making sure everyone can follow along.

Course Structure

Beginner Topics

We will cover the fundamentals of debugging Go code, ensuring a solid foundation for all participants.

Advanced Topics

Once the basics are mastered, we'll dive into advanced debugging techniques to tackle more complex issues.

Why this Course?

By the end of this course, you will possess a comprehensive understanding of debugging in Go, enabling you to solve problems efficiently both in local and live production environments.

About the Authors

ByteSizeGo

ByteSizeGo thumbnail

ByteSizeGo is a Go-focused course platform run by Aaron Lee, focused on the production / debugging side of Go engineering rather than language tour material. The platform's distinctive contribution is the Foundations of Debugging series, which teaches the systematic skill of debugging Go services in production rather than relying on ad-hoc print statements.

The CourseFlix listing carries six ByteSizeGo courses: Foundations of Debugging for Golang, The Ultimate Guide to Debugging With Go, The Anatomy of Go, Building Production-Ready Services with gRPC and Go, AI Engineering with Go, and The Art of Command Line Interfaces. Material is paid and aimed at working Go developers ready to deepen the operational side of their craft.

Matt Boyle

Matt Boyle thumbnail

Matt Boyle is a UK-based software engineer (formerly at Cloudflare) and the founder of ByteSizeGo's debugging course track. He publishes the This Week in Go newsletter and is one of the most consistent voices on the production-engineering side of Go development.

His CourseFlix listing carries two Matt Boyle courses, both focused on debugging Go services in production: Foundations of Debugging for Golang and The Ultimate Guide to Debugging With Go. Material is paid and aimed at working Go developers ready to systematically improve their debugging skill.

Watch Online 38 lessons

This is a demo lesson (10:00 remaining)

You can watch up to 10 minutes for free. Subscribe to unlock all 38 lessons in this course and access 10,000+ hours of premium content across all courses.

View Pricing
0:00
/
#1: Welcome!
All Course Lessons (38)
#Lesson TitleDurationAccess
1
Welcome! Demo
00:54
2
What is Debugging and why do we do it?
02:07
3
Introduction
02:13
4
Understanding code patterns and being aware of common errors
04:31
5
Exercise Solution
04:38
6
Pair Programming
04:01
7
Story Time - How I used these techniques to solve a production issue
02:22
8
Introduction to Logging
00:36
9
Logging Locally, the simple way
12:17
10
Logging for production; slog and log levels
08:09
11
Logging for production; slog,kibana and elastic search
13:47
12
Exercise Solution
15:01
13
Bonus Lesson: httputil
02:25
14
Introduction to the Debugger
01:17
15
Setting up the Debugger in Goland
01:06
16
Setting up the debugger in VSCode
02:31
17
Reading panic traces, breakpoints, conditional breakpoints and debugging nil pointer exceptions.
06:37
18
Debugging goroutines
06:25
19
tests as an entry point to debugging; debugging tests
04:58
20
Debugging a http request
02:23
21
Exercise Solution
11:41
22
Using the Debugger to debug a Go application in a Docker container
05:03
23
Introduction to Metrics
00:39
24
What should I measure?
04:20
25
Adding Metrics to an API written in Go
09:28
26
Introduction to Prometheus; Building Dashboard in Grafana
11:51
27
Exercise Solution
05:49
28
Introduction to Distributed Tracing
02:10
29
Adding Traces to a Go API
09:02
30
Tracing across services
06:15
31
Exercise Solution
06:17
32
Introduction to Profiling
04:05
33
Lets add Profiling to your Go Application
04:08
34
Profiling the Heap (Memory)
07:33
35
CPU tracing and pprof list
08:51
36
Profiling goroutine usage
07:16
37
Exercise Solution
12:18
38
Bonus Lesson: gotraceui and flight recording (new in Go 1.22)
06:55
Unlock unlimited learning

Get instant access to all 37 lessons in this course, plus thousands of other premium courses. One subscription, unlimited knowledge.

Learn more about subscription

Related courses

Frequently asked questions

What prerequisites do I need before taking this course?
This course is beginner-friendly and does not require previous debugging experience. It starts with the fundamentals of debugging Go code, making it accessible to those new to debugging. Having a basic understanding of Go programming is beneficial, as the course focuses on debugging skills specific to Go applications.
What projects or applications will I learn to debug in this course?
Throughout the course, you will learn to debug various aspects of Go applications, including reading panic traces, setting breakpoints, debugging goroutines, HTTP requests, and Go applications within Docker containers. These practical exercises aim to build your confidence in diagnosing and solving issues in both local and production environments.
Who is the target audience for this course?
The course is designed for Go engineers at all levels who want to improve their debugging skills. It is particularly suitable for those who have experience writing Go code but feel less confident when it comes to debugging complex issues in local or production environments.
How does the depth of this course compare to other debugging courses?
This course offers a concise and practical approach, focusing solely on essential debugging skills tailored for Go applications. Unlike broader debugging courses, it provides specific insights into logging, metrics, tracing, and profiling within the Go language, ensuring a comprehensive understanding of debugging in Go.
What specific tools or platforms are covered in this course?
The course covers several tools essential for debugging Go applications, including setting up debuggers in Goland and VSCode, using logging tools such as slog and Kibana, integrating metrics with Prometheus and Grafana, and utilizing profiling tools like pprof and gotraceui.
What topics are not covered in this course?
The course specifically focuses on debugging Go applications, so it does not cover general Go programming concepts or other development frameworks and languages outside of debugging. It assumes that you have a basic understanding of Go programming.
What is the expected time commitment for this course?
The course consists of 38 lessons designed to be concise and practical. Although the exact runtime is not specified, the structure suggests a focus on brief, focused lessons. This allows participants to learn efficiently without spending unnecessary time on non-essential information.