Re: GCC is 25 years old today

>>> compilers?
>>
>> maybe, being free.
>
> But GCC isn't the only free compiler out there, and yet no other
> compiler, paid or free, managed to attain the same level of
> popularity. Couldn't it be possible that GCC's success is owed to
> some determining factor other than price?


going from my limited experience, GCC was the first major compiler I saw
"putting up a good fight".


it came in the form of DJGPP at the time, which was an alternative to
what I was using before (TurboC), and much cheaper than the other option
(Watcom, at which IIRC my parents balked at the price).


I also saw LCC, but only ever saw it in a bare-bones form (it didn't
come with OS headers or libraries), and it seemed to produce fairly
naive output (and, IIRC at the time, not for the assembler I was using).




more recently, I have ended up mostly using MSVC, mostly because:
it was also freely available (via the Platform SDK);
it supported some features which at the time GCC didn't support (namely,
Win64).


and, to some extent, Visual Studio, but mostly because of the MSDNAA
thingy (didn't have to pay for it directly).




I remember looking at LCC again later, but at the time decided to write
my own C compiler based on my own code (I forget the exact reasons now).


my C compiler effort was based on the VM for my own language, but the C
compiler effort ran into significant difficulties regarding maintenance
and debugging, among other things.


more recently, more effort has been focused more on my scripting
language instead which, despite being ECMAScript based, still inherits a
fair amount from C, and some from C++ as well.




>> I vaguely remember a time when compilers tended to cost money, and
>> weren't exactly cheap.
>
> There are still paid compilers out there. If I'm not mistaken, Intel sells
> its compiler for around 600 euros.


yes, but I think they are mostly aiming for a special market:
people who want finely tuned high-performance output, and are willing to
pay for it.




I personally worry a little less about this though, given AFAICT there
is only around a 2x-3x raw performance difference between very naive
output (no optimizations or debug settings) and full compiler optimizations.


this, in turn, only really tends to make a big difference if the
performance is CPU-bound. if it is bound by something else, say, the
GPU, then other lines of optimization may make more sense (less worry
about using compiler optimizations for code that is only 1-4% of the
running time).


granted, a person can ask what the difference is between, say, MSVC or
GCC optimized output and ICC output, but I don't think it is likely to
be all that drastic (looking around, it seems to be generally closer to
around 20%).




actually, I do a lot of stuff, in general, that is arguably just "bad"
from a performance POV (such as using a lot of use of dynamic
type-checking in many places, ...), but then again, this code is not a
significant time waster (a lot of this code has ended up a bit
micro-optimized though, like a lot of "evil tricks" in the type-checking
predicate functions).


sometimes convenience may matter more, like having compiler logic or a
network protocol being based on dynamic types may turn out to be a bit
more convenient than using statically-typed logic.


it is not strictly "one or the other" though, as most often, dynamic
types are unnecessary (and would waste time and make debugging harder),
but where they are useful, they are very useful.




> Rui Maciel
> [I think it's fair to say that GCC was the first free compiler that
> generated code competitive with commercial compilers. -John]


yes, very possibly...


now, one can argue about LLVM, but where was LLVM 15 years ago? it
didn't exist yet.


so, timing may be an important factor to consider as well, in addition
to things like price, ideologies, the use of the GNU toolchain for
developing Linux, ...

Return to the comp.compilers page.
Search the comp.compilers archives again.