Subject: Re: self-hosting gc From: Erik Naggum <firstname.lastname@example.org> Date: Sat, 09 Mar 2002 03:44:21 GMT Newsgroups: comp.lang.lisp Message-ID: <email@example.com> * firstname.lastname@example.org (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.