Subject: Re: Allegro compilation warnings
From: Erik Naggum <>
Date: 2000/10/20
Newsgroups: comp.lang.lisp
Message-ID: <>

* Erik Naggum
| Well, first you dispense with the opiniated bullshit that it's
| "apparent nonsense".

* (Mario Frasca)
| Erik, please read what I write before attacking me.

  It's so ironic that you tell me this, because if _you_ can't even
  read more than one sentence at a time, you deserve to be attacked.
  The next sentence I wrote went:

    To see why, judge how likely it is that you listen to what I said
    after I branded your opinion that way first.

  Because I anticipated some morose response, I wrote this next:
    If you're really smart, it didn't affect you at all, figuring that I
    had my reasons to this very specific incident and that you could
    understand them -- the converse is not quite true for your reaction
    since it is not specific to anything anyone but you can determine.

  Can you please upgrade from "not really smart" to something like "at
  least not really dumb"?  Then _maybe_ I'll listen to you.  So far,
  this has been a waste of my time.

  As you decided to label the problems you have "apparent nonsense"
  and have continued to display an astonishingly irrational approach
  to this whole task, with irritation all over the place, _and_ you
  make the _incredibly_ moronic response to an _obvious_ joke at your
  expense, there is very little hope for you to pull yourself together
  and crank your cranium contents into operation.  But surprise me!

| can you display rational thoughts in front of such 'challenging' code:

  I have been a "software project firefighter" for 20 years because I
  tend to calm down in the face of disaster, danger, and problems that
  refuse to submit to any solution.  I get really pissed at "small"
  things like laziness and incompetence and unfounded assumptions, but
  that's because they aren't disasters, they're just sloppiness that
  could be prevented if the dickhead perpetrators had paid attention.
  I flat out _demand_ that other programmers have some similar traits:
  Get all worked up over some minutiae like LOOP or indentation rules
  for IF, but calm down, concentrate, focus, and think clearly and
  very rationally in the face of actual problems worth solving.  If
  you can't do that, you have failed my lithmus test for programmers,
  but _should_ be smart enough to realize that that means something.

| probably the only rational action is to do exactly what you said:
| print it and trash it.

  I actually said "use it for target practice".  Which is both much
  more violent than trashing it and at the same time much more calming
  since you don't want to destroy anything else in the process.  It is
  obvious that one has to print something out before using it for
  target practice, but your stupid rewrite of the joke into "trashing
  it" means that the printing out makes absolutely no sense.

| I see a difference here, but maybe I'm just being pedantic.

  Yes, and you missed the large print while getting upset over the
  small print.  Getting upset over the small print means attention to
  detail, and that's good.  Missing the large print means that your
  observational skills and rational approach to prioritizing your
  mental processes is sorely lacking, and that's not so good.

  To recap (the large print): The technique where you employ more and
  more of a language as you grow used to them must _naturally_ be a
  good approach even to understanding legacy code, with the _obvious_
  advantage that you have a guide to which features to look at next.

| you know something, this discussion did produce a good effect: I'm
| throwing away the sources I inherited and I'm writing this piece of
| software from scratch again.  not a big deal: just 72kb of lisp
| sources.

  Glad I could help.  That is just how I have made most of my money.
  I talked to an old friend the other day.  He had been unhappy with
  the realization that as he got better in his previous job, he was
  asked to do more and more "dirty work" and that it thus didn't pay
  off to become better.  The company he worked for lived off of the
  value produced by a 2 million line strong Fortran 77 system that
  needed continuous development.  And you consider 72K much?  It
  probably benefits greatly from rewriting in the first place, and the
  risk of doing so should be minimal.

  Please don't believe that 72K is a lot of code.  (72K _lines_ is
  getting there, of course.)  GNU Emacs 20.7 has 749K lines of C and
  Lisp code, some 25M total.  The 2.2.17 Linux kernel consists of more
  than 2.1 million lines of C code, 64.5M total.  A system I wrote
  single-handedly (with excellent code review along the way) in four
  months consists of 5200 lines (198K) of "infrastructure and support"
  code and 2700 lines (104K) of "application" code.  This is a _small_
  system in my view.  I'm _so_ not impressed or sympathetic to your
  72K and your plight.  Quit whining and go do some real work, now.

#:Erik, who wonders why he bothers with these whining kids
  I agree with everything you say, but I would
  attack to death your right to say it.
				-- Tom Stoppard