Beyond Effective Go: Part 2 - Striving for High-Quality

About the Author
Acknowledgments
Contents
Preface
Book Structure and Formatting
Chapter 4
Introduction
Code
Exploring Software Design Principles
	Minimalist and composable
	The DRY principle vs. the KISS principle
	Aspects to consider when applying the DRY principle
	Delegation
	Favor composition over inheritance
	Accept interfaces and return structs
	Accepting interfaces
	Returning structs
	The singles principle
	A single purpose
	A single responsibility
	A single level of abstraction
	The interface segregation principle
	Roles versus responsibilities
	The dependency inversion principle
Object-Oriented Design Patterns
	The singleton pattern
	Usage
	Implementation
	What is different in Go?
	The factory method pattern
	Usage
	Implementation
	What is different in Go?
	The observer pattern
	Usage
	Implementation
	What is different in Go?
	The adapter pattern
	Usage
	Implementation
	What is different in Go?
	Final thoughts on patterns
Summary
Questions
Chapter 5
Introduction
Code
What is Code UX?
Achieving Clarity
	Why idiomatic code?
	Formatting
	Whitespace
	What’s in a name?
	Names should be meaningful
	Names should be concise
	Names should be consistent
	Names should be context-aware
	Names don’t need to be original
	Adopting early return
	Switching to extended switch
	Avoiding shadowing
	Better struct initialization
	Avoiding foreign idioms
	Writing useful documentation
	Errors are not exceptional
	Named errors
	Wrapped errors
	The use of globals and init()
	Enums
	Don’t panic()!
Striving for Consistency
	Achieving a consistent style
	Building consistent packages
	The size and scope of packages
	Packages should be self-contained
	It’s all in the package name
	File organization
	How many files should be in a package?
	Do I need a function or a method?
	How long should our functions and methods be?
	Consider parameters and return values
	The number of arguments
	The scope of the arguments
	The grouping of the arguments
	The ordering of the arguments
	Boolean arguments are evil
	Reducing constructor arguments
	Employing private constructors
	Adopting config injection
Becoming Predictable
	APIs: export only what you must
	APIs: good fences make good neighbors
	Predictability with encapsulation
	Constructors
	A little copying vs. a little dependency
Dealing with Conflicting Goals
	Tradeoffs between code UX and performance
	Tradeoffs between code UX and code UX
Summary
Questions
Chapter 6
Introduction
Code
The What, When, Why, and How of Testing
	Why do we test?
	When do we test?
	How much should we test?
	Unit tests
	User acceptance tests
	End-to-end tests
	The test pyramid
	What should we be testing?
	What should we not be testing?
Table-Driven Tests
Test Scenario Construction
	What are the intended features and behaviors?
	What\'s the impact of different input types?
	How could things go wrong?
Mocks, Stubs, and Test Recorders
	Mocks and the Mockery tool
	Stubs
	Quick mocks and stubs
	Test recorders
Test UX and Quality
	The predictability of a pattern
	Improving test readability
	Using assertion libraries
	Avoiding the ambiguity of magic constants
	Reducing duplication
	Duplication caused by dependencies
	Duplication caused by mocks
	Duplication caused by test inputs
	Scenario 1: The input value influences the outcome
	Scenario 2: The input has no influence on the outcome
Achieving Test Resilience
Test Tricks That You Might Not Know
	The lesser-known Go test features
	The run flag
	The short flag
	The timeout flag
	The count flag
	Tests with context
	Test data
	Testing and private constructors
	Test-only config
	Internal initialization
	Function-based dependencies
	Testing with globals
	Testing fluent APIs
	Testing concurrent code
	Avoidance
	Switching outputs to channels
	Using a test latch
	Ensuring tests always complete
	Strategy 1: go test -timeout
	Strategy 2: Use channel results
	Strategy 3: Set context timeouts
	Strategy 4: Use give-ups
	Benchmarking concurrent code
	Asserting that an object implements an interface
	Fixing bugs
	Skipping tests
	Approach 1: use init()
	Approach 2: use an environment variable
	Approach 3: check for installed applications
	Global variables
Identifying Test-Induced Damage
	Parameters or configuration that only exist for testing
	Outputs that only exist for testing
	Parameters that cause leaky abstractions
	Publishing mocks in production code
	Excessive test coverage
Make it Work, Make it Clean, and Then, Maybe, Make it Fast
Summary
Questions
Interlude
Chapter 7
Introduction
Code
Be Lazy
	Less is often better
	Writing documentation can save time
Be Observant
	Look for repeated tasks
	Look for common mistakes
	Clean as you go
Be Introspective
Be Adventurous
	Use automated tests
	Plan, but just enough
	Expect change
Master Your Tooling
	Build tools that work for you
	Calculate unit test coverage
	Perform race detection with tests
	Format code and imports
	Generate/regenerate code
	Generate the dependency graph
	Ship it!
	Master your IDE
	Useful features
	Context actions
	The test runner
	Live templates
	Useful shortcuts
	Useful plugins
	Master your environment
	Handy Git scripts
	Shell aliases
Make Small Changes
Summary
Questions
Chapter 8
Introduction
Code
Functional Programming in Go
	First-class and higher-order functions
	Recursion
	Currying and partial functions
	Immutability
Fun with functions
	Understanding anonymous functions and closures
	Function-based patterns
	Replacing abstract methods
	Implementing middleware
	Functional options
	Decorating functions to satisfy an interface
	Function chaining
Implementing Futures
	Implementing futures the Go way
	Considerations surrounding futures
Curious Struct Tricks
	Empty structs
	Anonymous structs
	noCopy
Summary
Questions
Chapter 9
Introduction
Code
Integrating with APIs
	API integration example
	Calling the PagerDuty API
	Handling the API response
	Configuration and the command line
	Validation and reporting
	Wrapping up
Using Go to Coordinate Other Programs
Code Generation in Action
	A very brief introduction
	Code generation example
	Go’s AST
	Go’s text/template package
	Putting it all together
	Final thoughts on code generation
Summary
Questions
Postface
More From This Author
	Beyond Effective Go - Part 1
	Hands-On Dependency Injection in Go
	Articles and links to other content