Concurrency in Go: Tools and Techniques for Developers

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 :) )

Perhaps one of the best books on Go I have read so far. There is little we can call unique in Go but the currency model. It is not like it is particularly novel, but there was a time when not many programming languages offered what Go has had for a while. Although these days, more languages are catching up with the model and offering similar or even more exciting alternatives. So, investing time in learning and gaining an appreciation for the Go concurrency model is something that I found fascinating and very practical. I'm sure I can use this knowledge to understand what other modern programming languages have started to offer as well. This book was wonderful to achieve that goal. The author extensively covers many functional patterns of Go concurrency using goroutines and channels and offers many valuable examples. I immediately applied some of this knowledge to my work, translating many of these concepts into practical applications. So, I can attest the book is instrumental, practical, and fascinating. It is something that I cannot say of every Go book, so I must highlight that, so far, this is my favorite.

Finished 70 pages or so, nice read. Well written, a good survey. Found one mistake in the book: time.Sleep(1) does not mean sleep one second, it's sleeping 1 nano second. Also some of the experiments are not very convincing to me. For example, the experiment that measures OS thread context switch v.s goroutine context switch. The goroutine context switch uses channel to send / recv between two goroutines, I think using the channel could si measured time could significantly impact the measured time. Maybe using a profiler could be more convincing.

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.

I think that this book is an absolute must for any developer. It might be one of the best books that I've read on concurrent patters [ that happens to be written in GoLang ] with clear and concise examples. There are a lot of developers [ I've noticed, personally ] that avoid some of these complex ideas, and I've been looking for a good book on it for a while and stumbled onto this one. I thank the author for helping me understand these complex concepts [ so far - still reading ]. Very very very well done. I'll be buying the author's written work in the future. :-)

This is not the most well written book. The author does not seem to have a strong grasp on who the audience is. She leads off by explaining the basics of concurrency, which is good. Gets pretty deep into the theory. Maybe a bit too deep. Then throws a bunch of code at you with sync groups, locks, mutexes, go routines and channels before explaining what any of those are. And throws a bunch of semi-explained CSP syntax at you, which is great for background, but not something you really need to know. She repeatedly says "don't worry if you don't understand all the details here". A valid technique in teaching things, but she does way too much of this for way too long. I find it really hard to understand what the sample code is even doing without going to other resources to figure out those details. So I'm about 1/3 of the way in and pretty frustrated, but managing to follow along. Hoping that she gets into some actual practical information soon.

Go ist so eine Sache. Sie ist nicht so radikal neu aufgestellt, wie etwa Rust und wirkt vielleicht sogar etwas altmodisch. Allerdings verügt sie über eine Eigenschaft, der sie gegenüber vielen anderen Sprachen heraushebt — Eingebaute Nebenläufigkeit. Mit Go lassen sich parallele Prozesse direkt aus der Sprache heraus instanziieren und mit ihne sicher kommunizieren. Dafür besitzt die Sprache über ein eigene Konstrukte, die es zu meistern gilt. Dieses Buch versucht einen genau dies zu vermitteln und beginnt erst ein Mal mit der generellen Problemstellung von Paralleität und Nebenläufigkeit und vor allen dessen Fallstricken, wie Starvation, Race-Condition, Deadlocks. Es ist sicherlich kein Lehrbuch über diesen Aspekt, die Go-spezifische Stichtweise steht im Vordergrund, aber es baut die Konzepte, Patterns und auch Antipatterns gut auf und ist deswegen sehr zu empfehlen, wenn man den Schatz der Nebenläufigkeit in Go heben will.

The thing that makes Go stand out among programming languages is the way it effortlessly lets you use concurrency in application and helps application scale. This book talks about in detail on how concurrency is implemented in Go. Helps you understand how Go concurrency model works. such as CSP model, M:N model, fork-join model etc. It also teaches on how to avoid concurrency leaking and many more.

Amazing. Compete. Easy to read, understand.

First I was hesitant on buying the book that thin, which I’ve considered a little bit pricey. Nevertheless, decided to give it a try and didn’t regret the decision! Very well structured, shows anti-patterns and the ways to diagnose them, teaches how to test well. Not an easy read at all. Some examples are explaining of what context.Context is without referring to it, which is great. Totally recommend buying this piece.

Mi sono da poco avvicinato alla programmazione in Go, ed è molto chiaro