book

Go by Example

Name: Go by Example
Author: Inanc Gumus
ISBN: 9781617299896

by Inanc Gumus

September 2025

Intermediate to advanced

336 pages

11h 49m

English

Manning Publications

Read now

Unlock full access

Go by Example Programmer’s guide to idiomatic and testable code
copyright
contents
dedication
preface
acknowledgments
about this book
about the author
about the cover illustration
1 Getting started
1.1 Why should you read this book?1.1.1 Learning by example1.1.2 Crafting idiomatic code1.1.3 Crafting testable code1.2 Why Go?1.3 Hello, gophers!1.3.1 Statically and strongly typed language1.3.2 Compilation and static binary1.3.3 Go runtime1.4 Concurrency1.4.1 Goroutines1.4.2 Go scheduler1.4.3 Channels1.5 Type system1.5.1 Composition instead of inheritance1.5.2 Implicit interfaces1.5.3 Testing with implicit interfaces1.6 Standard library1.7 Tooling1.8 Outro1.9 Source code and Go module

2 Idioms and testing
2.1 Groundwork2.1.1 Overview2.1.2 Implementation2.2 Idioms2.2.1 Names2.2.2 Errors2.2.3 Fields2.2.4 Standard interfaces2.3 Testing2.3.1 Writing tests2.3.2 Running tests2.3.3 Writing a failing test2.3.4 Writing descriptive test failure messages2.3.5 Fixing the code2.4 Table-driven tests2.4.1 Creating a table of test cases2.4.2 Writing a table-driven test2.4.3 Running a specific test2.4.4 Identifying problems with table-driven tests2.5 Subtests2.5.1 Understanding subtests2.5.2 Writing a table-driven test with subtests2.5.3 Understanding the role of specific T pointers2.5.4 Running subtests2.5.5 Fixing the code2.6 Example tests2.6.1 Writing an example test2.6.2 Running example tests2.7 Other testing tools
3 Test coverage and optimization
3.1 Test coverage3.1.1 Measuring test coverage3.1.2 Perfecting test coverage3.1.3 100% test coverage != bug-free code3.2 Benchmarking and optimization3.2.1 Writing and running benchmarks3.2.2 Using sub-benchmarks3.2.3 Profiling: Chasing out memory allocations3.2.4 Optimizing code3.2.5 Comparing benchmarks3.3 Compiler optimizations3.3.1 Inlining and dead-code elimination3.3.2 The sink variable3.3.3 A bright new future3.4 Parallel testing3.4.1 Running tests in parallel3.4.2 Running subtests in parallel3.4.3 Detecting data races3.5 Exercises
4 Command-line interfaces
4.1 Groundwork4.1.1 Implementing the first version4.1.2 Running the first version4.2 Flag parsing4.2.1 Overview4.2.2 Higher-order value parsers4.2.3 Implementing a flag parser4.2.4 Integration and setting sensible defaults4.3 The flag package4.3.1 Integration4.3.2 Demonstration4.4 Value parsers4.4.1 Value interface4.4.2 Satisfying the Value interface4.4.3 Using Var4.5 Positional arguments4.5.1 Flags vs. positional arguments4.5.2 Customizing usage messages4.5.3 Setting a positional argument4.6 Validation4.6.1 Writing a custom validator4.6.2 Validating flags with a custom validator4.7 Exercises
5 Dependency injection
5.1 Challenges to testability5.2 Testable programs5.2.1 Overview5.2.2 A place to store dependencies5.2.3 io.Writer’s role5.3 Decoupling5.3.1 Decoupling from the environment5.3.2 Decoupling the parser’s output5.3.3 Preparing for the HIT client5.3.4 Demonstration5.4 CLI tests5.4.1 Observing with a strings.Builder5.4.2 Streamlining tests5.4.3 Adding a helper5.4.4 Writing CLI tests5.5 Unit testing5.5.1 A helper type5.5.2 Unit-testing the parser
6 Synchronous APIs for concurrency
6.1 Overview6.1.1 Package hit6.1.2 Package API6.1.3 Directory structure6.2 Foundations6.2.1 Result6.2.2 Send6.3 Iterators6.3.1 Push iterators6.3.2 Producing values6.3.3 Consuming values6.3.4 Testing6.4 Options6.4.1 Providing options6.4.2 Accepting options6.5 Integration6.5.1 Printing a summary6.5.2 Integration6.5.3 Demonstration6.6 Concurrent pipeline pattern6.6.1 Benefits of concurrent pipelines6.6.2 Designing a concurrent pipeline6.7 Producer stage6.7.1 Implementation6.7.2 Integration6.8 Throttler stage6.8.1 Implementation6.8.2 Integration6.9 Dispatcher stage6.9.1 Implementation6.9.2 Integration6.9.3 Demonstration6.9.4 Outro6.10 Exercises
7 Responsive and efficient programs
7.1 Revisiting the concurrent pipeline7.2 Cancellation propagation7.2.1 What is Context?7.2.2 Context is like a tree7.2.3 Context in practice7.2.4 Deriving a new Context7.2.5 Is Ctrl+C the end?7.3 HTTP and efficient I/O operations7.3.1 Round-tripping7.3.2 Interface composition7.3.3 ReadAll: Eat it all7.3.4 Copy: Eat small, be small7.3.5 Putting it all together7.3.6 Demonstration7.4 Optimization7.4.1 Client and its RoundTripper7.4.2 Tweaking the connection pool7.4.3 Demonstration7.5 Testing7.5.1 Satisfying RoundTripper7.5.2 Testing with a RoundTripper7.6 HTTP testing7.6.1 Package httptest7.6.2 Testing the client7.7 Exercises
8 Structuring packages and services
8.1 Organizing and structuring packages8.1.1 Avoiding import cycles8.1.2 Structuring packages in practice8.2 Core8.2.1 Errors8.2.2 Core8.2.3 Service8.2.4 Mutex8.3 HTTP8.3.1 Health check8.3.2 Serving HTTP8.3.3 HTTP server8.4 HTTP handlers8.4.1 Handler closures8.4.2 Redirecting8.4.3 HTTP status codes8.5 Routing8.5.1 ServeMux8.5.2 Routes8.5.3 Demonstration8.6 Timeouts8.7 Testing8.7.1 Response recording8.7.2 Testing a handler8.7.3 Test helpers8.8 Simplicity8.8.1 Up-front abstractions and indirections8.8.2 Inherently testable types8.9 Exercises
9 Composition patterns
9.1 Middleware pattern9.1.1 What is HTTP middleware?9.1.2 Example9.1.3 Practice9.1.4 Learning more about the slog package and the any interface9.1.5 Integration9.2 Logging responses9.2.1 Measuring durations9.2.2 Response recording9.2.3 Integration9.3 Interceptor pattern9.3.1 Field embedding9.3.2 Capturing and saving9.3.3 Integration9.3.4 Demonstration9.4 Optional interface pattern9.4.1 Type asserting for optional functionality9.4.2 Unwrapping all the way down9.4.3 Unwrap9.5 Context value propagation pattern9.5.1 Generating, storing, and retrieving9.5.2 Middleware9.5.3 Wrapping slog handlers9.5.4 Implementing a slog.Handler9.5.5 Implementing WithAttrs and WithGroup9.5.6 Integration9.6 Handler-chaining pattern9.6.1 Chainable handlers9.6.2 Response handlers9.6.3 Responder9.6.4 Integration9.7 Encoding and decoding9.7.1 Encoding JSON9.7.2 Decoding JSON9.7.3 Speaking JSON9.8 Wrapping and unwrapping9.8.1 Safeguarding against denial-of-service attacks9.8.2 Unwrapping the original9.9 Outro9.10 Exercises
10 Polymorphic storage
10.1 Interacting with SQL databases10.1.1 Registering a driver10.1.2 Opening a connection pool10.1.3 File embedding10.2 Database-backed service10.2.1 Insertion10.2.2 Test database10.2.3 Integration testing10.2.4 errors.As10.2.5 Retrieval10.3 Valuer and Scanner10.3.1 Supporting custom database types10.3.2 Satisfying Valuer and Scanner10.3.3 Encoding and decoding10.4 Implicit interfaces10.4.1 Consumers-first approach10.4.2 Providing an interface10.4.3 Activating the new implementation10.5 Exercises
appendix A Modules and packages
A.1 PackagesA.1.1 ExampleA.2 Package mainA.3 ModulesA.4 Building and runningA.5 Exercises
appendix B Variables and pointers
B.1 VariablesB.2 PointersB.2.1 What is a pointer?B.2.2 Nil pointers and type safetyB.2.3 Address operatorsB.2.4 Pass-by-value mechanicsB.2.5 Stack and heap memoryB.3 Exercises
appendix C Arrays, slices, and maps
C.1 ArraysC.1.1 Array operationsC.1.2 Passing arrays aroundC.1.3 Passing a pointerC.1.4 ExercisesC.2 SlicesC.2.1 UsageC.2.2 Underlying arraysC.2.3 Passing slices aroundC.2.4 Slice expressions and capacityC.2.5 AppendingC.2.6 Making slicesC.2.7 Strings and byte slicesC.2.8 Aliasing effectsC.2.9 Copying slicesC.2.10 ExercisesC.3 MapsC.4 Exercises
appendix D Object-oriented programming
D.1 StructsD.1.1 Declaring a new typeD.1.2 Creating new valuesD.1.3 Anonymous typesD.1.4 Named typesD.2 Methods and receiversD.2.1 Receiver typesD.2.2 Value receiversD.2.3 Pointer receiversD.2.4 Avoid mixing receiver typesD.2.5 Which receiver type to choose?D.2.6 ExercisesD.3 Implicit interfacesD.3.1 Starting with the concrete typesD.3.2 Discovering an interfaceD.3.3 Wiring upD.3.4 Harnessing the power of interfacesD.3.5 Interface values and method setsD.3.6 ExercisesD.4 Generics
appendix E Concurrent programming
E.1 GoroutinesE.1.1 Running sequentiallyE.1.2 Running concurrentlyE.2 Using WaitGroupE.2.1 Using syncx.SafeGroupE.2.2 ExercisesE.3 Unbuffered channelsE.3.1 UsageE.3.2 SynchronizationE.3.3 Pattern: Sending and receivingE.4 Closing channelsE.4.1 Pattern: for-rangeE.4.2 Pattern: Coordinating with a closing signalE.5 Using the select statementE.5.1 Waiting for multiple channelsE.5.2 Pattern: Nonblocking operationsE.6 Buffered channelsE.6.1 Pattern: Timing outE.6.2 Directional channelsE.6.3 Pattern: Limiting concurrencyE.7 Exercises
appendix F Self-referential options
F.1 Struct optionsF.1.1 Zero-value ambiguityF.1.2 Zero-value optionsF.2 Option functionsF.2.1 SendNWithF.2.2 Options as functionsF.2.3 Applying optionsF.2.4 Outro
appendix G Cross-compiling Go programs

Content preview from Go by Example

appendix E Concurrent programming

Concurrency is dealing with a lot of things at once. Parallelism is doing a lot of things at once. —Rob Pike, from his Waza talk (https://go.dev/blog/waza-talk)

Concurrency may involve parallelism, but these two concepts are not the same. Concurrency is about structuring the code, whereas parallelism is about executing the code simultaneously.

Many goroutines can run concurrently on a single CPU through context switching, whereas parallelism may occur when multiple CPUs execute goroutines simultaneously. Grasping this distinction helps us structure concurrent code regardless of the number of available CPUs.

In this appendix, we’ll explore goroutines and channels. This appendix builds on concepts ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781617299896Publisher Support Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Go by Example

by Inanc Gumus

appendix E Concurrent programming

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.