Concurrency in Go: Tools and Techniques for Developers

I always swore by Java Concurrency in Practice as a book everyone should read just for learning the general concept. I have now switched to recommending this one. This is a must have for anyone working in Go and has, in a short time, already helped me restructure some of my material I use for mentoring interns, new software engineers, etc.The author's approach is clear, concise and extremely well organized. Some great examples in the book take the time to show a basic approach and how to grow it into well-formed, concurrent process. With that in mind, that is how the book is organized as well: taking a simplistic approach and growing into a much more sophisticated solution. This is the way many excellent high level engineers and architects I know work and how I try to work. There's even some unit testing and benchmarking code in there that helps show how to fit some of the pieces together.The verbose nature of the book allows you get really in-depth. Rather than the copy-and-paste nature of some other books that say "hey, this just how it works... trust me" (regardless of language) the author shows and shares knowledge about how things work. The information is not just presented but also explained along with direct references to Go's internal documentation.I can't recommend this book enough.

This is a very practical book, so this is not a book for you if you are interested in theories behind Go's patterns, general Concurrency topics, deep dives into implementation details, etc.It's close to perfect for me case though. I'm very familiar with concurrency, but not familiar with Go's patterns, and I need to ramp up quickly and start contributing to a distributed system written in Go. This book had almost exactly the right amount of detail to start writing idiomatic concurrent Go.There's a few editing errors, some poor Kindle layouts, but nothing seriously detracting from the content.For the second edition I'd suggest shortening the error handling section (a lot of well-meaning advice there has little to do with concurrency) and add a couple of pages on memory model (where does Go put memory fences, when do we absolutely need to use atomics vs. regular variables are safe, this type of stuff; I found the comments in Go spec hard to parse, would benefit from translation from Google to human language there :) )

This is a short, easy to follow guide on Go's concurrent types (e.g. WaitGroup, Mutex, Cond, Pool, Once) and features (channels, select statements), filled with good examples and the occasional overview of the basic fundamentals (plus a brief intro of the CSP concurrency model) and concepts surrounding the subject matter.Thanks to Go's commitment to software maintainability, all the examples run without modification (though the author uses camelCase in her examples) in the version 1.15.7 of the compiler.I can only complain about the presence of many poorly written parts (English, not code) throughout the book. The editor could have done a better job.

You need to know something about Go to work through the examples in "Concurrency in Go", so I recommend The Go Programming Language by Alan A. A. Donovan and >>>Brian W. Kernighan<<< as your first Go book. After you have worked through chapters 1-7 in The Go Programming Language book, put that book down, and read through this book, "Concurrency in Go", because Go's mechanism for concurrency is simply stunning, and this book does a better job explaining it.The Go mechanisms for concurrency (goroutines, channels, and the Go scheduler) deliver what is arguably the most important feature of Go: its concurrency model. It's not an overstatement to say that, until you understand Go's concurrency model, you don't really understand Go. This book will help you understand and use Go's concurrency model.But, don't take my word for it. Brian Ketelsen of Microsoft, and one of the main organizers of the GopherCon conferences, writes: "Katherine tackles the complex issue of concurrency in Go with depth and style. She covers everything from primitives to patterns with aplomb. Concurrency in Go should be ***required*** reading before putting any concurrent code in production."My emphasis on the word "required" above. This book is truly that important. So, do yourself a favor: buy this book, and The Go Programming Language. Work your way through both books, as I have suggested above. Then, you will really understand Go.

Not knowing Go at all, but having learned and used many languages previously, this book does a great job getting to the root of why Go is so powerful. The author does an excellent job summarizing all the tools Go provides to facilitate concurrency and then explains useful design patterns that engineers can use as they scale. Many great examples are provided along the way to help visualize what the code looks like. Anyone who has proficiency in backend languages and wants to understand why Go is so powerful really should check out this book!