Re: Brian Kernighan, maybe I'm not worthy, maybe I'm scum

On Dec 31, 1:43 am, Randy Howard <randyhow...@xxxxxxxxxxxxxxxxx>
wrote:
On Sat, 29 Dec 2007 22:21:35 -0600, spinoza1111 wrote
(in article
<cf23fbbc-d1b7-493d-8d33-7df2f3f08...@xxxxxxxxxxxxxxxxxxxxxxxxxxxx>):

[I'm going to skip the semantic tap dancing nilgewater is famous for
and just hone in on the stuff related to programming and this newsroup]

We all recall your foolish attempt to add your private word to
wikipedia, and we all recall that on my request, your vandalism was
erased.

Actually, it wasn't my word, and I don't use wikipedia, seeing how I
think it's all bull*** having "facts" decided by a popularity contest.
Worse, is when people point at a wikipedia entry to back up a claim, as
if it is automatically authoritative... but I digress.

...which is why the word which you guys added was removed. I realize
you don't want to take credit now, since whoever vandalized wikipedia
was so thoroughly humiliated.

You're implying that one of "you guys", which presumably refers to
group subscribers of comp.programming did something to wikipedia, and
were "humiliated" for it.  It's hard to imagine how anyone was
humiliated, unless it was a very private humiliation.

The sweetest humiliation being that of a mob who acts ignorantly. You
et al. acted in ignorance of the basic rules of wikipedia and you were
smacked down. Get over it, mob member.

You didn't even participate in these efforts, jejune as they were, and
focused as they were not on "benchmarks" but on petty stylistic
prejudices and the resentment of a literate style in programming, the
only style possible for creating large systems as opposed to snippets.

Completely false. Not only did I participate in them, but I posted both
a test harness (compilable) here, along with results on several
different platform configs, and others joined in using it as well.  How
soon you forget, when you want to...

You certainly failed to bring that to people's attention, because you
failed to bring it to my attention, and my "bad" code was the focus

It quite obviously /was/ brought to your attention, because you replied
(quite long-windedly) to several of the posts, plus started hammering
my email inbox with even longer versions, along with a ridiculous claim
that your rights were being violated.

It wasn't "bad" code, dearest Randy. You see, you dine on garbage, and
think it oat kwizine.



which in turn addressed mostly unprovable and
undecidable issues of programming style, which were neither verifiable
nor falsifiable.

Not only were they verified, they were proven on multiple operating
systems, compilers and CPU architectures.  You chose to ignore all that

You keep saying things that are completely false, trusting at all
times that casual readers will read you first, and assume that what
you say has any relation to the truth.

30 seconds in front of a google search engine pointed at this newsgroup
will cough up the details.  Several people downloaded the code and
posted the results.  If you wish to pretend that you never saw them,
that's fine, but the data is there if you are not afraid to look.

Oh yes, the performance comparision. I wasn't addressing performance.
I was addressing reliable and transparent code that is not the private
property of the Computer Thugs...whose current stunt is the
destruction of the American economy, because (it appears to me at this
time from the record) they couldn't be bothered to make mortgage
securitization auditable.







As I explained at the time, since optimizing compilers hoist loop
invariants, that's in general not a good idea from the standpoint of
readable code, since each "work" variable represents a deficiency from
the standpoint of clarity.

And as was /proven/ at the time, none of the compilers in general use
at the time (or now), as verified by multiple people, on multiple
systems, did the magic that you /thought/ they did.  None.  Not only
that, writing code that makes the author look stupid does not add to
"clarity", unless stupidity is the object you wish to clarify.

Here, old Randy is saying one thing and one thing only: you really
have to dig. An optimizing compiler often can't transform a c while or
for condition by seeing to it that it would be evaluated once (but it
can in some instances), and I knew this commencing a long time ago. He
is responding to my point on a different issue: that I coded a for
condition with a repeated calculation for clarity. He'd responded to
me by saying that any "real" programmer would have "hoisted the
calculation", using a buzzword to obscure the truth and impress the
moron that was taken from optimization which does hoist when to do so
doesn't change semantics.

It's not a buzzword, it's a word that has been used in the industry for
/at least/ 25 years, probably much longer, and not only that, the word,
unlike much of CS terminology, is actually very descriptive of the
action taken.

I don't think you've been in the industry that long. I was
professionally involved in the industry from 1973 to 2005 (32 years).
During that time, unlike the Computer Thugs, I kept up with the
literature, and the word "hoisting" first appeared textbooks on
compiler design and optimization, including my 1976 text in graduate
school.

But the term isn't a programmer buzzword, it arose instead from
compiler optimization precisely because an optimizing compiler can in
many instances (such as a repeated calculation subexpression in a for
loop in a language in which the designers messed up, and made the
condition repeatedly executable) move parts of the calculation outside
the loop.

Not only compilers do this.  Programmers have been doing it to effect
manual code optimization for quite a long time.  If you wish to
proclaim you were ignorant of this, that's fine.

Computer Thugs (not "programmers") have been creating messes and
billing Yuppie Thugs for cleaning them up by attempting manual code
optimization, for quite a long time.



As I pointed out at the time, for the programmer to do this in all
cases often obscures intent because it creates a new name usually with
procedure scope, which represents one more thing for the reader to
worry about.

No, it makes it clear that the author of the code understands very
basic coding skills and is keen to not imply incompetence to the reader
by using a construct that sows the seeds of doubt in the originator of
such code.

Many Computer Thugs as, in Adorno's words, perennial candidates for
posts, have as you seem to have, a secret fear that all their
professional careers, they've never been more than journey men, and
are anxious to deny this by stunts such as creating unnecessary
variables.

They don't read the literature on compiler optimization and as such
are inordinately proud of their stunts.




Indeed, you, as a person incapable of
original thought, use a big word for a subhuman and automatable
operation  in order to impress your moron friends.

What "big word" would that be?  

Hoist.

So five letter words are too big for you.

Words, my dear Randy, are nodes in a relational graph and never
standalone. As I've pointed out to the thugs, "verbosity" isn't
"measured" by word count: it is a relation x/y where x is word count
and y is idea count. I don't care, for this reason, how many letters
are in hoist: I do care that you, as a Thug, misuse it while
criticising people for density of ideas.



You were hoist with your own petard in the use of that word
which far worse than being intended to impress, was meant to confuse.

My guess is the only person confused by it out of the readers of this
newsgroup was you.  If you can provide a list of those that were and/or
still are confused by what it means, I'll be happy to explain it to
them.

For the benefit of the audience, Randy thinks that

for (i = 0; i < length*adjustLength; i++)

where length and adjustLength are "loop invariants" not modified in
the text of the loop (does not occur, nor passed by reference in a
procedure in the loop) must, as a matter of life and death, be
replaced by

int foo = length*adjustLength;
for (i=0; i < foo; i++);

because as opposed to Visual Basic where in

For i = 0 to length*adjustLength

the calculation happens ONCE, in C and other languages in its family,
the calculation in the for is executed each time through the loop.

The time saved is de minimis, and the time taken in setting up foo
(and, perhaps, forgetting that length is long and debugging an
overflow condition) is mostly a waste of time. Furthermore, since
length is a loop invariant in addition to adjustLength, an optimizing
compiler will make this a nonproblem.

This is Randy's whole case, and he conceals the thinness of this case
by posting things offline and making reference to them.


It was pointed out to me correctly, but not by you, that the
termination condition in the c for is, in an old-fashioned and clumsy
way, evaluated each time control passes to the top of the for loop.

It's not clumsy, or old-fashioned.   It's highly useful, when people
aren't too ignorant of its use (perhaps you are the aliterate one, or
even a brief foray into K&R would have enlightened you) to understand
it.

K&R have never been my holy book:

Feel free to substitute any competent book on C syntax or more general
programming using C as the underlying language.  I've yet to encounter
any respected title that doesn't explain, usually very early on for
those with short attention spans, the use of for loops.

Computer Thugs hate the basics, mostly because they never mastered the
basics.
.