Go: Beyond the Basics

Day One

Writing code like the Go team (30 minutes)

In the first section of the course, you’ll learn to make your code look like it belongs in Go’s standard library—and why that’s important. We’ll cover how to organize your code into packages and what those packages should contain. You’ll discover how to write clearer and more understandable code and learn the unwritten Go patterns and conventions that go beyond “go fmt.”

• Packages
• Naming conventions
• Source code conventions

Effective error management (30 minutes)

You’ll learn how to effectively handle errors in Go by exploring wrong ways to handle errors and better alternatives. You’ll learn when it’s appropriate to handle an error and when it’s appropriate to pass it back up the call stack, and discover some of the ways errors can cause problems for users. You’ll end up with clear guidelines for error handling.

• Comparing errors with known types
• Exporting errors
• Libraries are different
• Annotating errors
• Wrapping errors for clarity

Embracing the standard library (30 minutes)

You’ll learn how to get the most out of Go’s amazing standard library. We’ll look at several standard library packages that are highly useful but often ignored, and explore the common interfaces in the standard library. You’ll learn how to write code that is more efficient and with fewer dependencies.

• Hidden gems in Go’s standard library
• Common interfaces
• Using stdlib for maximum effect

Creating useful interfaces (30 minutes)

We’ll look at Go’s interfaces and learn how to employ them for maximum flexibility and code reuse. We’ll single out several interfaces from the standard library and explore what makes them powerful. You’ll learn how to make your abstractions count with concise interfaces.

• What makes a good interface
• Standard library interface examples
• Interface size versus interface utility

Wrangling concurrency (60 minutes)

We’ll explore advanced techniques to enable concurrency in your applications. You’ll learn when and how to use channels and mutexes, as well as the common pitfalls of each, and how to detect and prevent data races and concurrency errors. You’ll also get practical experience using tools like sync.WaitGroup and sync.ErrorGroup to make your applications more reliable.

• Mutexes
• Channels
• sync.WaitGroup
• sync.ErrorGroup
• Race detection

Day Two

Profiling and benchmarking(60 minutes)

We’ll begin day two by exploring how you can make your application faster with Go’s tools for profiling, benchmarking, and optimization. Live demonstrations of profiling and optimization workflows and hands-on labs will give you firsthand experience you can use to find performance bottlenecks.

• GODEBUG
• pprof and debug/pprof
• Benchmarks
• perf
• Go tool trace

Writing code to be fast the first time (30 minutes)

Building on what we learned from profiling and benchmarking, we’ll explore techniques for creating fast code. You’ll learn how to minimize garbage created in your application, how to build reusable pools of expensive resources, and tricks to make your applications faster.

• Arrays and slices
• Make GC faster by creating less garbage
• Pools
• Avoiding unnecessary conversions
• Use the stack

Real-world testing (30 minutes)

We’ll explore real-world code from open-source Go projects to learn how to write testable code. You’ll discover how to create packages, functions, and types that are more testable and how to test hard-to-test corners of your code.

• Writing testable code
• Interfaces and mocks
• Integration tests
• Testing hard-to-test code

Writing scalable services (30 minutes)

We’ll cover advanced patterns and techniques for building applications that scale beyond your staging environment. You’ll learn how to prevent resource exhaustion by using timeouts and cancellations and how to measure the potential performance of your application to find theoretical maximums your application can handle with a single instance.

• Timeouts and cancellations using Contexts
• Measuring throughput
• Determining your limits
• Measuring, monitoring, and logging

Q&A (30 minutes)