Re: Survey: Do you use the "2" in Lisp-2?

On Jun 5, 11:51 am, Zach Beane <x...@xxxxxxxx> wrote:
I came across approximately this statement yesterday:

Lisp-2 programmers avoid using the same names for functions and
variables.

...

• Why You should Not Use The Jargon Lisp1 and Lisp2
http://xahlee.org/emacs/lisp1_vs_lisp2.html

plain text version follows.
--------------------------------------------------

Why You should Not Use The Jargon Lisp1 and Lisp2

Xah Lee, 2008-01-10

Someone (Propon...@xxxxxxx) wrote:

Having read Touretzky's introduction and the first half of Paul
Graham's On Lisp, I'm wondering what the advantages of a Lisp-2
are over a Lisp-1

It seems to me that a Lisp-2's ability to use a single symbol to
represent both a function and a value is a minor advantage,
although I'm sure some regard it as a disadvantage. On the other
hand, a Lisp-2 requires the clunky, IMHO, #' operator and cannot
have a elegant, universal DEFINE like Scheme's.

Yet I've heard that a Lisp-1's macros are necessarily less
powerful than those of a Lisp-2. Is that true? Are there some
other big advantages of a Lisp-2 that I'm missing?

Please try to avoid the jargons lisp1 and lisp2.

Recently i have just wrote a longish essay on the harm of jargons in
functional languages. The jargon lisp1 and lisp2 is one of better
example that illustrate the issue.

• The jargon is opaque. The words do not convey its meaning.

• Being a opaque jargon, it is often used subconsciously by people in
a group, to communicate that they are in-group. (a class-
differentiation strategy of human animals; as is much of slang's
purpose) And consequently, these jargons are thrown about often
without the writers actually understanding, or wishing to discuss
about it in any way.

Further, this issue is relatively minor, having little real-world
practical impact. It is not unlike a war about which end of egg one
should crack. (i.e. big endian vs little endian; See: Gulliver's
Travels. PART I — A VOYAGE TO LILLIPUT, Chapter 4)

Why is this issue minor? Consider it broadly in human animal's
computing activities. I give 2 examples:

Consider that in the 1960 people went to moon. (Moon landing) Imagine
what complexities involved in the physics, mathematics, computation,
at a time when computer are some one thousand times slower than today,
using punch-cards, and there are not much of computer languages, not
even modular programing.

For another example, consider today's PHP language. Linguistically, it
is one of the most badly designed language, with many inconsistencies,
WITH NO NAMESPACE MECHANISM, yet, it is so widely used that it is in
fact one of the top 5 most deployed languages. If one of PHP or lisps
and all associated applications written in them is to suddenly
disappear from the face of this earth as a catastrophic punishment
from Zeus, and all the leaders of nations is to have experts to assess
the damage as they do with natural disasters, it is probable that PHP
would be a order of magnitude greater loss.

Now, suppose we narrow the scope of “lisp1 vs lisp2” to its context:
computer language design. There are many issues in language design.
For example: dynamic scope vs lexical variable scope, various models
of typing systems (dynamic, static, variable/value based, algebraic
types, no types, with or without inference system), computing paradigm
(OOP, Functional, procedural, pattern matching, database), evaluation
model (greedy vs lazy) ... etc. Among all language design issues, the
“lisp1” vs “lisp2” is really one of the least significant, which
actually arise practically only in Lisp due to its peculiar concept of
its “symbols”.

The existence of a name to a concept or idea, especially a opaque
jargon, tends to get people to throw the name and argue about it
unnecessarily.

To people in the lisp communities, please stop using the term. If
necessary, say Common Lisp's model or Scheme Lisp's model, or, use a
communicative term like multi-meaning-space and single-meaning-space.

------------------------------
The “Why” of “multi-meaning-space”

Now, in the following, i wish to discuss some associated issue. In
particular, thoughts on how multi-meaning-space came about.

There's a curious question. Why is the “lisp1 vs lisp2” happens only
in lisp, and we don't have “perl1 vs perl2”, “java1 vs java2”, “ML1 vs
ML2”, or any language with a variation on this?

This has to do with the concept of lisp's symbol, which doesn't exist
in other languages (notably except Mathematica).

Now, a further question is then, why Common Lisp's symbol of a
particular name can have multiple meanings? (That is, a name in CL can
both be a variable and a function in the same block of code at the
same time. (This peculiar fact, we might give it a professional
terminology for ease of communication, and we might call it: Common
Lisp's multi-meaning-space, or just multi-meaning-space, meaning-
space.))

Now, the question is, why do Lisps before Common Lisp have this multi-
meaning-space feature?

I do not know much about the technical aspects of Lisp's history.
However, i can venture a educated guess.

Old Lisps's multi-meaning-space feature, just like so many of its
features (the cons cell for lists, the function “sort” being
destructive, and semi-regular syntax using nested parens, etc), is
simply designed as is without necessarily explicit, important,
rationales. In other words, it is probably a characteristic that
happens to be convenient, easy to implement, or not thought about at
the time, or simply went one way than the other. (as opposed to,
prominent issues that calls for conscious, explicit, decisions with
important ramifications, such as syntax (sexp), symbols system,
evaluation model, ...etc.)

Now, as i mentioned before, this (single/multi)-meaning-space issue,
with respect to human animal's computing activities, or with respect
to the set of computer design decisions, is one of the trivial, having
almost no practical impact. And, because some human animals, in the
history of their power struggle, is produced the byproduct of the
jargons “lisp1” and “lisp2”. And due to the fact that which end of egg
to crack is now blessed with a terminology that has all the
countenance of impartiality, it furnishes and fuels countless
arguments and fightings on this non-issue between the Scheme Lisp and
Common Lisp factions, even when the origin of the power struggle on
this particular issue (the Common Lisp Standard) has long died. (more
specifically, every few months the issue will rise up in
comp.lang.lisp or comp.lang.scheme, with all colors and types of
activities from sincere to trite to re-examination to political
struggle to pacification.)

Note: for the technical details of the Common Lisp's meaning-space,
and the origin of the jargons “lisp1” and “lisp2”, see: Technical
Issues of Separation in Function Cells and Value Cells, by Richard P
Gabriel, Kent M Pitman, 1988.

------------------------------
FAQ, and The Meaning Of Name Space

Xah Lee, 2008-10

Q: The terms “Lisp-1” and “Lisp-2” were invented to expressly *avoid*
mentioning Common Lisp or Scheme, therefore we shouldn't use the terms
such as Common Lisp model or Scheme model to describe it.

The creation of these terms is in a context of a political struggle.
Namely, in creating the Common Lisp standard, Kent Pitmant has
tirelessly and repeatedly pointed out in the past decade here.

As i mentioned in the article, the political context for the birth of
lisp1/lisp2 is over, about 2 decades ago.

Except when discussing history, there's no need to stick with the
jargon lisp1 and lisp2.

If fact, i argued, if not for so much of the colorful jargon “lisp1/
lisp2”, the issue wouldn't even be much noticeable as it is relatively
unimportant. Common Lisp today is multi-meaning-space, and Scheme Lisp
is single-meaning-space. That's just a language fact and there's not
much one can do or want to do much about that in practice.

Also, another point Kent has mentioned is that people in the community
naturally picked up these terms. Actually, in my opinion, the
popularity and continued use of these terms has much to do with Kent's
promotion. In the past decade in “comp.lang.lisp”, he constantly
reminds people of his article, and even explicitly requests others to
use the terms Lisp1 and Lisp2, as opposed to other terms people used
when discussing this issue, such as “Common Lisp way” or “Scheme way”.

Q: Lisp does not use the term “name space” differently from other
languages. The meaning is the same, only the implementation details
are different.

Namespace are the spaces for names. For example, you might have a
variable/subroutine/function/class named “CreateSound”, but this could
be just defined in your file, or it could be imported from a package/
module/library, or another package/module/library could also have such
a entity called “CreateSound”. This is when the name space concept
came from. For those curious, the “space” part of the terminology came
from mathematics, e.g. vector space, topological space. It effectively
means a “set”. The reason that “space” and “set” are often synonymous
is due to the study of geometry, because a space is a set of points.

The name space concept is tightly connected with the language's
library/package/module system. In emacs lisp, PHP, and Scheme Lisp,
for examples, these languages actually do not have a name space
mechanism, so that you have to create unique names for every function
or variable you write. (Note: PHP v5.3 (2008-10) and Scheme R6RS
(2007-08) both introduced name space mechanism but isn't in common use
yet) In most other langs (e.g. Perl, Python, Mathematica), there are
name space mechanisms, so that you could call a function in some
library using full path, or that you could call that function without
full path by “importing” the function's name into your current file's
name space.

However, having a name space system still does not solve the problem
of unique naming. That is, someone could write a library named Sound
with a function named CreateSound, but someone else could also have
written a library and function of exactly the same name. So, when 2
programs use CreateSound, even though their source code may be
identical, they might behave very differently. (this is a problem for
example in emacs, where lots of people have written a module named xyz-
mode (e.g. Javascript-mode), competing for the same name xyz-mode, or
else using creative and less intuitive names to avoid name conflicts
(e.g. javascript, js, js2 modes, xml vs nxml, html vs html-helper,
perl vs cperl, ... etc.))

Java solved the uniqueness problem by adopting the domain name system
for library names, as a convention. So, if Joe writes a package, by
convention he should name his package something like “com.joe-
bloke.sound”. This domain name system has been adapted in few other
language systems too (e.g. XML namespace).

With regards to lisp, in emacs lisp for example, the lack of name
space is a major problem, and is also a major problem of Scheme Lisp
( Scheme Lisp spec 6 tried to fix this problem but not without huge
controversy of the design). And as far as i understand from hearsay of
gossips here, it is also a major problem for Common Lisp.

The above is a brief introduction on the concept of name space as it
is used, and some of its issues.

Now, the jargon lisp1 and lisp2 refers to a concept entirely different
from name space. It has to do with what lisp calls a symbol's
“function cell” or “value cell” (note: as is given by Kent's article
title “Technical Issues of Separation in Function Cells and Value
Cells”). What these function cell and value cell basically means the
value of lisp language's var/function/subroutine/class. (Note: var/
function/subroutine/class are typically called a “name” in computer
languages but in lisp is called “symbol”.) The “function cell” and
“value cell” is effectively a “meaning space” (or “value space”).

Xah
∑ http://xahlee.org/

☄
.

Relevant Pages

  • Re: Oft-shared (perhaps?) Impressions of a Lisp Newbie
    ... by what I have heard about that language. ... as with Lisp and Java, ... That's Emacs-lisp, not Common Lisp, major differences, even ... If you like Emacs as ...
    (comp.lang.lisp)
  • Re: An Acceptable Lisp
    ... improvements that could be made to Common Lisp, ... By universal [Lisp] I mean the one, which will be accepted by all the ... Surely, I don't know, if such a language is at all possible, and, even ... Speaking about high-level, I know, that I've made an undersupported ...
    (comp.lang.lisp)
  • Re: A "killer" macro
    ... Or perhaps Lisp doesn't have one thing ultra- ... But it's true because of macros. ... indistinguishable from native Lisp - extend the language itself. ... it is because Common Lisp has extensibility at many points built in. ...
    (comp.lang.lisp)
  • Re: LISPPA
    ... >> do in Common Lisp with code that runs about as fast. ... Fortran or C or some such language. ... modern Pascal programming because I haven't written any Pascal ...
    (comp.lang.lisp)
  • Re: ILC2005: McCarthy denounces Common Lisp, "Lisp", XML, and Rahul
    ... >> the language should be available to users. ... In the design of Common Lisp, I asked Dave Moon (one of the architects ... Now, there are good kinds of low-level, like the way that floats are ...
    (comp.lang.lisp)