Subject: Re: Which one, Lisp or Scheme?
From: Erik Naggum <>
Date: 1997/01/31
Newsgroups: comp.lang.lisp,comp.lang.scheme
Message-ID: <>

* Michael Sperber
| Some misconceptions about Scheme from the view of CL programmers need
| clarification.

that may be, but please do not add more of them.

| >>>>> "Erik" == Erik Naggum <> writes:
| Erik> in Scheme, I must implement my own `member' with `string-equal'
| Erik> as the predicate.
| In Scheme, equal? works on strings.  No need to.

`equal' is case sensitive.  `string-equal' is not.  `equal?' in Scheme is
also case sensitive.  if this is not sufficient, choose a different
function, and get the point.

| Erik>  in like manner, I must reimplement everything else I
| Erik> need with a higher level of abstraction than Scheme provides.
| At least that is easy in Scheme.

sigh.  it may be hard, it may be easy.  in Common Lisp I don't have to.

| Erik> (1) because Common Lisp recognizes that a single namespace for functions
| Erik> and variables is bad for you.
| Again, that's an assertion without any proof.  Multiple namespaces
| greatly complicate dealing with names conceptually, especially when
| the same name has multiple bindings with disjoint meanings.  Possibly
| a matter of taste, admittedly.

where was the first "assertion without proof"?  your own?

| Erik> `defsetf' was mentioned.
| defsetf is trivial to define with Scheme high-level macros.

again, you need to roll your own.  all those "trivial" things add up.

| Erik> however, functions aren't normally values of variables.  this is
| Erik> seldom as useful as Schemers think it is.
| Erik, you should have asked a question.  It is immensely useful all the
| time.

because in Scheme, you have no other choice.  if you need it in Common
Lisp, you've implemented a different evaluation model before all those
trivial issues in Scheme have been implemented.

| I'd be happy to send to oodles of source code where having to use funcall
| would greatly screw up the code.

"greatly screw up the code"?  misconceptions, eh?  you're marketing.

| Erik> Scheme is a relatively low-level Lisp.  you _can_ build tall
| Erik> abstractions, but you run into many serious problems in scaling,
| Such as?

lack of a standard package system, for starters.

| Erik> not to mention the fact that Scheme is a language of bare
| Erik> necessities, like living in a cave, while Common Lisp is a
| Erik> language of complex societies where all the infrastructure you
| Erik> want to take for granted is indeed already implemented.
| As far as infrastructure for building abstractions is concerned, I
| want (and need) call/cc and macros.  So?

as if Common Lisp didn't have macros.  sheesh!

call-with-current-continuation is unique to Scheme.  somehow, people can
actually get work done in other languages.  listening to Schemers, I wonder
how this is at all possible without call-with-current-continuation.  could
it be that Scheme has removed all the _other_ mechanisms and replaced them
with a single very complex idea that is then used to reimplement them all?

in Scheme, you have to implement a lot of minor stuff.  this creates one
Scheme environment per user or group of users.  such is indeed the case.
in Common Lisp, it's there.

1,3,7-trimethylxanthine -- a basic ingredient in quality software.