Subject: Re: self-hosting gc
From: Erik Naggum <>
Date: Sat, 09 Mar 2002 03:44:21 GMT
Newsgroups: comp.lang.lisp
Message-ID: <>

* (Thomas Bushnell, BSG)
| My training in philosophy sometimes gets ahead of me, I'm afraid.  When
| confronted with a proposition that I believe to be false, I find the
| clearest most direct counterexample; the goal is never focused on the
| person, but only on the proposition.

  However, the space of things that are the negations of falsehoods is
  rather large and does not at all need to include any truth.  By picking a
  particular negation of a falsehood, you imply that your angle on what is
  false is sufficient to construct a counterexample.  This is generally not
  true.  When somebody is opposed to something, as is the case here, there
  is no telling what they actually would like propose.  By choosing some
  counter-example to a negative argument, you actually do impute intention
  and opinions about what a person would propose if they did not oppose
  your particular argument to begin with.  I have a very hard time seeing
  how this can _not_ result in hostilities.

| But that tends (again) to get ahead of me at times, and people interpret
| my zeal to demonstrate the falisty of some proposition as a zeal to
| demonstrate the foolishness of some other person.  But that is never my
| goal--though I grant that it can be near impossible to tell.

  If someone spends a lot of time demonstrating the falsity of something a
  person does not even express or imply, because the falsity you perceive
  is in your view a counter-argument to your position.  It is vital to keep
  track of positive and negative propositions and arguments in order to
  make this work.  Because the disproportionally larger space of a negative
  proposition, the negative of a negative may not even include the positive
  -- and that means that you must be very careful in countering arguments
  against your own position with counter-examples.  Instead, support your
  initial position.

| So this is a plea for good will.  In the particular case, I was trying to
| augment the previous poster's example, the point being that hand-typed
| tables can be maddeningly hard to get right at times, and even harder to
| find bugs in than normal code.

  However, it was not hand-typed.  Christ, give me a break.  First, if it
  were a hand-typed table, the line with l-p would not _all_ be lowercase,
  now, would it?  Second, just because something is in source form does not
  mean it was typed in by a human being.  It is far easier to read a case
  statement that actually contains the cases than code that builds a hairly
  table.  It is also far better to let the compiler writers worry about the
  optimization of table lookup than to do that grunt work yourself.  case
  is the right tool for the job.

  Of all the languages in which you can write code, the Lisp family offers
  the best way of all to produce some output and recycle it as code.  I do
  this a lot, because it is often easier to write Emacs Lisp code to write
  code for you than it is to type it in manually, anyway.

| I once had such a case in (IIRC) a table of parities for ascii.  There
| was a bug in one of the values, and it was so hard to notice in the midst
| of a big table, that (once I found the bug) I immediately replaced it
| with a table programmatically generated on startup.  *That* I could be
| sure was correct.

  Well, I prefer to produce source code in intimate cooperation with the
  editor, Emacs.

| In the instant case, however, my message was even worse, given the
| presence of a foolish carelessness in my part (since, of course,
| omitting the "I" was part of the original problem statement).

  I think your careless assumption that it was hand-typed should have been
  amply refuted by the presence of a systematic error that should unlikely
  have been made by hand.

  In a fight against something, the fight has value, victory has none.
  In a fight for something, the fight is a loss, victory merely relief.