Subject: Re: one small function From: Erik Naggum <email@example.com> Date: Thu, 07 Feb 2002 08:01:23 GMT Newsgroups: comp.lang.lisp Message-ID: <firstname.lastname@example.org> * "P.C." <email@example.com> | Guess the difference Sceme/Lisp are very small but important They are so large that someone who has been trained in Scheme has no hope of ever learning Common Lisp, because they _think_ the differences are very small despite strong evidence to the contrary, and because it is possible to write Scheme in Common Lisp, they will never be "offered" the necessary negative feedback necessary to "get it". I think the problem is that most people who have not been made aware of this fallacy at a young age have an unnerving tendency to think that they know something if it looks like something they know, and the less they _actually_ know what they think they know, the more they think something that looks the same to them, also _is_ the same. In a world of physical objects, this is probably not such a bad idea. The number of things you need to examine to determine that something is a duck is quite limited. This changes with man-made objects, and even more with purely man-made constructs like the infrastructure of a society or programming languages, where you have to be able to distinguish differences between _versions_ of what is actually _marketed_ as the same, For instance, if you plan according to the tax law or the Java version of a year ago, you are in trouble. This leads to a reversal of an important relationship between identity and details: In the physical world, if you find large similar properties between something new and something you know, you are quite justified in concluding that you know what it is, but in the man-made world, especially that of ideas, it is more important to look carefully after you have discovered large-scale similarities than before. For man-made things and ideas in particular, the belief that what looks the same is the same is an anti-intellectual attitude towards one's knowledge and actually betrays a lack of understanding of that which is believeed known. Also, since this belief is most probably not restricted to one particular area of knowledge, but is a result of methodological errors in reasoning and learning, there is no chance at all to make such a believer realize that he does not actually know what he believes he knows until he runs into a very serious problem that he cannot resolve well enough for comfort. Only when programming is made into a "team" effort which exposes newbies to the critical review that only gurus can provide, and gurus themselves acknowledge that new gurus may arise worth listening to, can the necessary feedback loops work well enough that good knowledge drives out bad. Today, we have a lot of people who are quite convinced of their own competence mainly because they have never been challenged beyond what they already know. The tragedy is that "looks the same, is the same" is not commutative. If you learned Common Lisp well and then found Scheme, it would be nothing more than some old home-made toy discovered in your parent's basement -- cute and all that, but not worth playing with for long, because all of the stuff you think a real programming language should have are simply not there. If you learned Scheme first and then found Common Lisp, it would seem just like Scheme, because what you have come to think of as a "programming language" is basically so little that you would not even comprehend all the stuff in Common Lisp that is not like Scheme at all. /// -- 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.