Without bankruptcy society would have no way of cutting losses and moving forward.
It's the other way around.
Originally "entrepreneurs" were a risk sink of the society -- if they fail, they become poor, but no one else is affected, so even if very few of them succeed, there will be enormous empires built with economy of scale, unimpeded by failures of others.
With bankruptcy, risk is distributed -- personally "entrepreneur" either wins or breaks even, but banks and occasionally government take losses. This, in its turn raises interest rates and devalues currency, thus losses are distributed to every member of society. As the result, the position of "entrepreneur" serves no purpose at all.
The market where Microsoft has monopoly is not just "desktop operating systems" but also "operating systems for general-purpose interactive computer devices". Even counting existing tablets as "general-purpose", what is a stretch for things like iPad, Microsoft is still a monopoly due to overwhelming numbers of PCs. Windows 8 for ARM is firmly in that category. It's marketed as the same Windows, just for smaller devices (just like Windows CE was, except then it was a lie, and now it mostly is not).
Why is it impossible to find out? You just track the original line number for every line of code, even after it has passed to the preprocessor. If, for example, one does "Go to definition" on an identifier, and it turns out to be a function that was a result of a macro expansion, you point the user at the line where said expansion happened. A good IDE will also let you hover over the macro on that line, and see the expansion.
And then there is no definition because it's stitched out of "##". And on top of that, it uses conditionals that are only resolved in the middle of build. IDE would have to generate documentation, and then tell the user to read it, what would be a stupid thing to do.
If your IDE (and other code processing tools) is doing things right, it will, of course, preprocess the source before trying to parse it.
And then they won't know what to tell you because it's impossible to find out what came from where, as preprocessor is allowed to generate identifiers.
Having a separate parser for the preprocessor is, unfortunately, unavoidable for the simple reason that it has a completely different grammar from the language itself (to the point where productions for tokens don't match, so a single token in a preprocessor can end up being two tokens in the compiler). It's definitely a sign of deficiency in the language design, but there's no need to make it even worse by writing more buggy parsers instead of reusing the one that's already there.
If you want to badmouth C, there are places for that, and it's not here. C design is what it is -- it's two languages in one. C++ is four. It's how they are designed, and it's not going to change unless you develop a new language from scratch.
Ah, so you'd rather use two different and subtly incompatible parser implementations to do a simple task rather than just one? what happened to "Unix way"?
Three. There is a preprocessor before C or C++ compiler, so what your built-in parser shows is likely not the same as what is happening in your source. Or four if you use Qt.
If you need to look at the source of everything every time you use it, you have a case of horrendously tight coupling, combined with lack of documentation. Some parts of Linux kernel come close to this point, thus requiring things like LXR (but then LXR does what IDEs don't and shouldn't, such as allow users to look at multiple versions to see how things changed -- it's not something that is supposed to be stuffed into the editor).
Really? I thought it was a great way to have a persistent Linux install for a newbie to test driver compatibility and get a taste of the environment without having to worry about partitioning, data loss, and other headaches relating to OS installations.
Then you are either ignorant, stupid or both. Ubuntu and many other Linux distributions now come with an installer that can resize the partitions as a part of installation process. Wubi solves a problem that does not exist, and imposes a permanent penalty, in usability, security, flexibility and performance on all systems installed with it.
Good! Then those "many companies" will be extinct soon because "most companies" do not rely on incompetent legal departments who use meaningless weasel words like "combined w/ non-GPLed software", and follow the license that covers redistribution of modified software.
Have you read the GPLv3? It is a long and complex legal document. Are you certain that nothing that you are doing violates it? Want to bet your business on it?
Absolutely. I work for a company that has legal department for that very purpose. And they had to deal with much, much more complex and restrictive licenses, like every single license for proprietary software that I ever had to use there.
No, my point is that if you can benefit from any of those things, you are not a programmer at all because your thinking is incompatible with programming. For a programmer all those things look like those idiotic ad-links popups that some Javascript monstrosity overlays over all texts subjected to it. The functionality is equivalent to giving crutches to a marathon runner.
So when will GCC provide a way to recompile one function within a translation unit without recompiling all other functions within the same translation unit? Does it already?
It's completely unnecessary, unless someone writes "translation units" with tens of thousands of functions. And then the problem is not with the compiler.
Oh, Eclipse does let you customize UI. But then in the end you have just a really bad editor with a project and compiler menu, and I have better one in Emacs.
You know, it's been my experience that when someone says something along those lines (any other way of doing something is shit, and anyone who does it is shit) that they really don't know what they are talking about, are full of themselves.
Or, maybe, they have seen it done the shit way before, and want to warn people against doing it again.
So what's the valid way of finding what functions exist and what variables belong to what functions? Such functionality is needed for "go to definition of selected symbol" and "search for uses of selected symbol" actions.
The valid way is "don't, because it encourages horrendously tight coupling in all interfaces". I am more productive with two editor windows side by side (something that can't be accomplished in IDEs due to multitude of itty-bitty reference windows everywhere) than programmers who rely on tools to jump to definitions that usually they have no business reading in the first place.
The way how it is implemented everywhere is, use ctags. You don't need the whole compiler for just parsing identifiers.
One example would be integrating the compiler with its own custom tools.
The only valid way of integrating compiler with custom tools is calling the compiler from them (everything else is shit design made by shit developers). That was done with gcc for as long as gcc exists.
Slashdot Mirror
Without bankruptcy society would have no way of cutting losses and moving forward.
It's the other way around.
Originally "entrepreneurs" were a risk sink of the society -- if they fail, they become poor, but no one else is affected, so even if very few of them succeed, there will be enormous empires built with economy of scale, unimpeded by failures of others.
With bankruptcy, risk is distributed -- personally "entrepreneur" either wins or breaks even, but banks and occasionally government take losses. This, in its turn raises interest rates and devalues currency, thus losses are distributed to every member of society. As the result, the position of "entrepreneur" serves no purpose at all.
The market where Microsoft has monopoly is not just "desktop operating systems" but also "operating systems for general-purpose interactive computer devices". Even counting existing tablets as "general-purpose", what is a stretch for things like iPad, Microsoft is still a monopoly due to overwhelming numbers of PCs. Windows 8 for ARM is firmly in that category. It's marketed as the same Windows, just for smaller devices (just like Windows CE was, except then it was a lie, and now it mostly is not).
You really are supposed to have them in the documentation.
ctags
Did I recommend to use ctags? I said that ctags is a sufficient implementation of the feature that is unnecessary in the first place.
Why is it impossible to find out? You just track the original line number for every line of code, even after it has passed to the preprocessor. If, for example, one does "Go to definition" on an identifier, and it turns out to be a function that was a result of a macro expansion, you point the user at the line where said expansion happened. A good IDE will also let you hover over the macro on that line, and see the expansion.
And then there is no definition because it's stitched out of "##". And on top of that, it uses conditionals that are only resolved in the middle of build. IDE would have to generate documentation, and then tell the user to read it, what would be a stupid thing to do.
If your IDE (and other code processing tools) is doing things right, it will, of course, preprocess the source before trying to parse it.
And then they won't know what to tell you because it's impossible to find out what came from where, as preprocessor is allowed to generate identifiers.
Having a separate parser for the preprocessor is, unfortunately, unavoidable for the simple reason that it has a completely different grammar from the language itself (to the point where productions for tokens don't match, so a single token in a preprocessor can end up being two tokens in the compiler). It's definitely a sign of deficiency in the language design, but there's no need to make it even worse by writing more buggy parsers instead of reusing the one that's already there.
If you want to badmouth C, there are places for that, and it's not here. C design is what it is -- it's two languages in one. C++ is four. It's how they are designed, and it's not going to change unless you develop a new language from scratch.
Ah, so you'd rather use two different and subtly incompatible parser implementations to do a simple task rather than just one? what happened to "Unix way"?
Three. There is a preprocessor before C or C++ compiler, so what your built-in parser shows is likely not the same as what is happening in your source.
Or four if you use Qt.
If you need to look at the source of everything every time you use it, you have a case of horrendously tight coupling, combined with lack of documentation. Some parts of Linux kernel come close to this point, thus requiring things like LXR (but then LXR does what IDEs don't and shouldn't, such as allow users to look at multiple versions to see how things changed -- it's not something that is supposed to be stuffed into the editor).
Really? I thought it was a great way to have a persistent Linux install for a newbie to test driver compatibility and get a taste of the environment without having to worry about partitioning, data loss, and other headaches relating to OS installations.
Then you are either ignorant, stupid or both. Ubuntu and many other Linux distributions now come with an installer that can resize the partitions as a part of installation process. Wubi solves a problem that does not exist, and imposes a permanent penalty, in usability, security, flexibility and performance on all systems installed with it.
Good! Then those "many companies" will be extinct soon because "most companies" do not rely on incompetent legal departments who use meaningless weasel words like "combined w/ non-GPLed software", and follow the license that covers redistribution of modified software.
Have you read the GPLv3? It is a long and complex legal document. Are you certain that nothing that you are doing violates it? Want to bet your business on it?
Absolutely. I work for a company that has legal department for that very purpose. And they had to deal with much, much more complex and restrictive licenses, like every single license for proprietary software that I ever had to use there.
No.
Makefiles are necessary because projects may contain tens of thousands of files for very legitimate reasons.
Incremental compilation is only necessary if programmer is a dumbass.
No, my point is that if you can benefit from any of those things, you are not a programmer at all because your thinking is incompatible with programming. For a programmer all those things look like those idiotic ad-links popups that some Javascript monstrosity overlays over all texts subjected to it. The functionality is equivalent to giving crutches to a marathon runner.
I have seen people doing with Vim what I do in Emacs, so I consider both to be valid options, however I am more accustomed to Emacs.
It's idiotic, unreliable, slow, and prevents you fron removing Windows.
More shills...
That's not an "entry point", that's a way to attach malware once the system is already compromised.
But that doesn't stop little Windows propaganda workers, they just want to say something that sounds convincing on the surface.
So when will GCC provide a way to recompile one function within a translation unit without recompiling all other functions within the same translation unit? Does it already?
It's completely unnecessary, unless someone writes "translation units" with tens of thousands of functions. And then the problem is not with the compiler.
Oh, Eclipse does let you customize UI. But then in the end you have just a really bad editor with a project and compiler menu, and I have better one in Emacs.
the topic of this thread is "What's Wrong With GCC?", not "What's Wrong with the GPL"
The brancg you are answering to, starts from my response:
And WHY would a company want to avoid GPL compiler, unless it intends to distribute a sabotaged version of the compiler?
You know, it's been my experience that when someone says something along those lines (any other way of doing something is shit, and anyone who does it is shit) that they really don't know what they are talking about, are full of themselves.
Or, maybe, they have seen it done the shit way before, and want to warn people against doing it again.
Win what? Legalization of destruction of government property on the ground that he claims airspace above his head up to the distance to the Moon?
So what's the valid way of finding what functions exist and what variables belong to what functions? Such functionality is needed for "go to definition of selected symbol" and "search for uses of selected symbol" actions.
The valid way is "don't, because it encourages horrendously tight coupling in all interfaces". I am more productive with two editor windows side by side (something that can't be accomplished in IDEs due to multitude of itty-bitty reference windows everywhere) than programmers who rely on tools to jump to definitions that usually they have no business reading in the first place.
The way how it is implemented everywhere is, use ctags. You don't need the whole compiler for just parsing identifiers.
How is any of that related to licensing?
One example would be integrating the compiler with its own custom tools.
The only valid way of integrating compiler with custom tools is calling the compiler from them (everything else is shit design made by shit developers). That was done with gcc for as long as gcc exists.
Apple couldn't integrate GCC with their IDE like they wanted
If you can't integrate gcc into an IDE, you have shit IDE. I mean shittier IDE than Eclipse, and that's a shit IDE already.