News for hackers. Stuff that matters.
Re:Why Go is doomed to succeed by aaggarwal on Saturday June 13, 2015 @12:27PM (#9711492)
I have never used Go before. From the sound of it, it looks like Go hits a sweet spot between C and Java? and of course the Google support is a major factor for a possible success.
Re:Why Go is doomed to succeed by vezzy-fnord on Saturday June 13, 2015 @12:58PM (#9711639)
Not quite. To understand Go, you need to understand the history of the Bell Labs gurus somewhere around the late 9th and 10th editions of Research Unix, when the vestiges of what would become Plan 9 and Inferno began to take shape (the sam editor that would influence acme, the rc shell, mk and the predecessor to 9P [streams] would all originate here - see "Interprocess Communication in the Ninth Edition Unix System" [1]).

Meanwhile, Rob Pike and his contemporaries did language research, particularly related to the semantics of CSP-style concurrency. Syntactically they were all C-like, as the Plan 9/Research Unix community all generally liked it.

Newsqueak was the first and it was a cross between C and with special syntax and semantics for procs (green threads). It was written for GUI workstation environments in mind, the idea being to easily build multi-seat applications. From Newsqueak arose Alef, which refined on it but had manual memory management. Then from Alef came Limbo, the language running on top of the Dis VM that formed the core of the Inferno OS.

Fast forward some years later, Rob Pike and some other Bell Labs vets are at Google. Some event happens which painfully reminds them of mediocrity in computing, that gives them the drive again and they resume right where they left from Limbo.

Go is born.

[1] http://cm.bell-labs.co/who/dmr/ipcpaper.html

Re:Why Go is doomed to succeed by tptacek on Saturday June 13, 2015 @01:15PM (#9711701)
I feel like "bringing CSP into a modern language" gave Pike's team social permission to launch Golang, but the parent comment is closer to the truth than this summary.

According to Pike's blog, the real motivating factor for Golang was how forbidding and painful Google's C++ build process was. A lot of Golang makes more sense if you look at it through this lens: above all else, don't be like C++.

Re:Why Go is doomed to succeed by pcwalton on Saturday June 13, 2015 @01:23PM (#9711752)
> According to Pike's blog, the real motivating factor for Golang was how forbidding and painful Google's C++ build process was. A lot of Golang makes more sense if you look at it through this lens: above all else, don't be like C++.

You and I disagree in regards to a lot about Golang, but I think you're spot-on here. I've thought for years that it was interesting how yosefk's criticisms of C++ in the "Frequently Questioned Answers" directly correspond to decisions in Golang: "compile times are long" → "use the Plan 9 toolchain", "memory management is difficult and unsafe" → "garbage collection", "templates are a mess" → "no generics", "exceptions interact badly with RAII" → "no traditional exceptions", "header files are a pain" → "use packages and forbid circular dependencies", etc.

Re:Why Go is doomed to succeed by tptacek on Saturday June 13, 2015 @01:25PM (#9711765)
Oh, wow. I love the C++ FQA (I'm a C++ refugee, from the nadir of C++, when Alexandrescu's book had just come out and template error messages were still 10 pages long).

I never though to evaluate Golang against it. Great point.

Re:Why Go is doomed to succeed by pron on Saturday June 13, 2015 @04:24PM (#9712503)
Why do exceptions interact badly with RAII?
Re:Why Go is doomed to succeed by pcwalton on Saturday June 13, 2015 @04:36PM (#9712551)
You have to think carefully about how to clean up your object if something throws during its constructor, and throwing an exception in a destructor can lead to your program aborting if that destructor was called as a result of another exception being thrown.

Note that I don't think banning exceptions is really the answer; in particular, the destructor issue is just a specific case of "handling errors during finalization is really hard", and you can't get away from finalization in general. Exceptions really put those issues front and center, though.

Re:Why Go is doomed to succeed by pjmlp on Sunday June 14, 2015 @03:58AM (#9714124)
Although I would say that is a C++ problem, many other languages with exception support do enjoy more sane models than C++.
Re:Why Go is doomed to succeed by pron on Sunday June 14, 2015 @12:12AM (#9713691)
Oh, exceptions during construction/destruction, right. I don't think Go addresses that at all. Go's defer is just like a finally block, and panics can happen at any time.
Re:Why Go is doomed to succeed by vezzy-fnord on Saturday June 13, 2015 @01:24PM (#9711753)
According to Pike's blog, the real motivating factor for Golang was how forbidding and painful Google's C++ build process was.

Yes, that was the "spark" that motivated it, as I hinted it.

A lot of Golang makes more sense if you look at it through this lens: above all else, don't be like C++.

"Don't be like C++" is pretty much a side effect behind much of the Bell Labs and Research Unix philosophy that values composable byte stream interfaces and liberally using a small number of abstractions.

The historical context behind Go that I wrote about is quite undeniable, though. I feel that you're being a tad too contrarian here, but I'd love to know more from your viewpoint.

Re:Why Go is doomed to succeed by tptacek on Saturday June 13, 2015 @01:29PM (#9711778)
I guess my point is pretty simple: Golang could have succeeded at its core task without channels and "select", but could not have succeeded without an ultra-fast toolchain and a carefully designed standard library that nurtured an idiom of composable APIs defined by nothing more complicated than structs.

Having native CSP gives Golang a differentiator that it would not so clearly have without it. People can disagree about toolchain quality, and for every person that appreciates a well designed stdlib, there are 3 that appreciate CPAN more. It's harder to disagree with a facility that few mainstream languages provide in any form. So CSP is very important to Golang's identity.

It's just not the "why" of Golang (or at least, I don't think it is.)

Re:Why Go is doomed to succeed by vezzy-fnord on Saturday June 13, 2015 @01:42PM (#9711840)
You seem to be analyzing this from a more economic approach, whereas I'm leaning to the historical. I think I can incorporate your position, but I feel as though you undermine the role of CSP. You see it as a "differentiator", whereas I see it as a central research interest of Rob Pike's that permeated all his previous languages and naturally had to make it into Go, as well.

See this excerpt from the Alef reference manual [1]:

        chan(Mesg) keyboard, mouse;

        Mesg m;

        alt {

        case m = <-keyboard:

		/* Process keyboard event */

		break;

	case m = <-mouse:

		/* Process mouse event */

		break;

       }
Now where the toolchain is concerned, again that was adapted from the Plan 9 compiler collection (which even OpenBSD at one point was considering but backed off due to licensing) which makes cross-compilation a surprising breeze.

Carefully designed standard library? Plan 9's syscall interface...

Composable APIs defined by one key abstraction? Plan 9 syscalls again, though there it was 9P.

Speed was a motivator, but again - direct side effect of the "5 Principles of Programming" espoused by Rob Pike [2].

[1] http://doc.cat-v.org/plan_9/2nd_edition/papers/alef/ref

[2] http://users.ece.utexas.edu/~adnan/pike.html

Re:Why Go is doomed to succeed by RogerL on Saturday June 13, 2015 @04:03PM (#9712424)
So, I'm curious. I know how data driven Google is - have they done studies on whether Go met its goals w.r.t C++ development?
Re:Why Go is doomed to succeed by fao_ on Saturday June 13, 2015 @02:54PM (#9712137)
CSP == Continuation Style Passing or?
Re:Why Go is doomed to succeed by vezzy-fnord on Saturday June 13, 2015 @02:59PM (#9712161)
Communicating Sequential Processes.
Re:Why Go is doomed to succeed by fao_ on Sunday June 14, 2015 @05:50AM (#9714355)
Ah, thank you.
Re:Why Go is doomed to succeed by gvickers on Saturday June 13, 2015 @03:05PM (#9712189)
Communicating sequential processes
Re:Why Go is doomed to succeed by thisrod on Sunday June 14, 2015 @09:46PM (#9717068)
Re:Why Go is doomed to succeed by r0naa on Saturday June 13, 2015 @01:02PM (#9711654)
That was very insightful, thank you for sharing!
Re:Why Go is doomed to succeed by pjmlp on Sunday June 14, 2015 @03:56AM (#9714121)
You missed out the Oberon-2 influence on method declaration syntax. :)
Re:Why Go is doomed to succeed by 0xdeadbeefbabe on Saturday June 13, 2015 @08:06PM (#9713257)
To be fair, there is still mediocrity left in computing.
Re:Why Go is doomed to succeed by Elrac on Saturday June 13, 2015 @12:40PM (#9711559)
"Between C and Java" hits it very well, I'd say.

When I jumped ship from C to Java, Java's object orientation wasn't exciting to me, and its exception handling is an acquired taste.

But dynamically growable, garbage collected buffers are something I'd missed for a long time. And the simple ability to concatenate strings without first reserving space for the result. Oh, and hash maps! Remarkably versatile data structures, those.

Coming from C, Java was a delight. Java would have a lot more trouble dragging me away from Go.

Re:Why Go is doomed to succeed by xamuel on Saturday June 13, 2015 @05:27PM (#9712731)
>And the simple ability to concatenate strings without first reserving space for the result

Not exactly the same thing, but routine string manipulation in C gets considerably easier once you discover a highly underrated function called asprintf (basically combines sprintf and malloc, calculating the buffer size for you).

Re:Why Go is doomed to succeed by Elrac on Saturday June 13, 2015 @08:23PM (#9713303)
Woo hoo, thanks for the tip!

But I still need to worry about creating a memory leak with this. :(

Re:Why Go is doomed to succeed by Merovius on Sunday June 14, 2015 @04:38AM (#9714227)
Also, asprintf is a GNU-extension, so if you want to write portable code, it's a no-go (as for everything usefull in C).
Re:Why Go is doomed to succeed by Elrac on Sunday June 14, 2015 @10:16AM (#9714980)
Thankfully, I'm not doing much C any more. Those hoity-toity hand-holding languages have spoiled me, and now I don't want to be bothered about memory management and other "trivia." :)
Re:Why Go is doomed to succeed by pjmlp on Sunday June 14, 2015 @04:01AM (#9714128)
Not in ANSI C nor POSIX.
Re:Why Go is doomed to succeed by okasaki on Saturday June 13, 2015 @03:17PM (#9712232)
Well, C++ has all of that.
Re:Why Go is doomed to succeed by Elrac on Saturday June 13, 2015 @03:58PM (#9712402)
Only for small values of "all." The magic of concatenation and auto-conversion of strings that's baked into the Java compiler and, to a lesser extent, the Go compiler, is missing in C++ - not vital but convenient. Similarly, hashmaps, while built directly into the language in Go, are a library class in C++. Finally, garbage collection will likely never be part of C++.
Re:Why Go is doomed to succeed by klibertp on Saturday June 13, 2015 @07:54PM (#9713226)
What do you mean by "the magic concatenation and auto-conversion of strings"?

Also, having a map implemented in a library is a Good Thing. It means that your language is extensible and expressive enough for this. AFAIK Go is - by design - not that extensible.

Re:Why Go is doomed to succeed by Elrac on Saturday June 13, 2015 @08:31PM (#9713320)
Magic concatenation: the "+" operator is understood by the compiler to be the concatenation operator if either operand is a String. "Magic" in the sense that it's an exceptional affordance made by the language (not the library) for this one data type and operator.

Auto-conversion: "2" + 5 = "25". This looks horribly hackish, like some type buggering perl might do, or js. But it comes in handy when you want to build a message string.

And yes, as the article tells us, a lot of things are very purposely left out of Go, which has advantages and disadvantages like most trade-offs.

Re:Why Go is doomed to succeed by okasaki on Sunday June 14, 2015 @02:18AM (#9713917)
Magic concatenation:

        string hello = "hello";
        string world = "world";
        string hw = hello + ' ' + world;
Auto-conversion:

        stringstream ss;
        ss << "2 + 2 = " << 2 + 2 << endl;
        string result = ss.str();
Re:Why Go is doomed to succeed by Elrac on Sunday June 14, 2015 @04:29AM (#9714204)
1 point for "magic concatenation;" I wasn't aware that works!

"nice try" on "auto-conversion".

Re:Why Go is doomed to succeed by reagency on Saturday June 13, 2015 @06:15PM (#9712905)
The main problem of C++ is that it has far too large values of "all".
Re:Why Go is doomed to succeed by pjmlp on Monday June 15, 2015 @08:49AM (#9718960)
Which is still too less when compared with Java, CPAN, Gems, .NET....
Re:Why Go is doomed to succeed by danieldk on Sunday June 14, 2015 @04:23AM (#9714188)
Similarly, hashmaps, while built directly into the language in Go, are a library class in C++.

And this is a problem because?

(It's actually a weak point of Go that you cannot define them in a library without sacrificing type safety.)

Re:Why Go is doomed to succeed by Elrac on Sunday June 14, 2015 @04:30AM (#9714209)
I didn't say it was a problem. I was objecting to "C++ has all that."
Re:Why Go is doomed to succeed by danieldk on Sunday June 14, 2015 @04:51AM (#9714244)
Ah, but the standard library (including unordered_map) is part of the C++11 standard.
Re:Why Go is doomed to succeed by pjmlp on Sunday June 14, 2015 @04:03AM (#9714134)
> Finally, garbage collection will likely never be part of C++.

C++11 has a GC API defined.

Reference counting is part of any GC book in CS speak.

Re:Why Go is doomed to succeed by wyager on Sunday June 14, 2015 @04:07AM (#9714147)
There are a large number of people who would strongly disagree with the claim that implicit casting is a good thing.
Re:Why Go is doomed to succeed by Elrac on Sunday June 14, 2015 @04:35AM (#9714216)
Absolutely, and it's something I consider somewhat of a liability in (e.g.) Scala. You can drive yourself crazy if you're not careful.

However, I feel that doing the "implicit casting" thing only for the single, limited case of string concatenation strikes a happy medium between providing useful convenience and giving you enough rope to hang yourself with.

Re:Why Go is doomed to succeed by okasaki on Saturday June 13, 2015 @04:35PM (#9712549)
It has garbage collection through shared_ptr.
Re:Why Go is doomed to succeed by albinofrenchy on Saturday June 13, 2015 @08:24PM (#9713304)
Not sure if you are serious but the hard part of gcs is resolving and identifying cycles. Cycles with shared pointers are just leaks.
Re:Why Go is doomed to succeed by threeseed on Saturday June 13, 2015 @08:16PM (#9713290)
Exception handling may be an acquired taste.

But it is infinitely better tasting than Go's ridiculous error handling which is something you would expect in the 1980s.

Re:Why Go is doomed to succeed by masklinn on Saturday June 13, 2015 @12:42PM (#9711563)
> it looks like Go hits a sweet spot between C and Java?

If your sweet spot is 90~95% java and 5~10% C.

Re:Why Go is doomed to succeed by aaggarwal on Saturday June 13, 2015 @12:50PM (#9711597)
That's not really my sweet spot, but if it have such a strong inclination towards Java, then would it be much easier for Java programmers to move to Go compared to C programmers?

And, what about python programmers, how would Go be for them?

Re:Why Go is doomed to succeed by dsymonds on Saturday June 13, 2015 @12:57PM (#9711628)
Any decent programmer should be able to switch between {C,Java,Go,Python} without too much difficulty. They each have their own differences and learning curve, but as long as a programmer doesn't identify themselves too tightly as a specific language developer (e.g. some people say "I'm a Java programmer", implying they couldn't possibly learn something else) then it's not hard to pick up Go.
Re:Why Go is doomed to succeed by eropple on Saturday June 13, 2015 @01:40PM (#9711825)
I think that's reductive. I'm a "decent programmer". (I think I'm a little better than that, if I'm being honest.) I regularly use Ruby, Scala, C#, and enough bash to choke a horse. Some C++ too, when I have to, but it's not something I ever want to touch.

I can't deal with Go. And I don't think it's me--I don't do Haskell because of me, I don't do Go because of it. I find it almost impossible to think in Go. I find it incredibly primitive, well past the point of "stupid code is impossible to misunderstand" and into "stupid code because the language demands it." This wouldn't bother me, in a very "you do you" sense, if I wasn't stuck debugging faddishly-designed tools like Docker and Terraform written in it. To this end I think Go is a regression for the open source community, because what I see as veneration of stump-dumb languages makes it harder, not easier, to be smart about problems.

Re:Why Go is doomed to succeed by danieldk on Saturday June 13, 2015 @02:01PM (#9711908)
I find it incredibly primitive, well past the point of "stupid code is impossible to misunderstand" and into "stupid code because the language demands it."

Since the parent mentioned C and Java. What are you missing in Go compared to Java besides generics? What are you missing in Go compared to C besides manual memory management?

To me, Go seems to have about the same amount of expressiveness as C and Java. The difference being that it's safer than C and more UNIXy/less OO than Java.

To this end I think Go is a regression for the open source community, because what I see as veneration of stump-dumb languages makes it harder, not easier, to be smart about problems.

A lot of open source UNIX software was written in C. To me it seems that if C was acceptable, Go is acceptable (if the application can live with a GC and slightly lower performance). And as the article argues, it lowers the bar for contribution, because it restricts overengineering.

Re:Why Go is doomed to succeed by eropple on Saturday June 13, 2015 @04:02PM (#9712418)
> Since the parent mentioned C and Java. What are you missing in Go compared to Java besides generics?

That's a clever way to attempt to constrain the conversation away from the elephant in the room. "Other than the bullet in your stomach, how are you feeling?"

Not having at least Java-style "dumb" generics, in 2015, is unacceptable; the existence of `go generate` should mortify everybody involved with Go. Not having better than that--consider what you can do with Scala even before you get to something like Shapeless--is not quite unacceptable but short-sighted and limiting because suddenly I as a human have to do what a moderately smart compiler can do around type checking and leveraging types to solve problems.

Go's general ignorance, and the community's general ignorance, to really basic functional programming that so hugely improves your life is probably borne out of the stupid type system; things like composition (Try monads) for error handling, so I'm not vomiting `if err != nil` everywhere, things like functional transforms for data structures so I'm not writing for loops until my eyes bleed. And you can't really do that in a statically typed language without either blind casts (which Go partisans recommend, because clearly everything should be `interface {}`, remember the days when java.util.ArrayList just gave you Objects?) or generics.

It's just...dumb, written for the lowest common denominator, and I guess the lowest common denominator is dishearteningly low. Good for them, but having more and more core tools written in this junk makes my job a lot harder because it obfuscates potential problems under a sea of boilerplate and line noise.

> To me, Go seems to have about the same amount of expressiveness as C and Java.

I agree with that assessment. Go's roughly equivalent in expressiveness to Java.

That is a criticism, not a defense.

Go being a somewhat more terse Java 1.4 is not an endorsement of the language or the environment. I stopped using Java quite some time ago because my frustrations with "coding with gloves on" outstripped any benefits of the language. (Not the virtual machine. The JVM is fantastic, I love using it. But Java-the-language is Newspeak: if I can't coherently describe a solution in its syntax and semantics, I have to resort to worse solutions. Go's actually worse for this, surprisingly enough...)

Michael O. Church discusses the problems of Java and the problems if the Java shop very well in one of his articles, and in my experience the Go people I have worked with and talked to almost universally fit into that mold (echoing the normal Java ignorance of the outside world, a neat sense of epistemic closure, and the weird desire to rewrite the world into it).

https://michaelochurch.wordpress.com/2012/04/13/java-shop-po...

> if C was acceptable, Go is acceptable

Should C be acceptable? I don't think so. C is, in 2015 and in truth in 2000, too stupid to live. For a very long time we had no other alternatives, and it is an effective lingua franca because it's dumb enough that you can knock out a language binding in short order, but it's a bad language. No memory safety, no type safety (seriously, just review the rules for implicit pointer casting, you have no types to speak of), and nothing, anywhere, to help you not do things that are damaging.

Like, I'm not a C++ fan because it has many warts and creeping features, but if you literally limit yourself to C with classes, std::string/std::vector, and use pointers only in a last resort (preferring references), you have just solved probably eighty percent of the correctness and security problems caused by our reliance on C. (And you cannot practically implement many of those solutions in C without a level of developer discipline that essentially does not exist in the wild. Just having ctors/dtors is literally transformative to writing safe, smart code.)

Rust will solve more, better, and I'm a huge fan of what they're trying to do, but isn't there yet.

> And as the article argues, it lowers the bar for contribution, because it restricts overengineering.

That's an argument. I'd say that it restricts engineering. Which is not a fatal flaw of a tool, there are lots of problems where grunting and bashing your way through it makes sense, but engineering problems often require being able to actually write what you mean, not write what you need to address the symptoms of the inexpressive language before you get to write what you sort of mean if you squint through the garbage it forces upon you.

Lowering the bar for contribution is only a plus if it doesn't moronize people who are cool with clearing a higher bar. For most of the stuff that I deal with, four novices don't replace one expert. When using Go, I very strongly feel that I can't do my job intelligently because I don't have the tools, and so not only will I do my job more slowly, but I increase the likelihood of doing my job wrong.

Re:Why Go is doomed to succeed by taeric on Sunday June 14, 2015 @01:57AM (#9713875)
This just seems to hit all of the highlights of the "I tried liking your viewpoint, but you are ultimately stupid" manner of rhetoric. You even give praise to the JVM.

For every post like this that has me starting to think "hell yeah, C is really stupid, how can others not see this?" I'm reminded of why Linus Torvalds is glad he didn't choose c++ for git. And... it resonates too bloody well. Especially when I consider all of the ports to other languages that have been attempted for git.

I think it comes down to generalities. The reality is most programs are doing good if they solve one problem. Not just solve it well, but solve it at all. Many algorithms, on the other hand, can be widely adopted.

This leads one to think they could "write with their gloves off" and nail down that algorithm in such a way that it will be usable everywhere. The reality, though, is that it rarely (ever?) works out. What you find is that all of the small corner cases that matter in solving something come back and bite you. Hard.

Re:Why Go is doomed to succeed by danieldk on Sunday June 14, 2015 @04:49AM (#9714239)
tl;dr: Go is a dumb language because it does not provide enough abstraction. (Or with the underlying tone: Go users are just to dumb to understand superior languages.)

I agree and disagree with all your points. I have written C++ and Prolog professionally for years, then some Java (because employer), with a little Haskell on the side (hobby projects).

I am in a bind when it comes to PLs. I prefer the abstraction of C++ and Haskell (or Prolog for the domains where it fits). On the other hand, it is easier in powerful languages to get complete mismatches between the level of abstraction and the abstractions that are used. To take three widely-used C++ libraries as an example:

- Boost: highly template and template meta-programming driven.

- Qt: basically C++ as C with classes, with moc for signals. Really only templates for collections.

- Xerces/XQilla: 90ies style C++ with global state, and too many Java SingletonFactoryProxies.

In projects where you use different dependencies with different styles, things can get ugly. Also, your policy-based design may not be understandable to your 'C++ is C with classes' colleagues/contributors.

In the end there will always be interaction between expressiveness and maintainability/accessibility. The right abstractions can improve both. Too much magic (page-long type signatures, too many levels of templated indirection, etc.) can make everyone's lives miserable. The graveyard of ugly C++ libraries shows that finding the right abstractions can be hard, even for experienced programmers.

Re:Why Go is doomed to succeed by ngrilly on Sunday June 14, 2015 @11:52AM (#9715298)
I agree with you that the lack of generics is a weakness of Go. Even Rob Pike agrees [1]. But some of your arguments are just plain wrong:

- `go generate` was never designed as a way to bring generics to Go.

- Most Go programmers are not "ignorant of basic functional programming". They use FP in other languages, and even in Go which has first-class functions, higher-order functions and closures. But it's true that the lack of generics severely limits the usage of FP techniques in Go.

- Go partisans don't "recommend" to stuff everything in interface{} and use "blind" type assertions everywhere. They even recommend the contrary. Give me a link to the Go official documentation that recommends that and I'll revisit my position.

To be clear, just like you, I sometimes miss generics in Go, especially when I'd like to use some FP techniques. But for me, it's just an inconvenience. It sounds like for you it's a showstopper and I understand that. But I don't think that using words like "junk", "stupid" or "dumb" helps in making your point.

I hope, and I'm confident, that the Go team will find a way to add some form or type parametricity that fits well with the overall language.

[1] http://blog.golang.org/slices

Re:Why Go is doomed to succeed by eropple on Sunday June 14, 2015 @07:45PM (#9716742)
> `go generate` was never designed as a way to bring generics to Go.

Unix was designed to port Spacewar. What's that got to do with anything?

> Most Go programmers are not "ignorant of basic functional programming".

That doesn't match my experience. The overwhelming majority of Go people I know, and the loudest advocates to whom I am exposed, seem to regard functional programming as a nothing. Your experience may differ.

> Go partisans don't "recommend" to stuff everything in interface{} and use "blind" type assertions everywhere.

Again, that doesn't match my experience; this was literally recommended to me by a senior-level Google engineer. To his credit, he suggested instead using `go generate` as an alternative. (Because that's better. =/ )

> I don't think that using words like "junk", "stupid" or "dumb" helps in making your point.

Completely fair criticism. But let me put it this way: I view Go, and the terminally blinkered Rob Pike, and his disciples, to be so obviously and monstrously disastrous to what I do for a living that those were the remains after a pretty heavy dose of editing and self-censorship.

I could tell you how I actually feel if you'd like. =)

Re:Why Go is doomed to succeed by atilaneves on Sunday June 14, 2015 @01:07AM (#9713778)
This is probably the best comment I've ever seen on HN.
Re:Why Go is doomed to succeed by dsymonds on Saturday June 13, 2015 @01:58PM (#9711899)
That wasn't what I was replying to. aaggarwal was asking how easy it was to move to it. I was saying that it's easy. If you find it too primitive, well, that's a fair opinion, but it's still easy to move to. I think it's hyperbole to claim that you can't work in it.
Re:Why Go is doomed to succeed by eropple on Saturday June 13, 2015 @03:35PM (#9712308)
No, something that's as primitive as Go is quite hard to move to. I understand the language, but I can't think in it and so using it is very far from easy.
Re:Why Go is doomed to succeed by tptacek on Saturday June 13, 2015 @01:16PM (#9711705)
If you took "C" out of that list, I'd agree with it.
Re:Why Go is doomed to succeed by dsymonds on Saturday June 13, 2015 @01:22PM (#9711743)
Yeah, C is probably the hardest to learn in that set.
Re:Why Go is doomed to succeed by masklinn on Saturday June 13, 2015 @03:04PM (#9712184)
> would it be much easier for Java programmers to move to Go compared to C programmers?

Don't know about "very", but there would be very little difficulty moving from java to go. There wouldn't be that much value to it though (startup speed and deployment would be the primary ones, and if those are your concern chances are you're not using java as it's notoriously not great at those).

> And, what about python programmers, how would Go be for them?

That seems to be the primary actual market, migrations from python, ruby, php and the like: Go provides a bit of type safety and easy concurrency, an easy deployment story, structural typing is closer to duck-typing than nominal typing (where interfaces must be explicitly opted into by objects) and the fast compilation time means the compilation step isn't much of an issue over "direct" interpretation (/implicit compilation).

Re:Why Go is doomed to succeed by aaggarwal on Saturday June 13, 2015 @03:17PM (#9712231)
This is helpful. Thanks!

I have one more question, how does Go ensure easy concurrency?

Re:Why Go is doomed to succeed by masklinn on Sunday June 14, 2015 @05:19AM (#9714283)
It provides built-in lightweight thread abstraction ("goroutines", and "channels" for communication between these).

Beware though, Go uses shared-memory concurrency (as opposed to, say, Erlang) so if you pass a pointer to a mutable structure through a channel the structure won't be copied or moved, both sides will be able to alter it. It does provide a data race detector but it's just that, you have to hit the corruption path while running the detector for it to have a chance, I'm not sure it's 100% even if you do, and I understand it has a non-trivial runtime cost and limitations wrt number of routines it can track.

Re:Why Go is doomed to succeed by aaggarwal on Sunday June 14, 2015 @05:59AM (#9714369)
Thanks for informing, that is an important point to keep in mind, ignoring this would lead to potential bugs and very difficult debugging as you said.
Re:Why Go is doomed to succeed by Blackthorn on Saturday June 13, 2015 @09:48PM (#9713529)
Assuming that's an honest question: it has actual lightweight threads, so you don't need to muck around with either async garbage or worrying that you're using too many threads because you aren't mucking around with async garbage.
Re:Why Go is doomed to succeed by aaggarwal on Sunday June 14, 2015 @03:10AM (#9714021)
Yeah,I was reading about the http module and goroutines. It looks nice. Though I still have to try it.
Re:Why Go is doomed to succeed by aaggarwal on Saturday June 13, 2015 @02:17PM (#9711970)
I found this discussion very helpful. Thanks!
Re:Why Go is doomed to succeed by oldmanjay on Saturday June 13, 2015 @01:49PM (#9711868)
It doesn't feel right to say go is "between" java and c. There isn't a tremendous amount of expressiveness in go that java can't replicate, and there's enough in java missing from go that makes it a wash, for me anyway.