Subject: Re: distinction?
From: Erik Naggum <>
Date: 2000/12/05
Newsgroups: comp.lang.lisp
Message-ID: <>

* Kellom{ki Pertti <>
| I have always been curious as to why you think so. My problems
| when I switch from Scheme to Common Lisp and back seem to be very
| superficial, e.g. whether to write "define" or "defun", whether to use
| #' or not etc. Otherwise the difference does not seem to be that big,
| and certainly the same mindset works for both languages.

  Well, that latter point is why you have no problems, but I can't write
  the kind of things I write in Common Lisp in Scheme at all.  If you
  write in a tiny little subset of Common Lisp that translates well into
  Scheme, you are simply not using Common Lisp very well, or, unlikely,
  you have built a Common Lisp inside Scheme, but that's such a waste
  that I can't believe anyone would do that, and I have never heard of
  anyone doing it, either.

| Admittedly I am more familiar with Scheme than CL, so maybe my coding
| style is just closer to some premordial proto-Lisp.

  It could be that you're simply writing Scheme in Common Lisp.  I have
  seen too many (reasonably) bright students who were first exposed to
  Scheme who never got out of the Scheme mindset, despite consistent and
  insistent cajoling and significant encouragement to learn to think
  more in Common Lisp terms when using Common Lisp.  The misguided idea
  that languages should be small seems to stick with them so much that
  at some level they refuse to learn more than some misconception of a
  "core" Common Lisp, and prefer to write out most everything else by
  hand whenever they need it.  (We see the same in some Common Lisp
  programmers who have a strong, irrational desire never to use loop,
  even where it is far more expressive and compact and efficient than
  whatever they write by hand.)

| The language communities and the typical way in which the languages
| are used are quite different in many respects, but on technical
| grounds Scheme and Common Lisp seem very similar to me.

  It is on technical grounds they are the least similar.  Superficially,
  the syntax and the names of many operators makes it possible to become
  and remain confused, since nothing else is similar to them, but if you
  see someone using, say, defun _inside_ a function, you just know they
  have not outgrown Scheme, yet.  There are so many traps and pitfalls
  between the two languages that one is better served thinking they are
  not similar at all.  Otherwise, you write code that uses each language
  to such a small extent that you could use just about _any_ language.

  "When you are having a bad day and it seems like everybody is trying
   to piss you off, remember that it takes 42 muscles to produce a
   frown, but only 4 muscles to work the trigger of a good sniper rifle."
								-- Unknown