Grokking Advanced Go
Learn how Go values, memory, and interfaces work, how to use generics and iterators, how to design errors and modules, how to test, benchmark, and profile real programs, and how to build production HTTP services, with runnable Go 1.27 programs throughout.
Course Overview
Knowing the syntax of Go is enough to write a program that works. Writing one that stays fast, correct, and easy to change takes a deeper understanding. A slice can keep a large array in memory, a nil pointer stored in an interface can make a nil check fail, and a pointer passed to save time can add an allocation instead. This course explains how the language and its tools work. It starts with values and memory, then covers interfaces, generics, iterators, error design, modules, testing, benchmarking and profiling, the runtime, reflection, the standard library, HTTP services, and code generation. One running example, an order service, connects the chapters, and the final chapter builds it as a complete project. Most example programs run in the browser on Go 1.27, and tests, profiles, and examples with several files appear with their captured output.
What you'll learn in Grokking Advanced Go
- Predict what copies, escapes, and allocates, and how slices, maps, strings, and structs are laid out in memory.
- Write generic functions, types, and methods with constraints, and recognize when generics make code worse.
- Design errors that callers can check, using wrapping, errors.Is, errors.AsType, and joined errors.
- Test in depth with table tests, golden files, fakes, fuzzing, HTTP handler tests, and coverage.
- Reduce allocations, and tune the garbage collector with GOGC and GOMEMLIMIT.
- Use the standard library well: JSON v2, slog, os.Root, composed readers and writers, embed, and time.
- Generate code, write an analyzer, use build tags and cross compilation, and stamp versions into binaries.
- Understand interface values, avoid the nil interface trap, and design small interfaces for their consumers.
- Build and combine iterators with range over functions, the iter package, and pull iterators.
- Manage modules, version selection, workspaces, package layout, and major versions.
- Measure with benchmarks and benchstat, read CPU, memory, block, and mutex profiles, and use PGO.
- Use reflection, struct tags, unsafe, and cgo correctly, and recognize when to avoid them.
- Build HTTP services with routing, middleware, timeouts, validation, health checks, logs, and metrics.
- Apply it all in a complete order service, from domain types and tests to a profiled release build.
Course Content
Performance and the Runtime
Reflection, unsafe, and cgo
What people say about our courses
About the Author
Arslan Ahmad
Industry Expertise & Leadership
Arslan Ahmad is the lead author of Grokking Advanced Go. As the founder of Design Gurus and a former FAANG hiring manager, he has worked at industry giants like Facebook (now Meta) and Microsoft.
He has conducted hundreds of system design interviews, giving him unique insight into what top tech companies look for in candidates.
The course also incorporates expertise from senior engineers at Google, Meta, Amazon, Microsoft, and Uber, ensuring you learn system design best practices from professionals who have built and scaled real-world systems.
500+
Interviews Conducted
10k+
Students Taught
Related Courses
$197
$98
$48
FAQs
What is Grokking Advanced Go?
It is a text course on how the Go language, its tools, and its standard library behave in real programs. It covers values and memory, interfaces, generics, iterators, error design, modules, testing, benchmarking and profiling, the runtime, reflection, HTTP services, and code generation, and it ends by building one complete service.
Who is this course for?
It is for software engineers who already write Go and want to predict what their code will do under real load, for back-end engineers who build and maintain Go services, and for engineers preparing for interviews where Go internals come up.
What should I know before starting?
You should be comfortable with variables, slices, maps, strings and runes, structs, methods, interfaces, pointers, errors, and packages, and you should have started a simple goroutine. Grokking Go covers everything the course assumes.
How is this different from Grokking Go?
Grokking Go teaches the language from the beginning. This course assumes that knowledge and explains what happens below it: how a slice, map, or interface value is built, what a line of code costs, and how to test, measure, and ship a program. It also covers generics, iterators, modules, profiling, and the runtime, which Grokking Go does not teach.
How is this different from Grokking Concurrency in Go?
That course is about running work at the same time: channels, select, the sync and context packages, and concurrency patterns. This course covers the rest of advanced Go, and goroutines and channels appear only where a topic cannot be shown without them. You can take the two in either order.
Which version of Go does the course use?
Go 1.27. It uses current features such as generic methods, encoding/json/v2, errors.AsType, os.Root, the unique and weak packages, runtime.AddCleanup, and testing.B.Loop, and it says which Go version added each recent feature.
Do I need to install Go?
Not to start. Most example programs run in the browser, and you can change them before you run them. Tests, benchmarks, profiles, cgo, and examples with several files cannot run in the browser, so those lessons show the files together with their captured output, and you can run them with a local Go installation.
Does the course use third-party packages?
The programs that run in the browser use only the standard library. A few lessons show tools from outside it where they are the normal choice, such as benchstat for comparing benchmarks and the golang.org/x/tools analysis package for writing an analyzer.
What do I build in the capstone?
You build an order service from its domain types upward: a generic repository, cursor pagination, an HTTP API with one error format, tests that include fuzzing, a hot path that is profiled and improved, and a release build. Each part uses a technique from an earlier chapter.
Will this course help with interviews?
Yes. Questions about slices, maps, interface values, escape analysis, and the garbage collector are common in Go interviews, and several lessons end with a short section on how to explain the topic in an interview. The rest of each lesson teaches the subject itself, so what you learn applies to production code as well.
Is the course text-based or video-based?
It is text-based, with diagrams and runnable code in the lessons, and every chapter after the introduction ends with an adaptive assessment. You read an explanation, change the example, run it, and see the result without pausing or rewinding anything.
Do I get a certificate of completion?
Yes. Design Gurus issues a certificate once you have completed the course, and you can share the link directly or add it to your LinkedIn profile.
