Hacker News Reader

Please don't start programming language flamewars on HN ("Go is utter shit", etc.) Those are all the same, and we're hoping for thoughtful discussion.

We detached this subthread from https://news.ycombinator.com/item?id=11678317 and marked it off-topic.

Does anyone have a browser extension or similar that will reattach subthreads that get moved like this? Or maybe a user preference similar to showdead?

>Go: Go is utter shit that only survives due to the devs name-dropping "Google" every 5 minutes.

Making blanket statements like that without any substantiation makes me want to just write off everything else you have said.

To my mind writing off Go is table stakes for having an interesting discussion about modern programming language choice - anyone who takes Go seriously is coming from a position so different from mine that it would take many pages (all of which would be rehashing of old discussions) to bridge the gap, and I honestly can't be bothered. While I would try not to be so rude about it, I think GP is right to dismiss the language without going into detailed reasons; there are any number of threads about Go that cover the case for and against already.

Go is obviously pretty god awful when it comes to design when viewed strictly as a language. The language is mind numbingly boring and restrictive. The reason why people are interested in go (at least IMO) is because of stuff that isn't really about the language design. They are interested in the subsecond compile times out of the box. They are interested in one of the best standard libraries out there, a static binary that has subsecond start up times, a GC that doesn't require lots of tuning, a language spec so simple and a standard formatter so most code looks the same, etc.

The language it's self has no beauty and is not fun or interesting like scala. But I still love it and would totally base my company on it if I was planning on hiring thousands of developers and training them to use it. I would be scared of doing that with scala.

I guess I can see the case for using Go for something basic like CRUD that you just want to "crank out". But to my mind the kind of code you can program that way shouldn't be something you program at all - rather you write a system that handles it all generically (e.g. Rails/Django have generic model editor forms). Maybe in a business where programming is incidental it makes sense? But certainly it would destroy any kind of "hitting the high notes" business.

> But certainly it would destroy any kind of "hitting the high notes" business.

Not sure what you mean by that.

I still think that you are not really thinking about how many non-language pain points go takes care of. You don't really worry about a library being the wrong version, you need extremely little special training for a new developer to start on a go code base (compared to FP which requires a paradigm shift for most people), the people that have to setup the servers generally appreciate something that only requires a static binary to be dropped on the server and executed. Almost none of the things that make go great are actually related to programming languages, where as some of the best things about scala are all of the elegant ways you can express computation.

I agree with you that they are just 2 very different language in philosophy and usage. To my mind Go is about boring technology used to make interesting and very popular products while Scala is about exploring cutting edge in PL theory.

One can see most work on Scala in git commits is done either by few people at a research institute(EPFL) or at a consulting company(lightbend) whereas Go has quite varied committer profiles and there are far more committers.

> To my mind Go is about boring technology used to make interesting and very popular products while Scala is about exploring cutting edge in PL theory.

I would strongly disagree with the implication that Scala isn't used to make interesting or popular products (e.g. Spark or twitter), or indeed that it's "exploring" anything "cutting-edge"; it is very much a production-quality language (backed by theory sure, but theory that's been established for decades now), and I don't see that it contains anything more novel or experimental than e.g. Go's concurrency model. It's a decent platform for doing research in, but that's mostly just a question of being a good language.

> One can see most work on Scala in git commits is done either by few people at a research institute(EPFL) or at a consulting company(lightbend) whereas Go has quite varied committer profiles and there are far more committers.

We're talking about a factor of 2-3 in number of committers, not that I have any idea what that number is supposed to tell anyone. Certainly Scala has substantial industrial support and a wide base of contributors.

So what? If you can't tolerate an opinion I can imagine you are having a hard time on the internet. :-)

It does a discredit to any other better substantiated or more reasonable opinion you have stated.

For better or for worse when most people hear a new statement or opinion coming from someone they will trust it as much as they trust the least believable thing they have heard that person say.

This sounds like a very US-trigger-warning-safe-spacey stance.

I think most people on this planet are able to consider each point at its face value.

> I think most people on this planet are able to consider each point at its face value.

Humans have a pretty strong demonstrated tendency to develop positive or negative emotional attachments to pretty much everything, including sources of information/arguments, and see the world strongly filtered through those. This is, while it can be misleading, an important evolved survival mechanism in terms of attention/resource management.

Most people probably can, by expending effort, mitigate that to a certain extent, but that doesn't negate it completely.

People who can't assess statements objectively are probably exactly those people whose opinion I couldn't care less about.

Perhaps this is exactly the filter I want to have.

A few different people are trying to politely show you a way you're undercutting yourself.

And that's perfectly fine! I won't throw a tantrum because I might disagree (which I don't).

So you would not assess their other statements objectively?

This is not about safe spaces, this is about basic human psychology.

A small side note: Scala has several great features, but "low development overhead" just isn't one of them. Also why so harsh on Go?

If by low development overhead you mean amount of crap you need to type in order to get things done, Scala absolutely does have low development overhead.

As for Go, I'd say that's the most honest description of the language I've seen in a while.

"Low development overhead" was taken from parent comment, but I understood that it means how productive and fast it is to write code/develop something in Scala.

If your limiting factor is how fast you can type you are either an amazing person that should be studied or you need to take a typing class.

My limiting factor is usually how fast I can comprehend other people's code, and the extraneous crap some languages require can often be the biggest contributor to that.

I suppose "amount of crap you have to type" means "low boilerplate", not "basically APL".

Scala is pretty good in the low boilerplate department. I'm not a fan of Scala in the slightest, but in terms of code more or less directly expressing ideas it isn't bad.

Why do you say low development overhead isn't one of them? Outside of the one-time cost you pay to learn the language (which is higher than Go and most languages), Scala makes it super easy to write correct code quickly. The developer workflow of incremental compile + REPL + unit tests is great.

Probably depends on the code base, but having worked with Scala for a few years, there are a lot of things that causes development overhead. First things that come to mind: slow compile times, there are usually several ways to do one thing and also docs/guides are inconsistent, overused operator overloading in libraries (almost have to learn new DSL syntax for some libs), and it is not always easy to comprehend code by other developers.

not bagging anything you're saying, but I found slow compile times more or less go away if I open an sbt and type ~ compile to have it auto compile on save

Regarding Go... perhaps the parent was harsh, but not wrong per se. I think a strong argument can be made for Go being a very poorly designed language with an excellent community.

Scala certainly doesn't have high development overhead either. Build system more or less just works, plenty of libraries, minimal ceremony to do much. Don't get me wrong, I kinda hate Scala¹, but compared to _many_ languages it does have low development overhead.

¹ Disclaimer: haven't used Scala since 2.8. Maybe it's better now. Don't get your panties in a wad, but Scala is basically really shitty OCaml on the JVM in my mind.

Scala has been vastly improved since 2.8. If the experience you stated comes from Scala 2.8 I think you will love the way things are working currently.

I wouldn't want to go back to 2.8 even if people paid me a ton of money.

I love ML, but think OCaml is a poor ML. That's why I love Scala. It's extremely consistent, and design decisions are very considerate.

It's an amazing language and I can express my intentions much better than in OCaml (no typeclasses, no higher-kinded types, etc.).

I'll check it out again!

Thankfully I'm no longer working with the JVM, so I doubt I'll use it much, but it could be fun to take another look at.

Oh, and OCaml is possibly getting typeclasses (via modular implicits—not unlike Scala actually, for better or worse). It's not very painful if you use an alternate standard library (i.e. Core) that actually takes advantage of OCaml's amazing module system.

> Swift where things get added at a frightening rate.

Things are always added at a frightening rate when a language is young. Happened for C#, happened for Scala, happens for all languages.

Not really something to worry about.

The difference is that Scala devs didn't push for immediate adoption while they were still working things out.

Apple's Swift message is more or less "Stop writing Objective-C if you can and start using Swift – oh and by the way – you will have to rewrite your code with every major Swift release which we will be releasing at a rapid schedule".

It will be very hard for Swift to get rid of all the cruft they accumulate.

In Scala every major release addresses one or two pain points and migration is very smooth – no "rewrite all your stuff".

> In Scala every major release addresses one or two pain points and migration is very smooth – no "rewrite all your stuff".

Yes, the Java way. Take ten years to implement basic stuff.

I much prefer Swift and C#'s approach to this: first major version bump, things get deprecated. Second bump, they get removed. It worked great for C#, it's going to work great for Swift, which has already seen incredible adoption on iOS.

Scala is moving at a glacial pace in comparison, really not worth bothering with.

Oh come on Cedric. You managed to troll better in the past.

As you surely know it already, the deprecate-remove cycle is pretty much how a) Scala works and b) C# doesn't work.

> Go: Go is utter shit that only survives due to the devs name-dropping "Google" every 5 minutes

Woah!

Go is great if you dont mind writing 1000's of lines of boiler plate code one would expect to exist.

Agreed, but that said I'm a recent convert from Scala to Go. Not sure I'd go backwards (no pun intended), boilerplate aside.

Having standardization on things like channels in the language makes for a much nicer consistency in the language. Scala has 8000 ways to do anything, half of which involve an exotic DSL. I'll take plain and simple please over esoteric and unmaintainable.

'plain and simple' languages encourage and often necessitate 'esoteric and unmaintainable' applications. Look at Java for examples of this, and Go is basically java without generics and a much worse garbage collector.

How so? You can find examples of poor engineering in any language. What's specific about go?

Go doesn't have the facilities that let you handle real-world concerns in a nice way. All the examples of bad, enterprisey Java - Spring AbstractSingletonProxyFactoryBean, XML config for everything, reflection-based JSON serialization, annotation-based transaction management, JavaSpaces - they weren't written by idiots, they were written because they were the best way to solve real business problems within the limits of the language - limits that go also has.

People don't like writing hundreds of lines of repetitive boilerplate the way go's lack of generics forces you to. They'll look for a better way, and they'll come up with hacks, just as they did in Java.

Well Java has generics since 2004 and I have seen bloated enterprisey usage and patterns increasing vastly since then. Spring has become major force after Java had generics. So your argument about generics does not sound realistic to me.

Java's type system is limited (no higher kinds) and methods that might throw exceptions can't be handled as values in a generic way.

Be fair now, you don't need to write them, you just copy/paste them.

Not sure if you meant that in jest, but it made me shudder a little.

Clearly people either love or hate Go. There is a lot of hate I've seen on HN. I personally love it, but who am I to say what is a good language and what isn't.

Honestly I'd expect to see the most Go hate on a thread about scala. The design principals of both languages are completely at ends with each other.

Clearly people have opinions that range across a wide spectrum on any subject.

To say interest in is divided into either hate or love is disingenuous.

I would like to hear what makes Go utter shit

Oodles of boilerplate to do stuff that's a (simple and understandable) one-liner in several other languages.

It's a dumbed down language, not a simplified language.