Slashdot Mirror
Google Go Capturing Developer Interest
angry tapir writes with news that Google Go seems to be cutting a wide swath through the programming community in just a short time since its early, experimental release. While Google insists that Go is still a work in progress (like so many of their offerings), many developers are so intrigued by the feature set that they are already implementing many noncritical applications with it. What experiences, good or bad, have you had with Google Go, and how likely is it to really take over?
I wrote a small utility for detecting duplicate files in Go back when it first came out. I haven't really kept it up to date so I'm not sure if it compiles with the current version.
It's an interesting language. Apart from its lineage, which is interesting and great if you're into Plan 9, it seems to me to be an old-school procedural shot across the bow of the current crop of compiled functional languages (ML, Haskell). It's hard to place the language in any camp, because it does furnish functional programming and object-oriented features without really committing to the dogma of either one. It gives you a ton of interesting features that seem to work really well in concert, but it's also missing some core functionality. I can live without exceptions but I'm not sure I can live without type genericity in this day and age. And a lot of other programmers have their own little nits with it.
Overall, it seems great. But I seldom need code compiled to the machine, and I'm conversant with and fond of the compiled FP languages so I tend to rely on them for these kinds of utilities. I suspect at Google this will eventually become the de-facto language for implementing protocol buffer servers. If and when that happens, the language will have a guaranteed niche for a long time to come, whether or not it wins over hearts and minds outside the giant.
So, what has Go brought to the table?
No, Go doesn't bring anything new to the concurrency table. The two things I've seen about Go concurrency that are regarded as special are M:N/"green" threads and CSP-style channels.
M:N threading is an implementation detail of a language runtime. Whereas the standard library of a language might specify how threads are available to client applications (programs written in the language), it's best left to the implementation (runtime or compiler) to decide how to translate those threads onto the machine. Some implementations might want to focus on scalable, high-performance threading, and so they'd choose M:N. Some others might emphasize simplicity, and map language threads directly to OS threads. What Go has done is standardized this implementation detail into the language specification. (I don't think that's a good idea, but that's a matter of taste.) Other language implementations offer M:N threading, including GHC and (I think) Erlang.
On channels: they're cool. I love them. But there's a lot of prior art here, and many languages have great CSP-style channel libraries written for them that offer the same great flavor of relatively safe message passing and alternation between sets of channels:
In summary, I just don't get what the buzz with Go is about, besides that it's Google's very own language.
Oh whatever, this is news.
There hasn't been a successful new systems programming language since the introduction of C++ almost thirty years ago. Programming language technology has advanced a great deal since then. A new systems language is a very big deal, and Google is playing very fair and open with it.
Quit bitching.
In Capitalist America, bank robs you!
I can't give opinions on all of these (and some are still in development at this time anyway), but here's a list of some languages with paralellism designed in:
Craft Beer Programming T-shirts