book

100 Go Mistakes and How to Avoid Them

Name: 100 Go Mistakes and How to Avoid Them
Author: Teiva Harsanyi
ISBN: 9781617299599

by Teiva Harsanyi

September 2022

Intermediate to advanced

384 pages

10h 24m

English

Manning Publications

Audiobook available

Read now

Unlock full access

inside front cover
100 Go Mistakes
Copyright
dedication
contents
front matter
prefaceacknowledgmentsabout this bookWho should read this bookHow this book is organized: A roadmapAbout the codeliveBook discussion forumabout the authorabout the cover illustration
1 Go: Simple to learn but hard to master
1.1 Go outline1.2 Simple doesn’t mean easy1.3 100 Go mistakes1.3.1 Bugs1.3.2 Needless complexity1.3.3 Weaker readability1.3.4 Suboptimal or unidiomatic organization1.3.5 Lack of API convenience1.3.6 Under-optimized code1.3.7 Lack of productivitySummary
2 Code and project organization
2.1 #1: Unintended variable shadowing2.2 #2: Unnecessary nested code2.3 #3: Misusing init functions2.3.1 Concepts2.3.2 When to use init functions2.4 #4: Overusing getters and setters2.5 #5: Interface pollution2.5.1 Concepts2.5.2 When to use interfaces2.5.3 Interface pollution2.6 #6: Interface on the producer side2.7 #7: Returning interfaces2.8 #8: any says nothing2.9 #9: Being confused about when to use generics2.9.1 Concepts2.9.2 Common uses and misuses2.10 #10: Not being aware of the possible problems with type embedding2.11 #11: Not using the functional options pattern2.11.1 Config struct2.11.2 Builder pattern2.11.3 Functional options pattern2.12 #12: Project misorganization2.12.1 Project structure2.12.2 Package organization2.13 #13: Creating utility packages2.14 #14: Ignoring package name collisions2.15 #15: Missing code documentation2.16 #16: Not using lintersSummary
3 Data types
3.1 #17: Creating confusion with octal literals3.2 #18: Neglecting integer overflows3.2.1 Concepts3.2.2 Detecting integer overflow when incrementing3.2.3 Detecting integer overflows during addition3.2.4 Detecting an integer overflow during multiplication3.3 #19: Not understanding floating points3.4 #20: Not understanding slice length and capacity3.5 #21: Inefficient slice initialization3.6 #22: Being confused about nil vs. empty slices3.7 #23: Not properly checking if a slice is empty3.8 #24: Not making slice copies correctly3.9 #25: Unexpected side effects using slice append3.10 #26: Slices and memory leaks3.10.1 Leaking capacity3.10.2 Slice and pointers3.11 #27: Inefficient map initialization3.11.1 Concepts3.11.2 Initialization3.12 #28: Maps and memory leaks3.13 #29: Comparing values incorrectlySummary
4 Control structures
4.1 #30: Ignoring the fact that elements are copied in range loops4.1.1 Concepts4.1.2 Value copy4.2 #31: Ignoring how arguments are evaluated in range loops4.2.1 Channels4.2.2 Array4.3 #32: Ignoring the impact of using pointer elements in range loops4.4 #33: Making wrong assumptions during map iterations4.4.1 Ordering4.4.2 Map insert during iteration4.5 #34: Ignoring how the break statement works4.6 #35: Using defer inside a loopSummary

5 Strings
5.1 #36: Not understanding the concept of a rune5.2 #37: Inaccurate string iteration5.3 #38: Misusing trim functions5.4 #39: Under-optimized string concatenation5.5 #40: Useless string conversions5.6 #41: Substrings and memory leaksSummary
6 Functions and methods
6.1 #42: Not knowing which type of receiver to use6.2 #43: Never using named result parameters6.3 #44: Unintended side effects with named result parameters6.4 #45: Returning a nil receiver6.5 #46: Using a filename as a function input6.6 #47: Ignoring how defer arguments and receivers are evaluated6.6.1 Argument evaluation6.6.2 Pointer and value receiversSummary
7 Error management
7.1 #48: Panicking7.2 #49: Ignoring when to wrap an error7.3 #50: Checking an error type inaccurately7.4 #51: Checking an error value inaccurately7.5 #52: Handling an error twice7.6 #53: Not handling an error7.7 #54: Not handling defer errorsSummary
8 Concurrency: Foundations
8.1 #55: Mixing up concurrency and parallelism8.2 #56: Thinking concurrency is always faster8.2.1 Go scheduling8.2.2 Parallel merge sort8.3 #57: Being puzzled about when to use channels or mutexes8.4 #58: Not understanding race problems8.4.1 Data races vs. race conditions8.4.2 The Go memory model8.5 #59: Not understanding the concurrency impacts of a workload type8.6 #60: Misunderstanding Go contexts8.6.1 Deadline8.6.2 Cancellation signals8.6.3 Context values8.6.4 Catching a context cancellationSummary
9 Concurrency: Practice
9.1 #61: Propagating an inappropriate context9.2 #62: Starting a goroutine without knowing when to stop it9.3 #63: Not being careful with goroutines and loop variables9.4 #64: Expecting deterministic behavior using select and channels9.5 #65: Not using notification channels9.6 #66: Not using nil channels9.7 #67: Being puzzled about channel size9.8 #68: Forgetting about possible side effects with string formatting9.8.1 etcd data race9.8.2 Deadlock9.9 #69: Creating data races with append9.10 #70: Using mutexes inaccurately with slices and maps9.11 #71: Misusing sync.WaitGroup9.12 #72: Forgetting about sync.Cond9.13 #73: Not using errgroup9.14 #74: Copying a sync typeSummary
10 The standard library
10.1 #75: Providing a wrong time duration10.2 #76: time.After and memory leaks10.3 #77: Common JSON-handling mistakes10.3.1 Unexpected behavior due to type embedding10.3.2 JSON and the monotonic clock10.3.3 Map of any10.4 #78: Common SQL mistakes10.4.1 Forgetting that sql.Open doesn’t necessarily establish connections to a database10.4.2 Forgetting about connections pooling10.4.3 Not using prepared statements10.4.4 Mishandling null values10.4.5 Not handling row iteration errors10.5 #79: Not closing transient resources10.5.1 HTTP body10.5.2 sql.Rows10.5.3 os.File10.6 #80: Forgetting the return statement after replying to an HTTP request10.7 #81: Using the default HTTP client and server10.7.1 HTTP client10.7.2 HTTP serverSummary
11 Testing
11.1 #82: Not categorizing tests11.1.1 Build tags11.1.2 Environment variables11.1.3 Short mode11.2 #83: Not enabling the -race flag11.3 #84: Not using test execution modes11.3.1 The parallel flag11.3.2 The -shuffle flag11.4 #85: Not using table-driven tests11.5 #86: Sleeping in unit tests11.6 #87: Not dealing with the time API efficiently11.7 #88: Not using testing utility packages11.7.1 The httptest package11.7.2 The iotest package11.8 #89: Writing inaccurate benchmarks11.8.1 Not resetting or pausing the timer11.8.2 Making wrong assumptions about micro-benchmarks11.8.3 Not being careful about compiler optimizations11.8.4 Being fooled by the observer effect11.9 #90: Not exploring all the Go testing features11.9.1 Code coverage11.9.2 Testing from a different package11.9.3 Utility functions11.9.4 Setup and teardownSummary
12 Optimizations
12.1 #91: Not understanding CPU caches12.1.1 CPU architecture12.1.2 Cache line12.1.3 Slice of structs vs. struct of slices12.1.4 Predictability12.1.5 Cache placement policy12.2 #92: Writing concurrent code that leads to false sharing12.3 #93: Not taking into account instruction-level parallelism12.4 #94: Not being aware of data alignment12.5 #95: Not understanding stack vs. heap12.5.1 Stack vs. heap12.5.2 Escape analysis12.6 #96: Not knowing how to reduce allocations12.6.1 API changes12.6.2 Compiler optimizations12.6.3 sync.Pool12.7 #97: Not relying on inlining12.8 #98: Not using Go diagnostics tooling12.8.1 Profiling12.8.2 Execution tracer12.9 #99: Not understanding how the GC works12.9.1 Concepts12.9.2 Examples12.10 #100: Not understanding the impacts of running Go in Docker and KubernetesSummaryFinal words
index

Content preview from 100 Go Mistakes and How to Avoid Them

9 Concurrency: Practice

This chapter covers

Preventing common mistakes with goroutines and channels
Understanding the impacts of using standard data structures alongside concurrent code
Using the standard library and some extensions
Avoiding data races and deadlocks

In the previous chapter, we discussed the foundations of concurrency. Now it’s time to look at practical mistakes made by Go developers when working with the concurrency primitives.

9.1 #61: Propagating an inappropriate context

Contexts are omnipresent when working with concurrency in Go, and in many situations, it may be recommended to propagate them. However, context propagation can sometimes lead to subtle bugs, preventing subfunctions from being correctly executed.

Let’s consider ...

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

100 Go Mistakes and How to Avoid Them, Video Edition

Publisher Resources

ISBN: 9781617299599Publisher Support Publisher Website Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

100 Go Mistakes and How to Avoid Them

by Teiva Harsanyi

9 Concurrency: Practice

9.1 #61: Propagating an inappropriate context

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.