Learn Concurrent Programming with Go

Full disclosure, I reviewed this book while it was still in a draft form. I found the book to be very well organized and logically put together. This book, unlike a lot of other Go books, I would argue is quite applicable to other languages, which makes this book unique. This book, while it certainly leverages capabilities of Go and adheres to best practices of the language, focuses on a topic which is very much language-independent. Sure, implementations will be different and some languages will have features that others don't, but the principles, mechanisms and bugs that are likely to arise transcend languages.There are certainly people out there with strong CS backgrounds, in particular backgrounds in concurrent or parallel or distributed computing who likely won't learn much from this book, but the rest of us mere mortals, I can with fair certainty say, will learn some things from this book. Most people will not be implementing their own concurrency primitives, but it is absolutely essential to understand how they work, why they work the way they do, etc. All programming at this point in our lives involves working with multiple cores and maximizing available compute resources, which typically requires writing software that leverages multiple cores. A lot of research seems to strongly suggest that developers struggle mightily with concurrency and parallelism, and this is an area that's bug-prone and not well covered by good tests that will actually expose races.This is not a beginner book, nor does it aim to be. It assumes certain degree of knowledge and understanding, but at the same time this is a book which I think all developers early in their careers will immensely benefit from. Concurrency and parallelism are topics which we all have to deal with, yet often lack the understanding resulting in less performant implementations, buggy implementations and generally racy code. In my view the author gives the competent reader very solid knowledge that is quite accessible, relevant, applicable and very usable. In summary, this book will help most people become better developers, even if they never undertake implementation of a concurrency tool such as a semaphore, a lock, etc.

So far, I've read the first nine chapters, up to section 9.2.3 on "Fanning in and out". I've enjoyed learning about pipelining with channels. However, I was surprised that the web page and word downloads happen sequentially, slowing down execution. I'm eager to learn how to speed this up using concurrent downloads, which is where the fan-in/fan-out pattern becomes useful.Concurrent Programming with Go is an excellent guide that promotes hands-on learning. It has greatly improved my understanding of Go's concurrency features and their effective use. Whether you're new to concurrency or an experienced Go developer, this book will expand your skills and knowledge. Highly recommended!

This is easily one of my favorite technical books. I was expecting the book to be about Go, but was pleasantly surprised that it was focused on concurrency and just happened to use Go as the implementation language.I like the way the topics and chapters progress to not only get more in depth but also answer the questions and supply the information on what I would naturally want to know next. It's a great book on all manner of concurrency topics showing the ways to approach many different situations. The solutions and reasoning should be relevant for a long time.The graphics and drawings in the book are fun and pleasing to look at. The annotations for the listings are great and highlight the main points making them easy to understand.

This book was great, both as a way to learn Go's concurrency features. However, what I really enjoyed was the more foundational explanations of concurrency idioms and options and showing how these can be built up in Go and how that leads to what is provided by the language. Further, while I've used most of Go's concurrency patterns, there were a couple new or unexplored patterns that I hadn't used yet, and that were explained well by the book. This helped me know of a few additional ways to do things. As others have noted, while there is this foundational material, it is not overly academic and you won't get bogged down by it. It is easy to read, and will hopefully expand your knowledge of both Go's concurrency offerings, and how some of these concurrency primitives are implemented (or could be).

Great book for Go programmers who want to write faster programs! It explains how Go handles multiple tasks at once clearly and step-by-step. You'll learn the best way to use Go's built-in tools for concurrency and avoid common pitfalls. Even for senior engineers, this book offers advanced concepts to take your Go concurrency skills to the next level

"Learn Concurrent Programming with Go" is an excellent resource for developers aiming to enhance their skills in concurrent programming using Go. The book stands out for its clear and straightforward explanation of complex topics. It includes easy-to-follow visuals and relevant examples, making it accessible for developers at various levels. The author, James Cutajar, effectively demystifies concurrency and provides practical knowledge for building concurrency tools like readers/writer locks, semaphores, and thread pools. This book not only improves your Go programming skills but also lays a strong foundation for applying concurrency concepts in other languages, making it a valuable addition to any developer's library.

This book covers the concepts and principles of Concurrency using, in my opinion, the best programming language for the job. Go is a fast, and easy to learn, language with a simple syntax that is on par with JavaScript, C, C#, etc that you can pick up in about a weekend. Then the real fun begins. Learning how to write concurrent programs and applications using Go. If concurrency is an interest of yours look no further than this book.