Rid ad hominem

[michalrus]

Yo, the list is cool, but, maybe let’s consider removing the «for stupid people» parts? I can’t see offending being beneficial to the discourse in any way—especially to converting the Go crowd.

There is a way to communicate the most powerful truths and ideas to people.

Often this requires speaking no ill of the people in question.

— https://twitter.com/devslashdavid/status/775142439996760064

[ksimka]

But that's what those people actually say. That opinion is not anonymous or common, it has authors and you can see their names. The list is not "what Go actually is", it's "what different people think Go is".

If you feel offended by this (i.e. I'm absolutely not, just don't care), I can try to rephrase that statement. Or better you or someone else who is native speaker please offer alternatives.

[solidsnack]

• "designed for unsophisticated programmers"
• "heavy bias towards less capable programmers with little provision for advanced programmers"

[michalrus]

• “Designed for commodity programmers”—which might be good for some business, so maybe not offending?
• Even better (more inclusive) would be “designed to commodify our jobs”—but this one might be too far from the original point.

[ksimka]

"designed for unsophisticated programmers" sounds as a good compromise.

@michalrus as for me, both your sentences are "too far from the original point" (if I got the word "commodity" right :) ) So what do you think of @solidsnack's version?

[michalrus]

I dunno, really. I don’t like mine either. @solidsnack’s is way better than “stupid”, but still attacking these people, right? Most people, when attacked, will not take it cool and reasonably, but will automatically act defensively. And that prevents and harms potential conversion and, effectively, IT in general.

It’s for you to decide. :upside_down_face:

[annappropriate]

Jumping on this exciting bandwagon too ;) I read the first article that has "designed for stupid people" bullet point, and I believe the latter should be reworded as "naive approach is idiomatic". To back this up, author of the article rants about lack of "advanced shortcuts", and the snippets he offers really look as what you naively implement before you learn the idiomatic way. It isn't exactly about being offended, rather about some implications that you make about someone merely using a tool based only on the fact of using said tool. Rewording to my suggestion allows to hint how go will shape your way of expressing solutions in code, rather than suggesting a level of one's intellectual development. Kinda reverses the initial idea of you are stupid ⇒ you write in go to you write in go ⇒ go makes your thinking or problem solving less intelligent/high-level/advanced

[michalrus]

Thank you, @anna-zzz!

[ryukinix]

NOTE: this is a reflection about the attacking about the simplicity of Go and not about this repo necessarily

I don't understand the problem on this. The contrast for new system programming languages as Rust, D and Go is just the over-simplicity of Go on the rest. Go for itself is stupid. But some people are thinking that this is bad thing always. That characteristic was in purpose on design for the historical background of Go to be aware to complex languages like C++, as Rob Pike and Ken Thompson said it (easily found on sources of Golang history).

Is a way to design solutions for problems, being a stupid (aka over simple), is not necessarily bad. Can be easily a good thing. Lack of abstractions sometimes seems a problem (generics), but debugging a stupid program is much more easier than a too "smart" with a lot of incredible clever ideas (e.g.: Lisp with Macro DSLs).

But just because something is stupid and you uses doesn't means that are you stupid too. In certain level, if you think a lot about it, maybe you even conclude that The Turing Machine is pretty stupid too. But that machine was a not genius thing to even being so stupid but still so powerful? (the more powerful known way to compute anything, btw)

I think that the people attacking randomly Go saying things like that don't deserve credit. Golang has problems, but the simplicity is not necessary one. For a lot of problems that you need to write a program to solve you just don't need a really awesome abstraction feature. Simplicity can be better. Sometimes I just think that people forgot that Golang was mainly designed to do system programming solving problems with concurrency...

You need really a clever language with nice abstractions? Choose another tool. Rust. Haskell. Even Lisp. There is a lot to be find.

[solidsnack]

@ryukinix You are in the right. The “simplicity” justification is often used as an excuse for other aspects of Go, though — we don’t have generics, we don’t have a package manager (slowly changing), we don’t have colons between the variable name and the type...because of simplicity!

This “unbalanced simplicity” or “simplicity as an excuse” does create a real problem not only in Go but in many other real world systems.

[ryukinix]

@solidsnack, yes I understand that, I disagreed of some decisions of Go too. My problem is just over-attacking that.

The problem of not have some things, like generics, is that someone will do a awful thing to support that. Like nil interfaces, which is evil and error prone (I already do that and is no good). The package manager is really another problem too, go get is a mess. My overall experience with Golang was only in system programming on u-root (a type of busybox written in Go), so Golang sometimes fit very well, sometimes no.

My main problem with Go was of course the lack of a good package manager with versioning system, but we have some alternative tools today for Go. The GC increasingly has been better on new versions too.

[markww]

So, to jump on this bandwagon from a different perspective: to describe the language as "designed for stupid people" does not reflect the original sentiment of the authors.

The article "You Don't Like Go Because You Are Small" never claims that it is a language built for stupid people, it claims that the language designers made arrogant decisions about which language features are unnecessary that produces awkward, counter-intuitive syntax. This is not claiming that the language targets too low of a common denominator, but claims that the designers insufficiently tested the ease of using their own product.

The article "The Go Language is a Mess" only has the word "stupid" appear once, and it is not referencing the language itself, but the compiler/linker toolflow. Specifically, it criticizes the way that the compiler is "overly helpful" in managing compiled files and dependencies. While this may, indeed, be design for stupid people, it is not that the language was designed for stupid people, but the tools to make binaries from that language. Unless there is a fundamental language-level limitation I missed, this is a much less serious problem which could be solved by alternative tool implementations, and it seems unfair to summarize the author's article as leveling this rather strong charge against the language itself.

Ultimately, hearing people jump to describing other people, languages, or tools as "stupid" really turns my crank alarm (even when I agree with them). It's especially egregious, however, when it is used as an overly-strong summary of a thoughtful work that does not reach that level of accusation.

[dgryski]

The quote from Rob Pike that people keep clinging on to is:

The key point here is our programmers are Googlers, they’re not researchers. They’re typically, fairly young, fresh out of school, probably learned Java, maybe learned C or C++, probably learned Python. They’re not capable of understanding a brilliant language but we want to use them to build good software. 

And the association that "not capable of understanding a brilliant language" means he designed it for stupid people.

[ghost]

@dgryski does have a point there, all the repo does is summarise articles about Go that discuss its downsides. If you were to change the wording used in that summary it could end up misrepresenting what the original author meant. Don't fix what ain't broke basically

[Qix-]

@dgryski's quote is literally exactly where the "go is for stupid people" argument was birthed from. Saying anything else is ignoring the history behind the disapproval.

[cznic]

Except the word stupid is nowhere to be found in @dgryski's quote. IOW, the whole "designed for stupid people" has nothing to do with Rob Pike and everything to do with the authors who invented the term by themselves.

[onlyjob]

I suggest re-wording e.g. "designed for inexperienced/unsophisticated developers" or something like this.