『100 Go Mistakes and How to Avoid Them』を読む

『100 Go Mistakes and How to Avoid Them』を読む

無料で読める本

**この本は永遠に未完です。筆者の認識がアップデートされる度に加筆・修正されます** この本のモチベーションは、 - アウトプットを通して筆者自身のGoへの理解を深めることです - 『100 Go Mistakes and How to Avoid Them』を布教して日本のGoコミュニティに寄与することです この本には、 - 『100 Go Mistakes and How to Avoid Them』の感想が書かれています - 『100 Go Mistakes and How to Avoid Them』の翻訳・要約は書かれていません(翻訳権・翻案権に配慮しています) この本を読むことで、 - 『100 Go Mistakes and How to Avoid Them』でどのようなトピックスが扱われているかを知ることができます - 『100 Go Mistakes and How to Avoid Them』を読まずにはいられなくなります ===== 『100 Go Mistakes and How to Avoid Them』は、GoogleのシニアソフトウェアエンジニアであるTeiva Harsanyi氏が著し、Manning Publicationsから出版された技術書です。Go言語でよくあるエラーや落とし穴を回避し、生産性を向上させる方法が100個紹介されています。 現在、日本のエンジニアリング業界ではGoエンジニアの需要に対して供給が足りず、Goによる開発実務経験のあるエンジニアの採用にどの会社も苦労していると聞きます。そのため、他言語で経験を積んだエンジニアを採用し、Goエンジニアに再教育するというのが、各社の現実解となっているのではないでしょうか。 当該書籍は、Goエンジニアの教育・成長にとても役に立つはずです。そこで紹介されている”Go Mistakes”ひとつひとつについて私の感想を記していきますので、もし興味をお持ちになりましたら、ぜひAmazonなどで買って読んでみてください。

Chapters
Chapter 01

#1: Unintended variable shadowing を読む

Chapter 02

#2: Unnecessary nested code を読む

Chapter 03

#3: Misusing init functions を読む

Chapter 04

#4: Overusing getters and setters を読む

Chapter 05

#5: Interface pollution を読む

Chapter 06

#6: Interface on the producer side を読む

Chapter 07

#7: Returning interfaces を読む

Chapter 08

#8: any says nothing を読む

Chapter 09

#9: Being confused about when to use generics を読む

Chapter 10

#10: Not being aware of the possible problems with type embedding を読む

Chapter 11

#11: Not using the functional options pattern を読む

Chapter 12

#12: Project misorganization を読む

Chapter 13

#13: Creating utility packages を読む

Chapter 14

#14: Ignoring package name collisions を読む

Chapter 15

#15: Missing code documentation を読む

Chapter 16

#16: Not using linters を読む

Chapter 17

#17: Creating confusion with octal literals を読む

Chapter 18

#18: Neglecting integer overflows を読む

Chapter 19

#19: Not understanding floating points を読む

Chapter 20

#20: Not understanding slice length and capacity を読む

Chapter 21

#21: Inefficient slice initialization を読む

Chapter 22

#22: Being confused about nil vs. empty slices を読む

Chapter 23

#23: Not properly checking if a slice is empty を読む

Chapter 24

#24: Not making slice copies correctly を読む

Chapter 25

#25: Unexpected side effects using slice append を読む

Chapter 26

#26: Slices and memory leaks を読む

Chapter 27

#27: Inefficient map initialization を読む

Chapter 28

#28: Maps and memory leaks を読む

Chapter 29

#29: Comparing values incorrectly を読む

Chapter 30

#30: Ignoring the fact that elements are copied in range loops を読む

Chapter 31

#31: Ignoring how arguments are evaluated in range loops を読む

Chapter 32

#32: Ignoring the impact of using pointer elements in range loops を読む

Chapter 33

#33: Making wrong assumptions during map iterations を読む

Chapter 34

#34: Ignoring how the break statement works を読む

Chapter 35

#35: Using defer inside a loop を読む

Chapter 36

#36: Not understanding the concept of a rune を読む

Chapter 37

#37: Inaccurate string iteration を読む

Chapter 38

#38: Misusing trim functions を読む

Chapter 39

#39: Under-optimized string concatenation を読む

Chapter 40

#40: Useless string conversions を読む

Chapter 41

#41: Substrings and memory leaks を読む

Chapter 42

#42: Not knowing which type of receiver to use を読む

Chapter 43

#43: Never using named result parameters を読む

Chapter 44

#44: Unintended side effects with named result parameters を読む

Chapter 45

#45: Returning a nil receiver を読む

Chapter 46

#46: Using a filename as a function input を読む

Chapter 47

#47: Ignoring how defer arguments and receivers are evaluated を読む

Chapter 48

#48: Panicking を読む

Chapter 49

#49: Ignoring when to wrap an error を読む

Chapter 50

#50: Checking an error type inaccurately を読む

Chapter 51

#51: Checking an error value inaccurately を読む

Chapter 52

#52: Handling an error twice を読む

Chapter 53

#53: Not handling an error を読む

Chapter 54

#54: Not handling defer errors を読む

Chapter 55

#55: Mixing up concurrency and parallelism を読む

Chapter 56

#56: Thinking concurrency is always faster を読む

Chapter 57

#57: Being puzzled about when to use channels or mutexes を読む

Chapter 58

#58: Not understanding race problems を読む

Chapter 59

#59: Not understanding the concurrency impacts of a workload type を読む

Chapter 60

#60: Misunderstanding Go contexts を読む

Chapter 61

#61: Propagating an inappropriate context を読む

Chapter 62

#62: Starting a goroutine without knowing when to stop it を読む

Chapter 63

#63: Not being careful with goroutines and loop variables を読む

Chapter 64

#64: Expecting deterministic behavior using select and channels を読む

Chapter 65

#65: Not using notification channels を読む

Chapter 66

#66: Not using nil channels を読む

Chapter 67

#67: Being puzzled about channel size を読む

Chapter 68

#68: Forgetting about possible side effects with string formatting を読む

Chapter 69

#69 Creating data races with append を読む

Chapter 70

#70 Using mutexes inaccurately with slices and maps を読む

Chapter 71

#71 Misusing sync.WaitGroup を読む

Chapter 72

#72 Forgetting about sync.Cond を読む

Chapter 73

#73 Not using errgroup を読む

Chapter 74

#74 Copying a sync type を読む

Chapter 75

#75 Providing a wrong time duration を読む

Chapter 76

#76 time.After and memory leaks を読む

Chapter 77

#77 JSON handling common mistakes を読む

Chapter 78

#78 Common SQL mistakes を読む

Chapter 79

#79 Not closing transient resources を読む

Chapter 80

#80 Forgetting the return statement after replying to an HTTP request

Chapter 81

#81 Using the default HTTP client and server を読む

Chapter 82

#82 Not categorizing tests を読む

Chapter 83

#83 Not enabling the race flag を読む

Chapter 84

#84 Not using test execution modes を読む

Chapter 85

#85 Not using table-driven tests を読む

Chapter 86

#86 Sleeping in unit tests を読む

Chapter 87

#87 Not dealing with the time API efficiently を読む

Chapter 88

#88 Not using testing utility packages を読む

Chapter 89

#89 Writing inaccurate benchmarks を読む

Chapter 90

#90 Not exploring all the Go testing features を読む

Chapter 91

#91 Not understanding CPU caches を読む

Chapter 92

#92 Writing concurrent code that leads to false sharing を読む

Chapter 93

#93 Not taking into account instruction-level parallelism を読む

Chapter 94

#94 Not being aware of data alignment を読む

Chapter 95

#95 Not understanding stack vs. heap を読む

Chapter 96

#96 Not knowing how to reduce allocations を読む

Chapter 97

#97 Not relying on inlining を読む

Chapter 98

#98 Not using Go diagnostics tooling を読む

Chapter 99

#99 Not understanding how the GC works を読む

Chapter 100

#100 Not understanding the impacts of running Go in Docker and Kuberne

Author
Yuki Bobier Koshimizu
Topics
¥0今すぐ読む
公開
本文更新
文章量
45,745
価格
0