100 Go Mistakes and How to Avoid Them

Wish I had picked this up and read it earlier, full of great insights that experienced golang developers will already be familiar with, but with explanations to cement home why we are doing these things.

THIS BOOK AND "GO IN PRACTICE" ARE THE BEST GOLANG BOOKSWhen this began, i programmed in assembly then C. I never used the C++ additions because i couldnt trust or debug unknown inheritances. Go is improved C and compiles.This book has clear detailed explanations using actual lines of code that compile and run.if you want to download the source code instead of copying it from the book, manning supplies it by telling you to enter the code on two named pages. i thought there were no codes on the given pages but there were in a micro font, running vertically from the bottom of the page in the inseam.

Recently landed a gig working in Go, this book is a great companion read clearing up “gotchas” and providing insight to idiomatic go standards.While reading I’m able to look back at my code and recognize areas of improvement and optimization.I’m about halfway through the book and I’m extremely glad I purchased it. Writing Go code is easy, but not simple. There are a ton of misconceptions and feature oversights.Imo, it’s a must read for any developer looking to write production quality code in Go; especially if you already know other languages.Buy this book prior to “The Go Programming Language” book; the roi on time is huge.

Good book and does cover a lot of ground. There is something for everyone, and certainly a lot for most practicing programmers. But because the book tries to talk about mistakes, it needs to invert the tone when talking about best practices - makes for a drawl of a read at times. Still good.

A must read for all Go developers!

Helpful and interesting–not much filler at all. The only nit is probably that there aren't really 100 mistakes: the latter sections of the book become less about mistakes and more about not missing out on good approaches to Go code. All good, though.I've been a software developer for 20 years started using Go in 2015.

Go has the reputation of being easy to learn at first, and then it quickly becomes tough to master. What I like best about "100 Go Mistakes" is that it (1) presents a rich collection of Go "gotchas" and (2) explains and illustrates how to fix them and avoid them in the future. The author also correctly notes that "making mistakes is part of the learning process," and "[w[hat matters, in the end, is our capacity to learn from them." Some of the 100 mistakes are beyond my current experience or involve coding situations that likely may not pop up on my radar any time soon. Still, I have learned some good and worthwhile things from this book, and I recommend it for intermediate (and more experienced) Go developers. My thanks to Manning for sending a review copy.

The best book for intermediate Go devs so far

This is one of those very rare technical books that's genuinely insightful and truly well written. That combination makes it a page-turner: you want to keep reading because every page teaches you something.Don't be mislead by the title. There are 100 mistakes and how to avoid them, but a title like "Deep Go that Every Professional Go Programmer Must Know" would be accurate, too (but not as catchy).One particularly great aspect of this book are the examples. Harsanyi mentions in the preface that "It took me almost 2 years and countless iterations to frame each of these 100 mistakes alongside meaningful examples and multiple solutions where context is key." Crafting examples that are concise yet accurate, digestible yet informative, is difficult and time-consuming. They can make or break a book; in this case, they make it.Last thing: these are not obscure mistakes or examples that bear little resemble to reality. I've been programming Go at scale since v1.1, and I've seen all these mistakes, too. This book really is required reading for Go programmers.

Go is easy to learn, but hard to master. You used to need years to make all the common mistakes people make before you could be confident in your skills. Fortunately, there's now a book that can save those years of trials and errors.This book reminds me of "JavaScript: the Good Parts" . Yes, JS is a horrible language compared to others, there be dragons everywhere and you need to be vigilant, but millions of people made a career out of it. Go is not as bad, but it's not tremendously safe language either. And that's by design. Go promotes simplicity and pragmatism and I learned to love that. If that's your thing, I hope you get this book to make that journey easier.

This book focuses on the language specification, standard library, and standard toolset of the Go programming language. It does not cover topics such as web servers or gRPC, but it complements the book "The Go Programming Language" and covers fundamental concepts that all Go developers should know. It can be considered as the equivalent of "Effective Java."Any mistakes mentioned in this book are likely to have been experienced by developers who have worked with the Go language. It also includes explanations of concepts that, if known from the beginning, would make understanding existing code easier. Additionally, it covers many topics that are not extensively explained in other books.However, please note that there are many minor errors in the book, so if you can read Japanese, I recommend the Japanese version that I have translated.

This is an absolute must-have for any Go dev.