Subject: Re: one small function
From: Erik Naggum <>
Date: Thu, 07 Feb 2002 08:01:23 GMT
Newsgroups: comp.lang.lisp
Message-ID: <>

* "P.C." <>
| 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.