From ...
From: Erik Naggum <clerik@naggum.no>
Subject: Re: (describe-differences "Scheme" "Common Lisp")
Date: 1998/09/13
Message-ID: <3114703986711421@naggum.no>#1/1
X-Deja-AN: 390967258
References: <3602f224.338457185@news.newsguy.com>
mail-copies-to: never
Organization: Naggum Software; +47 8800 8879; http://www.naggum.no
Newsgroups: comp.lang.lisp,comp.lang.scheme

* trashcan@david-steuber.com (David Steuber "The Interloper")
| Meanwhile, could someone please tell me the differences between Scheme
| and Common Lisp?  I am interested in syntax, primitive functions (like
| cons, car, cdr, etc), philosophical differences, size of interpreter
| implementation, that sort of thing.

  the difference is easily observed to be cultural.  you cannot compare
  cultures, you can only critique them.  the Common Lisp is generally very
  welcoming -- proof of that is that all the good ideas in Scheme were
  adopted in Common Lisp, but none of the bad ones, which Scheme sadly has
  refused to let go of.

| I keep getting suggestions to consider Scheme for a scripting language.
| There must be something to it.

  Scheme as a culture is much more combative than Common Lisp.  Schemers
  fight each other over how unclean they are, and only the purest of pure
  are admitted into the language -- only causing much _more_ unclean code
  to live in "user space", instead.  of course they fight everybody else
  with this cleanliness obsession, too: they have this _odd_ need to tell
  people to use Scheme instead of Common Lisp and impute to Common Lisp all
  of the unhealthy properties of Scheme were it ever to become as big and
  supremely useful to as many programmers and uses as Common Lisp is, but
  Scheme does _not_ scale well.  Scheme's beauty is that easily achieved by
  the immature, like kittens, puppies, baby seals, etc -- it's like a
  pedophile whose arrested sexual development has removed from him the
  ability to find attraction in the mature.

  avoid Scheme, but do know it first.  the same goes for other languages
  that made seriously misguided decisions at one point or another in their
  youth, like C, Perl, etc.  they have their uses, but the chance they
  overlap with your needs is _very_ small.  yet, you must learn to eschew
  their mistakes: "small is beautiful" is actually reversed: it is ver
  often the case the beautiful is small, but mere lack of size is no
  guarantee of beauty.  absence of features is _not_ good.  unless, that
  is, you're into job security and reimplementing several kinds of wheels
  in incompatible ways -- then you will find Scheme even better than C and
  Perl.  _nothing_ is standard in Scheme, except for the ridiculously small
  language core.  it also appears to be much more fun to implement Scheme
  than to actually use it.  the useful Scheme systems are often larger than
  the comparable Common Lisp systems, and this is no accident.  small
  languages require more verbiage to express the same ideas than large
  languages do, and on top of that much smaller parts of the system has
  been left to people who were paid _only_ to implement fundamentals well
  and optimize them heavily.  small languages violate the concept of
  division of labor.  only fools and geniuses insist on implementing their
  own languages, and you can never tell which is which until afterwards.
  in Scheme, as in C, every programmer has to be a genius, but often comes
  out a fool because he is so far from competent at every task required.

  I think I dislike Scheme more because of the way Scheme folks denigrate
  Common Lisp, which they invariably haven't used, than anything else.  a
  language that does that to good people's minds should carry a warning
  from the Surgeon General.

  I know C very well and Scheme well.  I became exhausted over the prospect
  of doing the same low-level cruft over and over and over.  Scheme is
  often worse than C in this regard, because you will mostly find
  interpreted Scheme environments, and abstraction carries a heavy
  performance penalty, so you need to be much too clever.  (this is like
  byte-compiled Common Lisps, which penalize you severely for using your
  own functions instead of the internal functions that are very heavily
  optimized.)

  if you really want to implement your own language, implement Scheme.  if
  you really want to _use_ a good language, choose Common LIsp.  corollary:
  implement Scheme in Common Lisp.

#:Erik
-- 
  http://www.naggum.no/spam.html is about my spam protection scheme and how
  to guarantee that you reach me.  in brief: if you reply to a news article
  of mine, be sure to include an In-Reply-To or References header with the
  message-ID of that message in it.  otherwise, you need to read that page.