CSP style concurrency in Go is the killer feature in Go. It makes 
concurrent programming so much easier. To understand this you need to have 
done some years of concurrent programming using asynchronous calls, 
threads, locks, semaphores and all that stuff. I have done that and I can 
say that CSP style programming in Go with the use of channels makes 
concurrent programming much much easier. Much easier to get things right 
from the beginning, much easier to fix things. I have actually spent years 
fixing other people's and my mistakes causing race conditions and 
deadlocks. People who have not experienced this have no considerable 
experience in concurrent programming and don't know what they are talking 

You have to mention that green threads (aka goroutines) are not preemptive, 
though. This is what you have to pay for what you get for the ease of 
concurrent programming using CSP. For many applications this is a very good 
trade-off. All the server-side applications written in Go confirm this.

Am Dienstag, 8. August 2017 08:01:12 UTC+2 schrieb snmed:
> Hi Gophers
> I stumbled over a nice and very interesting Blog entry "Go channels are 
> bad and you should feel bad 
> <http://www.jtolds.com/writing/2016/03/go-channels-are-bad-and-you-should-feel-bad/>"
> , I would like to hear some opinions about that article
> from seasoned go developers. Because I just used go for a couple of months 
> for my private web projects and rarely get in touch with channels.
> By the way, that article is not a rant and the author likes go very much 
> as far as I can conclude from the article.
> Cheers snmed

You received this message because you are subscribed to the Google Groups 
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to golang-nuts+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to