Hacker News Reader

Comment by gaze | Hacker News Reader

Go was designed to not cause widespread damage in the hands of a mediocre programmer. It prevents people from being too clever at the expense of more boilerplate and general busywork. This is the exact tradeoff that google wanted to make.

View on HN

If that was the goal then why not just use Java? It fits this goal description even better and offer superior tooling, infrastructure and mindshare.

One important reason: Because Java encourages inhertance-based designs, which are especially dangerous if your goal is to get inexperienced programmers to write simple, straightforward code.

Go does not have inheritance.

But inheritance is thought to be a key to software reuse, and reusing the existing software is the safest path for inexperienced programmers to become productive.

Inheritance is thought by some to be a key to software reuse. By others it is considered a huge mistake.

Myself, I don't consider inheritance to be problematic when used wisely. But one shouldn't expect inexperienced programmers to act wisely.

My main point, though: Don't act like the inheritance question has a consensus answer. It doesn't.

If this was true, it would be an argument that applies just as powerfully to Rust. Ironically: it's the argument you'd expect Java developers to deploy.

Well... Inheritance have some use, sure. But productive code is code that is easily refactrorable, uncomplicated and easy to read. Inheriting, or rather subclassing too much will kill you code base (i'm currenctly working in a bank, writing mostly java and groovy, i think everybody agree except managment).

A good alternative is composition, but you have to have a clear view of what you want. I alway try to make one function/method per action (when i have more then three indent level in a function, i'm prototyping), and that helps more than inheritance for code reuse (and i avoid comments inside functions). And i use a lot of interfaces and "default methods" to emulate "traits" which is imo superior to inheritance, in a lot of way.

I still dislike java and groovy, when you spend hours depiling constructs to understand how to make a minor change on data collection, this is not a good language.

But it does have goroutines and many other features which are easy to make a mess with.

Also, the worst abuses of inheritance I've seen were all from supposedly senior engineers. And inheritance seems to be attacked a lot lately for questionable reasons. There are many places where it's a natural fit.

True, but I would argue that a novice/mediocre programmer will tread more carefully when using goroutines because the subject itself is often taught as a more complex/high level topic. Meanwhile, inheritance is often taught as a basic concept which can deceive inexperienced programmers into thinking that they completely understand it. That invites more potential missteps.

the glib but mostly correct answer is "because rob and others didn't like public static void main."

Rob and the other plan 9 folks hated C++ and Java with a passion because both took C and made it "complicated". They wanted something you could write servers, clients, and operating systems in.

I think of Go as a lovechild of C and Scheme, mainly; I wonder if there's a citation for the claim made about design for preventing damaging programmers.

You could also assume it as a rip-off of Modula/Oberon.

As is Acme, a text editor. Pike is like that.

Interesting, that was new to me. Wirth's work is not the worst source for inspiration of course.

I still find the adoption of Go interesting though, considering how limiting Pascal/Modula/Oberon felt to me when leaving them behind.

It might be because Go is a more defined C variant () but with a very full standard library.

: with real capturing closures and garbage collection, as in Scheme

Yes, it's not "good" in general terms but it's a lot better than Python or Ruby, and that's still a win.

I've heard this repeated several times. Is there a source for this claim from any of the people who designed the language?

> 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. So, the language that we give them has to be easy for them to understand and easy to adopt.

— Rob Pike <http://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Fro...>

From [1] via [2]:

– Rob Pike

[1] https://channel9.msdn.com/Events/Lang-NEXT/Lang-NEXT-2014/Fr...

[2] http://nomad.uk.net/articles/why-gos-design-is-a-disservice-...

Reply on news.ycombinator.com