001. Chapter 1. Go Simple to learn but hard to master
002. Chapter 1. 100 Go mistakes
003. Chapter 2. Code and project organization
004. Chapter 2. 3 Misusing init functions
005. Chapter 2. 5 Interface pollution
006. Chapter 2. Interface pollution
007. Chapter 2. 7 Returning interfaces
008. Chapter 2. 9 Being confused about when to use generics
009. Chapter 2. 10 Not being aware of the possible problems with type embedding
010. Chapter 2. 11 Not using the functional options pattern
011. Chapter 2. 12 Project misorganization
012. Chapter 2. 14 Ignoring package name collisions
013. Chapter 2. 16 Not using linters
014. Chapter 3. Data types
015. Chapter 3. 19 Not understanding floating points
016. Chapter 3. 20 Not understanding slice length and capacity
017. Chapter 3. 21 Inefficient slice initialization
018. Chapter 3. 22 Being confused about nil vs. empty slices
019. Chapter 3. 24 Not making slice copies correctly
020. Chapter 3. 26 Slices and memory leaks
021. Chapter 3. 27 Inefficient map initialization
022. Chapter 3. 28 Maps and memory leaks
023. Chapter 3. 29 Comparing values incorrectly
024. Chapter 4. Control structures
025. Chapter 4. 31 Ignoring how arguments are evaluated in range loops
026. Chapter 4. 32 Ignoring the impact of using pointer elements in range loops
027. Chapter 4. Map insert during iteration
028. Chapter 5. Strings
029. Chapter 5. 37 Inaccurate string iteration
030. Chapter 5. 39 Under-optimized string concatenation
031. Chapter 5. 41 Substrings and memory leaks
032. Chapter 6. Functions and methods
033. Chapter 6. 43 Never using named result parameters
034. Chapter 6. 45 Returning a nil receiver
035. Chapter 6. 47 Ignoring how defer arguments and receivers are evaluated
036. Chapter 7. Error management
037. Chapter 7. 50 Checking an error type inaccurately
038. Chapter 7. 52 Handling an error twice
039. Chapter 7. 54 Not handling defer errors
040. Chapter 8. Concurrency Foundations
041. Chapter 8. 56 Thinking concurrency is always faster
042. Chapter 8. Parallel merge sort
043. Chapter 8. 58 Not understanding race problems
044. Chapter 8. The Go memory model
045. Chapter 8. 59 Not understanding the concurrency impacts of a workload type
046. Chapter 8. 60 Misunderstanding Go contexts
047. Chapter 8. Catching a context cancellation
048. Chapter 9. Concurrency Practice
049. Chapter 9. 63 Not being careful with goroutines and loop variables
050. Chapter 9. 65 Not using notification channels
051. Chapter 9. 67 Being puzzled about channel size
052. Chapter 9. 68 Forgetting about possible side effects with string formatting
053. Chapter 9. 70 Using mutexes inaccurately with slices and maps
054. Chapter 9. 72 Forgetting about sync.Cond
055. Chapter 9. 73 Not using errgroup
056. Chapter 9. 74 Copying a sync type
057. Chapter 10. The standard library
058. Chapter 10. 77 Common JSON-handling mistakes
059. Chapter 10. 78 Common SQL mistakes
060. Chapter 10. 79 Not closing transient resources
061. Chapter 10. 80 Forgetting the return statement after replying to an HTTP request
062. Chapter 10. HTTP server
063. Chapter 11. Testing
064. Chapter 11. 83 Not enabling the -race flag
065. Chapter 11. 85 Not using table-driven tests
066. Chapter 11. 87 Not dealing with the time API efficiently
067. Chapter 11. 88 Not using testing utility packages
068. Chapter 11. 89 Writing inaccurate benchmarks
069. Chapter 11. Not being careful about compiler optimizations
070. Chapter 11.9 90 Not exploring all the Go testing features
071. Chapter 12. Optimizations
072. Chapter 12. Slice of structs vs. struct of slices
073. Chapter 12. Cache placement policy
074. Chapter 12. 92 Writing concurrent code that leads to false sharing
075. Chapter 12. 93 Not taking into account instruction-level parallelism
076. Chapter 12. 94 Not being aware of data alignment
077. Chapter 12. 95 Not understanding stack vs. heap
078. Chapter 12. 96 Not knowing how to reduce allocations
079. Chapter 12. 97 Not relying on inlining Part 1
080. Chapter 12. 97 Not relying on inlining Part 2
081. Chapter 12. 97 Not relying on inlining Part 3
082. Chapter 12. 99 Not understanding how the GC works
083. Chapter 12. 100 Not understanding the impacts of running Go in Docker and Kubernetes
