Go by Example: Programmer's Guide to Idiomatic and Testable Code
Unlock Go's unique perspective on program design and start writing simple, maintainable, efficient, and testable code through hands-on, realistic project examples.
You can read the book at https://mng.bz/DwMy.
What is this book about?
- Example projects based on real-world scenarios.
- Writing idiomatic, efficient, and testable Go code from scratch.
- Writing code that is easy to read, maintain, and extend.
- Demonstrating Go's unique features and using them as they were intended.
- Go patterns, best practices, and common pitfalls to avoid.
Who is this book for?
- Expert programmers proficient in another Object-Oriented language and want to learn idiomatic Go.
- Gophers who want to improve their skills and knowledge for writing idiomatic, efficient, and testable code.
This book includes a Go crash course in Appendices.
Table of Contents
[!TIP]
Click on the chapter headings to see the code listings.
Chapter 1: Getting started
This chapter explores the book's goals, introduces Go, and showcases Go's prominent features without fully delving into Go's mechanics and idioms. It gets you started with Go and prepares you for the more advanced topics covered in the book.
Topics covered
- Why should you read this book?
- Importance of writing idiomatic and testable code
- Presenting Go's prominent features
Chapter 2: Idioms and testing
This chapter focuses on writing idiomatic code and testing.
Topics covered
- Exploring idiomatic guidelines with packages
- Satisfying the standard library interfaces
- Writing and running tests using the tools provided by Go
- Using table-driven testing and subtests to improve maintainability
- Writing example tests to generate runnable documentation
Chapter 3: Test coverage and optimization
This chapter covers the importance of test coverage and performance optimization.
Topics covered
- Measuring test coverage to see what percentage of code is tested
- Optimizing for performance using benchmarks and profiling
- Parallel testing to reduce test run time and detect data race issues
Chapter 4: Command-line interfaces
This chapter uses the standard library alone to write idiomatic command-line programs.
Topics covered
- Structuring and writing user-friendly command-line tools
- Parsing command-line arguments and flags
- Exploring the standard library's
os and flag packages
- Extending the
flag package with custom types
Chapter 5: Dependency injection
This chapter explores how to decouple code from its dependencies to improve testability and maintainability.
Topics covered
- Exploring challenges to testability
- Improving testability by isolating dependencies
- Using dependency injection techniques for testability
Chapter 6: Synchronous APIs for concurrency
This chapter focuses on designing and structuring synchronous APIs that treat concurrency as an implementation detail.
Topics covered
- Designing synchronous APIs that treat concurrency as an implementation detail
- Standardizing the processing of sequences of values using push iterators
- Structuring concurrent processing with the pipeline pattern
Chapter 7: Responsive and efficient programs
This chapter focuses on writing responsive and efficient programs, using HTTP as a case study.
Topics covered
- Propagating cancellation signals using the
context package
- Efficiently processing HTTP using the
net/http package
- Efficiently consuming byte streams using the
io package
- Interface embedding and composition mechanics
- Idiomatic testing techniques using the
RoundTripper interface
- Testing against a test HTTP server using the
httptest package
Chapter 8: Structuring packages and services
This chapter focuses on package organization and structuring that avoids import cycles, using HTTP services as a case study.
Topics covered
- Effectively organizing and structuring packages to avoid import cycles
- Simplifying the use of types by making their zero value useful
- Protecting against unsafe concurrent use of shared state with mutexes
- Implementing and testing HTTP servers with the
http and httptest packages
- Recording HTTP responses with custom test helpers to streamline testing
Chapter 9: Composition patterns
This chapter focuses on composition patterns to demonstrate how to design packages that offer reusable and composable functionality.
Topics covered
- Effectively using composition patterns and functional programming techniques
- Leveraging field embedding and method forwarding to reuse functionality
- Understanding optional interfaces, method hiding issues, and type assertions
- Propagating request-scoped values across package APIs Using
Context
- Implementing custom
slog.Handlers to log extra attributes automatically
- Wrapping interfaces to modify, extend, and intercept existing behavior
- Extracting implicit behavior using anonymous interfaces
Chapter 10: Polymorphic storage
This chapter explains using implicit interfaces to decouple storage from its consumers and highlights consumer-defined interfaces.
Topics covered
- Interacting with SQL databases
- Understanding the driver pattern
- Integration-testing external services
- Leveraging consumer-driven interface approach
Appendix A: Modules and packages
This appendix introduces the concept of modules and packages.
Appendix B: Variables and pointers
This appendix covers the basics of variables and pointers.
Appendix C: Arrays, Slices, and Maps
This appendix covers the basics of arrays, slices, and maps.
Appendix D: Object-oriented programming
This appendix covers the basics of object-oriented programming in Go.
Appendix E: Concurrent programming
This appendix covers the basics of concurrent programming in Go.
Topics covered
- Goroutines and their usage
- Using
WaitGroup to synchronize goroutines
- Unbuffered channels for communication between goroutines
- Closing channels to signal completion
- Using
select to handle multiple channel operations
- Buffered channels for decoupling goroutines
- Many other widely used concurrency patterns
Appendix F: Self-referential options
This appendix covers Rob Pike's self-referential options pattern and compares it with other approaches.
Appendix G: Cross-compiling Go programs
This appendix shows how to cross-compile Go programs for different operating systems and architectures.
