Hacker News Reader

Comment by laureny | Hacker News Reader

> > Notably, if a package is included but not used, Go treats this as an error and enforces removing unused declarations

A good illustration that the Go designers didn't think their ideas through. This is a real pain in the butt when you are writing code and regularly commenting in and out sections of code while you are testing things. And every time you do this, you need to remove or restore the imports. And since Go's tooling is nonexistent, there is no IDE to do this automatically for you.

This kind of thing belongs in a compiler plug-in (if it was designed with such a thing in mind, which is not the case for Go), macros (if the languages supports them, ideally the hygienic and statically typed kind) or an external tool, not in the compiler.

View on HN

> A good illustration that the Go designers didn't think their ideas through.

Please don't misconstrue disagreement as sloppiness. If you read the mailing list, it's pretty clear they thought it through.

> This is a real pain in the butt when you are writing code and regularly commenting in and out sections of code while you are testing things.

Not for me. I love it, actually.

> And since Go's tooling is nonexistent, there is no IDE to do this automatically for you.

Vim does this for me.

Also, Go has some of the most wonderful tools of any programming language I've ever used.

> This kind of thing belongs in a compiler plug-in (if it was designed with such a thing in mind, which is not the case for Go), macros (if the languages supports them, ideally the hygienic and statically typed kind) or an external tool, not in the compiler.

I think reasonable people can disagree on this point.

False. The Go designers have explained many times why they made unused imports an error. In particular unused dependencies slow down compilation. There's even a FAQ: http://golang.org/doc/faq#unused_variables_and_imports.

A trivial workaround to silence the compiler errors during development is to use blank identifiers (http://golang.org/doc/effective_go.html#blank_unused). I use them all the time.

You may disagree with their decision, but it's disingenuous to claim that it's because they didn't think it through.

Maybe they did think it through, but their conclusion reveals some inexperience.

It's impractical on many levels. Thus the need for kludgy solutions like blank identifiers. I'd rather see a strict mode or some other type of compiler flag.

Maybe you don't realize that "they" includes Ken Thompson himself... You may disagree with the Go design team's decisions, but it's amusingly absurd to accuse them of inexperience.

> Maybe you don't realize that "they" includes Ken Thompson himself... You may disagree with the Go design team's decisions, but it's amusingly absurd to accuse them of inexperience.

Not really, if anything, Go shows that its designers have a lot of inexperience when it comes to modern language design.

Go would have been a kille language in the late 90's but it seems to ignore everything that we've learned about language design in the past decade.

Quite true, every single feature can be traced back to 80's and 90's languages that for whatever reason did not manage to become mainstream.

Maybe one could make a table stating the language feature and which language provided it for the first time.

Just an update on my comment.

Even if the language is like that, if it helps improving the situation where young developers learn that strong typing does not have anything to do with VMs, I find it quite positive.

Just because he created UNIX, does not make him right in every technology decision he takes.

Impractical for you. I particularly enjoy the rigidity of the compiler.

Jesus Jumping Blue Christ, why is it that every time Golang comes up in any type of discussion, there's always someone out there who complains that Go is horrible because it doesn't implement their favorite pet non-mainstream language features, which is obviously because the Go designers were inexperienced newbies with only 50 years of experience designing groundbreaking software, and therefore lacked your deep insights into how things should really be organized?

I usually chalk it up to armchair quarterbacking.

> good illustration that the Go designers didn't think their ideas through. This is a real pain in the butt when you are writing code and regularly commenting in and out sections of code while you are testing things.

How could it be that bad?

It's as simple as a compile, a click on the error message and adding a one line comment.

No worse than the standard practice of making sure your c/c++ code compiles without warnings with the maximimum warning level set.

People develop at different speeds. For me, anything like this that slows me down and interrupts my flow with 3-4 seconds of "click on the error message and add a one-line comment" is incredibly annoying.

Development has several modes. One mode is "hacking", just hashing out what you want until it works and is elegant enough as a solution, perhaps changing your mind frequently when you see how it works in practice. Another is "polishing", carefully annotating, cleaning up, documenting, burning off loose threads, making sure the test coverage is top notch, etc.

The problem is that Go's compile-time strictness lends itself to the "polishing" phase, but not to the "hacking" phase.

    > Development has several modes. One mode is "hacking",
    > just hashing out what you want until it works and is 
    > elegant enough as a solution, perhaps changing your mind 
    > frequently when you see how it works in practice. 
    > Another is "polishing", carefully annotating, cleaning 
    > up, documenting, burning off loose threads, making sure 
    > the test coverage is top notch, etc.
    > 
    > The problem is that Go's compile-time strictness lends 
    > itself to the "polishing" phase, but not to the 
    > "hacking" phase.

When I write Go, or indeed in any programming language, I generally start with, and stay in, what you call the "polishing" phase. Experimentation occurs in my head, and what makes it through to my fingers is the polished form of that experiment.

That Go is not conducive to writing sloppy (or "hacking" phase) code is I think only a good thing.

Without measuring how productive we (you and I) are as programmers, such a qualitative judgement is largely meaningless.

Anecdotally, I have had colleagues who always plan ahead meticulously, using pen and paper and diagrams and plenty of note-taking before ever writing a single line of code, and the first line of code is often a test. And yet those people were terrible programmers. They take a long time to produce working code, and it's often deeply flawed. They will spend half a day or an entire day trying to hunt down a bug that I found to be trivially obvious even without knowing the codebase. Meticulousness does not imply quality.

Reply on news.ycombinator.com