Subject: Re: What does LISP stand for?
From: Erik Naggum <>
Date: 1997/08/21
Newsgroups: comp.lang.lisp
Message-ID: <>

* William Paul Vrotney
| No I am not mistaken. ...
| Pay attention! ...
| For some reason that fact that I reminded us that the concept of type ATOM
| is still around in Common Lisp seems to bother you and a few others.

no, what bothers me, at least, is that you pretend that some distinction is
fundamental when it is not.  this is your mistake.  and, I might add, it's
getting ludicrous when you scream "pay attention" to others here, when you
so clearly don't do it yourself.  we're not debating this in comp.lang.c++.

| I am not harping on this I am only defending my explaination of why Lisp
| was called LISP and why lists and atoms were and still are important
| concepts in Lisp.  Thats all I was trying to say!

it's too much and too little at the same time.  you were talking about
lists, but I think you were grappling at the symbolic expression and trying
to say something about lists.  clearly, you're confused beyond reach, but
if you had confined yourself to tell the poor requestor that the "list" in
LISt Processing refers to the list of the symbolic expression, we might be
getting somewhere.  but that is not what you said.

| But I am not sure what you are trying to say.

I'm refuting your claim.  I'm pointing out to you that it is false.  I'm
showing you where your claim falls apart.  I'm debunking yet another myth.
I'm saying that you should have stopped after the first sentence.  that's
what I'm trying to say.  may I suggest that a "pay attention" is in order?

| Are you trying to say that types LIST and ATOM is *not* an exhaustive
| covering of all Common Lisp types?  Are you trying to say that the notion
| of ATOM is not important in Common Lisp?  Are you trying to say that the
| type ATOM and function ATOM are not necessary?  Please be more specific.

when somebody is refuting some claim, that doesn't mean that they are
thereby _claiming_ whatever bogus opposites of the refuted claim somebody
may conjure up.  I consider the tendency among some people to react to a
"no, that's not true" by hurling accusations back that everything they hold
as dear and obvious truths and that they consider to follow from whatever
it is they believe is _also_ contradicted in a single negation of a single
proposition to be quite astonishingly anti-intellectual.

in particular, I'm not at all interested in what you have built on top of
your confused understanding of LIST and ATOM, nor am I interested in
answering any of your stupid questions -- that would serve only to take
this discussion even further off track.  I think it's indicative of your
serious confusion that you feel the need to ask them.  you are no longer
defending a view of Lisp, you are defending yourself, and doing it badly.

| By the way, what exactly is the mistake you are referring to?

that the Common Lisp type system is _fundamentally_ partitioned into the
two _types_ LIST and ATOM.  it isn't.  from what I can see from LISP 1.5
Programmer's Manual, your claim wasn't even true in 1962.

[lots of bogosity deleted to save space and time.]

| Perhaps I should have said
|     "In Lisps in general at a high level the only two data types are the
|     *list* and the *atom*.  The most important atom is a *symbol* which
|     refers to some world entity."

it is _still_ wrong.  what you could have said was something like:

    Lists in Lisp consist of objects of various types, including lists.

but this is no more _worth_ saying than

    Arrays in Lisp consist of objects of various types, including arrays.

etc for _all_ the container types in Lisp.  there's nothing "high level"
about talking about the list as if it were fundamentally important for the
type system.

however, the list _is_ fundamentally important to the s-expression, and
what I think you're grabbing at, but can't reach in your confused state,
is something along the lines of the following shot from the hip:

    In Lisp, the fundamental programming concept is the `symbolic
    expression', or `s-expression' for short.  A s-expression is either an
    atom or a list of s-expressions.  An object of any type except list is
    called an `atom'.  A list whose the first atom is a symbol is called a
    form, and that symbol defines the meaning of the whole form.  A Lisp
    program is made up of many, nested forms.  The Lisp type system has a
    large number of types in addition to symbols and lists, both atomic and
    containers, including numbers of many types, vectors, arrays, and
    strings, all of which form a type hierarchy.  Lisp has functions that
    work on objects at any level of this hierarchy.  Despite the importance
    of the list for s-expressions, modern Lisp programs use lists sparingly
    at run-time.  The s-expression is a convenient way to represent code
    (functions) as objects in the language itself.  It follows that most
    types can be represented in text form and that they can be printed from
    a Lisp system.  This is often referred to as "code and data are
    interchangable in Lisp", but this applies to the uncompiled form of the
    code, only.  Lisp is naturally a compiled language, even though it also
    follows from the above that it is easy to write an interpreter.  Toy
    Lisps are frequently interpreted-only.  Unfortunately, most beginners
    only play with the toy Lisps -- many a myth has thus been perpetuated.

*whew*  stuffing Lisp into a small box is damn hard work.

man who cooks while hacking eats food that has died twice.