Read here: Concurrency in Go

Book Rating : 8/10

Overall, I think this is a great book to read if you are coming from a different language. It's a good fundamental because it holds good meat about the internal operations within the language itself, instead of just telling you what syntax to use and calling it a day.

Coming from Java, the concepts differ quite heavily from the Spring Boot convention of writing @Async('threadPoolTaskExecutor') while declaring a pool for the concurrent tasks to run. Go feels much more direct. You are introduced to the primitives more plainly, so the mental model is less about framework convention and more about how the concurrent work is actually being coordinated.

The early chapters do a good job introducing the building blocks: goroutines, channels, and synchronous mutexes. That part was important for me because it slowly paints the bigger picture of how concurrent processes work at scale instead of trying to act smart too early.

The programming paradigm in this book is also mildly refreshing to understand. Coming from a Java background, I honestly think this book should still be read even if you are not writing any Go code, because it gives an interesting perspective on how other languages are handling concurrency.

Another thing I liked is that the book does a great job describing anti-patterns in premature optimization when you are trying to write "Best practice" code. It gives a fairly reasonable "trust me bro" basis with the Go runtime, which I actually appreciated. Sometimes that is enough when the point is to help you build the correct intuition first before disappearing into runtime rabbit holes.

A notable shout from me is Chapter 4, where it mentioned a section about error handling that I really enjoyed. From where I was coming from, asynchronous processes were usually either thrown all the way to the caller or failed silently. But in this section, in line with Go's programming paradigm of error handling, it breaks down a simple example of how concurrent errors should be handled.

Although I would have loved to see an example of fail-fast error handling where any goroutine giving the first error immediately stops the rest, that is more of a nitpick from me than an actual complaint. I also skimmed through some topics like work stealing in the Go runtime and healing unhealthy goroutines, but overall most of the content was interesting to me and I greatly enjoyed the book.

That said, if you have already been writing Golang for enterprise applications for more than a year, I don't think this book will be very beneficial to you. But if you are transitioning into Go from another language, I think it is absolutely worth the read.