From: Christopher Smith <[EMAIL PROTECTED]>
Gabriel Sechan wrote:
ANd this type of negligent and quite frankly unprofessional thinking is
why my Athlonx2 has problems running the same application load my pentium2
333MHz did. We write poor, slow, buggy code.
I'm gonna call bullshit on this. If it's the same code, then the
performance bottleneck is clearly not the processor. If it isn't the same
code, it's entirely possible that the problem is not poor, slow, buggy
code, but that the apps have different functionality (you may not like the
changes, but nonetheless it's not necessarily anything about the quality of
code).
Of course its not the same code. But my Athlonx2 has trouble running Word,
an mp3 player, and its various firewalls. My p2 333 did the same job with
fewer problems. Some of this (perhaps as much as 50%) is due to feature
creep. The rest is because we've thrown out the craft of efficiency and
instead count on the hardware to speed things up for us. And due to this,
we're going to be in a shitload of trouble in a few years- hardware has
just about peaked out, and multiple cores is only going to do so much.
And in the rare cases where they do need to optimize other things they
should be writing in high level languages and then linking in their own
optimized C or even further optimized assembly code.
"High level languages" is bullshit. The fact is its just as quick to
write a program in C as it is in Python, Perl, Java, etc- provided you're
experienced equally in those languages (obviously coding in a language
you're not experienced with is always a penalty to speed). And the data
all shows this- development speed is not going up despite the number of
"high level" languages around today.
I'm going to call bullshit on this too. "development speed" is not the
right metric, because our perceptions of what can and should be done
quickly have changed substantially. More importantly, the advantage of high
level languages is more that it that it simplifies code, which allows
increasingly more and more complex projects to be tackled by smaller and
smaller teams.
Bullshit. High level languages don't simplify code, they complicate it.
Inheretence, exceptions, templating, etc are all far more complicated to
understand than simple procedural code. Only in rare occasions does this
complication actually come with a commesurate performance increase. You may
end up doing more per line, but that does not mean simplification- it means
more points of failure and more difficulty debugging.
Gabe
--
[email protected]
http://www.kernel-panic.org/cgi-bin/mailman/listinfo/kplug-lpsg
