>tends to emphasize compile speed over producing optimal executables
So they opted to handle the easy problem.
So they opted to handle the easy problem.
Optimal executables aren't that important most of the time. Hardware is cheaper than dev time and the gain of 'optimal' isn't much for the compile time trade off.
1) Sure. Most of us do not. So why should we care and/or trade other stuff for compile time improvements?
2) That's when you don't have a module loading system and have to build everything everytime.
2) This is about the linker, not the compiler. You should compare the compilation times with the linking times instead of making assumptions.
Which is an no-op answer. That can be the answer for any kind of engineering decision, including the most idiotic ones.
We're concerned with what's best here, not merely with what has been decided.
>Don't like it, feel free to fork it
Another BS non answer.
Yeah I was being facetious with my original reply, and frankly I get your point, I was pointing out however that you _can_ fork it to make it work the way you'd prefer. If you truly don't want to (or can't) do that, then open a ticket or send something to a mailing list.
If this really matters to you, do something about it that can make an actual difference.
Or use gccgo, which piggybacks off of the many optimizations that have been used in the gcc collection[0] over the years.
When discussing compilation of Go, people here often seem to forget that two first-class compilers exist for the language.
[0] Yes, I am aware that this is like saying "ATM machine"
I think having some sort of optional 'really fast compile' vs. 'optimal performance' build is the ideal - fast cycle development, then on deploy build something fast. I think gc go vs. gccgo is potentially a model for this :-)
But that is mostly a problem because incremental compiling in C++ is difficult for well-known reasons. Incremental compiling is well-supported in many other languages (e.g. Java) and is usually very fast. So, the issue of compilation time is IMO overstated by Go proponents.
Besides that, e.g. JRebel and DCEVM provide true hotswapping. So, generally, developing e.g. a web service in Java does not have a visible compile and deploy cycle at all.
I think having some sort of optional 'really fast compile' vs. 'optimal performance' build is the ideal
Why not have really fast compiles and JIT compilation when needed to make it fast (Java, C#, F#) or just JIT compilation (JavaScript). Of course, the trade-off is that you have to carry around a VM, but the JVMs and JS VMS are ubiquitous.
As I've already said to someone else. This is about linking, not compilation. The rest of your comment is irrelevant to this discussion.
And I am reacting to your grandparent, who was talking about compilation.
danieldk 8 minutes ago | link
>> As I've already said to someone else. This is about linking, not compilation. The rest of your comment is irrelevant to this discussion.
> And I am reacting to your grandparent, who was talking about compilation.
I'm fairly certain that that slow compile time is a combination of `compile + link` and the linking is probably a big part of the equation as well, just like it is in C and Go.
Actually, chromium's ninja [0] build setup [1] is really awesome, and does what it can with incremental building, but it's obviously limited in what it can do, it doesn't seem to take very much to trigger a very big rebuild. It's a definite help though.
[0]:http://martine.github.io/ninja/ [1]:https://code.google.com/p/chromium/wiki/NinjaBuild
https://groups.google.com/d/msg/mozilla.dev.platform/HdXdNdf...
* Videos on how to download, build, and debug Firefox code: http://www.codefirefox.com/
* Good first bugs: http://www.joshmatthews.net/bugsahoy/?cpp=1&unowned=1
Also the problem with the lowest cost/benefit for them. Also the problem with the highest benefit. One calls this a "no-brainer."
Of course, Go is a language that is more amendable for quick compilations. But it would be more interesting to see a solution that provides good optimizations and improves programmer productivity. Go doesn't really have an answer to that (except: use gcc-go), while the competition has (e.g. JIT compilers).
If you want to be nitpicky, it's not that Go is selling a shortcoming as a feature. It's more that it simply doesn't have that feature.
Go also has a number of other features pcc doesn't.