Common Lisp is not a language

by **Ron Garret** » Thu, 19 Apr 2007 04:35:20 GMT

In article < XXXX@XXXXX.COM >, Edi Weitz < XXXX@XXXXX.COM > 





Common Lisp is not a language, it is a family of languages.

From  http://www.**--****.com/ :

"Common Lisp was designed as a description of a family of languages."

rg

by **Rainer Joswig** » Thu, 19 Apr 2007 05:03:33 GMT

In article < XXXX@XXXXX.COM >,






What about ANSI Common Lisp?

-- 
 http://www.**--****.com/

by **Kent M Pitman** » Thu, 19 Apr 2007 11:21:10 GMT

ainer Joswig < XXXX@XXXXX.COM > writes:

As I recall, the referenced paragraph, quoted here, and the entire
section it was in, was written by a coalition of people as a kind of
consensus view of the history. I'm not sure whether the individual
quoted sentence is due to me, and even if it was, it was a long time
ago, so my views here are through the haze of memory, as augmented
by the obvious issues of textual context:

| In April 1981, after a DARPA-sponsored meeting concerning the
| splintered Lisp community, Symbolics, the SPICE project, the NIL
| project, and the S-1 Lisp project joined together to define Common
| Lisp. Initially spearheaded by White and Gabriel, the driving force
| behind this grassroots effort was provided by Fahlman, Daniel Weinreb,
| David Moon, Steele, and Gabriel. Common Lisp was designed as a
| description of a family of languages. The primary influences on Common
| Lisp were Lisp Machine Lisp, MacLisp, NIL, S-1 Lisp, Spice Lisp, and
| Scheme. Common Lisp: The Language is a description of that design. Its
| semantics were intentionally underspecified in places where it was
| felt that a tight specification would overly constrain Common Lisp
| esearch [sic] and use.

(Presumably we meant "research", not "esearch"... sigh.)

In historical context, there was a risk that the entire language
family containing the enumerated languages would not be selected by
DARPA as the language of choice for research. (As I recall it,
Interlisp had been proposed by some as the language most used. But
the little dialects got together and said "no, we're really all the
same language, you just can't see it".) The loose-knit coalition
papered over their differences and spun the story they were all a
single idea. The move succeeded, and these dialects displaced
Interlisp, rather than vice versa. However, with the 1984 publication
of CL, those dialects were also slowly obsoleted by CL, which CL did
not really "describe" so much as "supplant".

The only lingering sense in which CL remained in any sense a language
family, and I don't think anyone would have described it that way even
then, is that code was not easily ported from implementation to
implementation. The original language definition did not seriously
address portability, probably because no one had the patience for such
issues until they had used the language for a while. (I wrote a
conference paper on the subject and it was rejected as uninteresting
in that timeframe. I just don't think anyone thought consciously
about how the language and its portability mattered.) ANSI CL
corrected that deficiency, by making portability a real issue and
seriously attempting to address it.

But I don't think CL presents itself (other than in this stray
sentence) as itself a language family. Lisp is the name of the family
of languages. (Whether there are usefully nameable subfamilies, I
suppose, is an open question.)

(Note well: My opinion is no particular authority on the matter. I
WAS there, and WAS a first-hand observer, but my views as expressed
here are still just my personal opinions. I don't claim any special
credential of rightness just because of the "writeness" of my involvement.)

by **Ken Tilton** » Thu, 19 Apr 2007 15:01:59 GMT





The scary thing is that if you offset each character of "esearch" by two 
you get "google".

kt

-- 
 http://www.**--****.com/ 

"Algebra is the metaphysics of arithmetic." - John Ray

by **Ron Garret** » Fri, 20 Apr 2007 05:46:46 GMT

In article < XXXX@XXXXX.COM >,




I think that is quite significant, and I'm apparently not the only one 
who thinks so.  I draw your attention to:

 http://www.**--****.com/ 

and in particular the following exchange between myself and Pascal 
Costanza:

PC: You're certainly aware of the fact that Common Lisp is not a 
programming language, but a family of languages. 

RG: I knew that Lisp was a family.  I was unaware that Common Lisp was 
considered a family, and not a single language.

PC: [Long excerpt from CTLT2 elided] And, more to the point, from the 
HyperSpec (Section 1.1.2): "Common Lisp was designed as a description of 
a family of languages."

RG: I stand corrected. 

PC: That's a good start, because EVERYTHING ELSE FOLLOWS FROM THERE.  
[Emphasis added.]

rg

by **Ken Tilton** » Fri, 20 Apr 2007 08:18:30 GMT






You mean because sockets and FFI were not standardized, and in a few 
places in those 1000 pages things get left up to implementations? 
Aggravation does not rise to the level of "hey, those are two different 
languages!" though I certainly felt as if that might be the case porting 
from Symantec C to CodeWarrior C.


Was the author writing under the cloak of infallibility, channeling the 
word of G*d, and is our Talmudic interpretation of those awkward words 
precise? The legislative history shows that CL got designed to address 
concerns of The Big Customer over language fragmentation, so it is hard 
to imagine an intent other than to define one language. The next step 
was a pretty tight ANSI standard language specification.

Too easy? (I know, it is mroe fun being contrarian.)

kt

-- 
 http://www.**--****.com/ 

"Algebra is the metaphysics of arithmetic." - John Ray

"As long as algebra is taught in school,
there will be prayer in school." - Cokie Roberts

"Stand firm in your refusal to remain conscious during algebra."
    - Fran Lebowitz

"I'm an algebra liar. I figure two good lies make a positive."
    - Tim Allen

by **Rainer Joswig** » Fri, 20 Apr 2007 17:37:28 GMT

n article < XXXX@XXXXX.COM >,
Kent M Pitman < XXXX@XXXXX.COM > wrote:

If ANSI Common Lisp is a family of languages, this family
would have member languages (unless there is the empty
set of languages).

Is OpenMCL a programming language? LispWorks? Or just
extended/simplified implementations of ANSI CL?
Are there other descriptions of languages based on
ANSI Common Lisp? Hmm.

Mostly I see in the manuals of current Common Lisp systems:

a) we (try to) do ANSI Common Lisp
b) here are some places where we don't do ANSI CL
c) here we say how we implement some ANSI CL
d) we extend/simplify ANSI CL with the following ...
e) this is our library

a), b), and c) is just ANSI CL.

Now would d) make it a language?

What could be in d) ?

1) language extensions like tail recursion elimination
2) added special forms
3) new built-in data types (decimal arithmetic)
4) parallel computing constructs

d) could also describe a sublanguage. Say a Common Lisp
without CLOS.

--
http://lispm.dyndns.org

by **Pascal Bourguignon** » Fri, 20 Apr 2007 20:29:42 GMT

Ron Garret < XXXX@XXXXX.COM > writes:




In addition, one can implement a subset of Common Lisp and all it
rightly and legaly a "subset of Common Lisp", therefore Common Lisp an
indeed be desribed as a family of languages, the union of all its
subsets.

-- 
__Pascal Bourguignon__                      http://www.**--****.com/ 

"Specifications are for the weak and timid!"

by **Kent M Pitman** » Sat, 21 Apr 2007 00:02:44 GMT

ainer Joswig < XXXX@XXXXX.COM > writes:

I think it's entirely reasonable to take the position personally that
Lisp either is or is not a "language family", that Common Lisp either
is or is not a "language", that Scheme is or is not part of one of
those categorizations, etc. I certainly don't mean to contest that
anyone believes what they believe, nor that they get value for doing
so.

I often don't use the terminology in the way most people seem to, so
who am I to tell another that they shouldn't?

I do think sometimes people see a written document and try to
interpret it in an overly specific way. I don't like to say I have
the uniquely right interpretation as much as to say "please don't
assume your own reading is the only possible reading". Sometimes I
think it doesn't occur to people that the thing they so carefully read
even MIGHT have meant something other than what they infer. And it's
in that light that many of my remarks should be taken.

I don't personally approach the problem this way, although I think these
are good thought questions. I find the terminology manipulates me, and I
prefer to pick terminology to match what I'm thinking.

I think I think of those things you're remarking on as dialectal
variations. That is, I look to the social behavior of ahering to a
common reference as evidence that they are a common language. The day
any of those implementations says "we don't care what ANSI CL says" is
the day it's not a CL. The day any of those implementations say "we
don't care what the Lisp community does" is the day it's not a Lisp.
Exactly because of this, I generally don't see Scheme as Lisp. Not
because of the similarities or differences with other Lisps, but
because of the social behavior of not caring whether and how a change
made to the language will affect or relate to other Lisps.

Most commonly, though not consistently, I personally refer to Lisp as
a language, CL as a dialect of Lisp, and things like MCL and LispWorks
and Allegro as implementations of Lisp. Some may say Lisp is not a
language, since it designates no specific dictionary of words, but by
the same claim, there is no English, only British and American. I
reject that. I find it more natural to say people speak dialects, in
part to remind myself that the claim that one can speak a "neutral
version" of a language rather than a "dialect" is non-sensical. Like
everyone claiming they have no spoken accent, and that only others
(who don't have their own neutrality) have an accent.

It's trivially true that any language that inherits from another
language creates a language family. But one must be careful about
that. Familyness cannot be said to be transitive or we will follow
our family trees around and every one of us will be found to be of one
family. Which is ok. But if that's all you mean by "family", then
give it up, the word is useless. Words are useful only if you can
make a distinction by having used or not used them. It must be
possible to make breaks among languages, and so I make that break
subjectively. To me, it relies on the intent of the designer and
community as to how referencing will work. Human families are the
same. Some people think second cousins are family; others don't even
keep up with first cousins. And even within the same "family",
individuals disagree. But this doesn't negate the meaning of the
term, it just means you have to establi

by **rpw3** » Sat, 21 Apr 2007 11:36:02 GMT

ainer Joswig < XXXX@XXXXX.COM > wrote:
+---------------
| Mostly I see in the manuals of current Common Lisp systems:
| a) we (try to) do ANSI Common Lisp
| b) here are some places where we don't do ANSI CL
| c) here we say how we implement some ANSI CL
| d) we extend/simplify ANSI CL with the following ...
| e) this is our library
| a), b), and c) is just ANSI CL.
+---------------

The CLHS speaks to this:

http://www.lisp.org/HyperSpec/Body/sec_1-5-1-1.html
1.5.1.1 Required Language Features

http://www.lisp.org/HyperSpec/Body/sec_1-5-1-5.html
1.5.1.5 Conformance Statement
...
If the implementation conforms with some but not all of the
requirements of this standard, then the conformance statement
shall be: ...[prototype]...

Also see this glossary entry:

http://www.lisp.org/HyperSpec/Body/glo_p.html#purports_to_conform
PURPORTS TO CONFORM v. makes a good-faith claim of conformance.
This term expresses intention to conform, regardless of whether
the goal of that intention is realized in practice. For example,
language implementations have been known to have bugs, and while
an implementation of this specification with bugs might not be
a conforming implementation, it can still purport to conform.
This is an important distinction in certain specific cases; e.g.,
see the variable *features*.

And this Variable entry:

http://www.lisp.org/HyperSpec/Body/var_stfeaturesst.html
...
:ansi-cl
If present, indicates that this specification has been
adopted by ANSI as an official standard, and that the
implementation purports to conform.

I would suspect that almost all popular CL implementations
*at least* "purport to conform" to the ANSI Standard.

+---------------
| Now would d) make it a language?
| What could be in d) ?
| 1) language extensions like tail recursion elimination
| 2) added special forms
| 3) new built-in data types (decimal arithmetic)
| 4) parallel computing constructs
+---------------

The CLHS speaks to this:

http://www.lisp.org/HyperSpec/Body/sec_1-5-1-3.html
1.5.1.3 Documentation of Extensions
A conforming implementation shall be accompanied by a document that
separately describes any features accepted by the implementation
that are not specified in this standard, but that do not cause any
ambiguity or contradiction when added to the language standard.
Such extensions shall be described as being ``extensions to Common
Lisp as specified by ANSI <<standard number>>.''

So depending on the exact style of integration with base CL,
all of your "d)1-4" *might* be permissible extensions to CL.

But watch out for the restrictions here:

http://www.lisp.org/HyperSpec/Body/sec_1-6.html
1.6 Language Extensions
...
An implementation can have extensions, provided they do not
alter the behavior of conforming code and provided they are
not explicitly prohibited by this standard.
...
The following list contains specific guidance to implementations
concerning certain types of extensions.

- Extra return values ... [prohibited] ...
- Unsolicited messages ... [prohibited] ...
- Implementation of macros and special forms
Macros and special operators defined in this standard
must not be functions.

+---------------
| d) could also describe a sublanguage. Say a C

by **Kent M Pitman** » Sat, 21 Apr 2007 13:02:33 GMT

 XXXX@XXXXX.COM  (Rob Warnock) writes:


An alternative might be to start from ISLISP and work up.

ISLISP is not specifically ANSI CL compatible, mind you, but I like to
think of it as "culturally compatible" with ANSI CL... Certainly
moreso than, say, Scheme.  It's quite small, and lacking a lot of the
power of CL, but what it has got is in a style that's similar to CL.
Whether it would suit any given purpose is hard to know, which is why
you'd have to look for yourself.

by **rpw3** » Sat, 21 Apr 2007 13:48:30 GMT


+---------------
|  XXXX@XXXXX.COM  (Rob Warnock) writes:
| > Note: From time to time I have noodled around with the notion of
| > defining a subset of CL which meets the constraints of CLHS 1.7
| > and is still sufficiently rich to be interesting and/or useful
| > [e.g., for "scripting" or CGI or the like]. It's not as easy as
| > it might at first appear. Little fiddly bits in one corner of
| > the language interact in subtle ways with fiddly bits in other
| > corners of the language.
| 
| An alternative might be to start from ISLISP and work up.
+---------------

I *have* actually considered that. But after several cursory readings
of the ISLISP spec, I have come to the provisional conclusion that
ISLISP, while quite interesting *in its own right*, isn't really
a suitable candidate for "a subset of Common Lisp as specified by
ANSI X3.226" under the constraints of CLHS "1.7 Language Subsets".
For one thing [and this is a big one!], as far as I can tell, getting
a non-trivial ISLISP program to load into a CL implementation would
require at least *some* sort of "compatibility package" to have been
pre-loaded into the CL implementation, something that is expressly
excluded from the definition of a CL subset by CLHS 1.7.

That is, to me at least, whether there even *can* be one or more
useful "subsets of CL" in the strict CLHS 1.7 sense is separate
and very different question from that of what "a good small Lisp"
could/would/sholud look like... and whether Scheme or ISLISP or
XYZ [name your favorite] is a good starting point for that. Both
questions are interesting, but the one I was addressing in the
above-quoted "Note" was the former, not the latter.

By the way, in the interest of exposing a little of my motivation
for looking into the "subset" question, let me say that I am
perfectly happy these days to use a "full" Common Lisp for almost
all of my Lisp-family needs [e.g., I haven't written any new Scheme
code for several years now!], but there are a *few* situations
where my usual CL environment (CMUCL) cannot run [or at least not
conveniently enough for it to be feasible] and it would be very
nice to have an implementation of a small subset of CL which
*could* run. Being a "subset" in the CLHS 1.7 sense would mean
that most of the code could be developed & tested in the "full"
environment.  It would also make it more likely to be portable
to some other "full" environment than the one I currently favor.

Plus, I have yet to hear of anyone who has managed to come up
with a non-trivial yet useful "subset of ANSI CL" in the strict
CLHS 1.7 sense. It's a bit of an intellectual challenge.

+---------------
| ISLISP is not specifically ANSI CL compatible, mind you, but I like
| to think of it as "culturally compatible" with ANSI CL... Certainly
| moreso than, say, Scheme.  It's quite small, and lacking a lot of the
| power of CL, but what it has got is in a style that's similar to CL.
+---------------

Based on my somewhat-limited reading of the spec, I quite agree
on all of these points.

+---------------
| Whether it would suit any given purpose is hard to know, which
| is why you'd have to look for yourself.
+---------------

(See the above...)


-Rob

-----
Rob Warnock			< XXXX@XXXXX.COM >
627 26th Avenue			<URL: http://www.**--****.com/ ;
San Mateo, CA 94403		(650)572-2607

by **Kent M Pitman** » Sat, 21 Apr 2007 15:33:39 GMT

 XXXX@XXXXX.COM  (Rob Warnock) writes:


Oh, it definitely is not a subset.  I was just suggesting it if you 
wanted a small Lisp dialect that was similar to CL for an independent
scripting purpose.  


Ah.  Indeed, if you want to move your programs back and forth, it gets
a bit trickier.

 
Paul Robertson did work on this at one point and did the best job of
outlining such a subset.  It was part of his review comments on the
standard.  I have that data somewhere offline, and keep meaning to put
it online...

by **Kent M Pitman** » Thu, 26 Apr 2007 09:39:14 GMT

Kent M Pitman < XXXX@XXXXX.COM > writes:


Oh, that comment by Paul Robertson is _already_ online... I guess I had
dredged it up previously and had forgotten.

   http://www.**--****.com/ 

It's the best stab at a theory of subsets I've seen anyone do.

by **Ken Tilton** » Thu, 26 Apr 2007 10:04:38 GMT





That's a great window on the do-or-die mood driving the development of 
CL. Here's my favorite line:


Disaster? Ha! Lisp! It's mine! It's all mine!!!!! MWUAHAHAHAHAHAAAA!!!!

(And we prefer "smug Lisp weenies".)

kenny

-- 
 http://www.**--****.com/ 

"Algebra is the metaphysics of arithmetic." - John Ray

"As long as algebra is taught in school,
there will be prayer in school." - Cokie Roberts

"Stand firm in your refusal to remain conscious during algebra."
    - Fran Lebowitz

"I'm an algebra liar. I figure two good lies make a positive."
    - Tim Allen

Common Lisp is not a language

Common Lisp is not a language

Jump to:

Next

Common Lisp is not a language

Re: Common Lisp is not a language

Re: Common Lisp is not a language

Re: Common Lisp is not a language

Re: Common Lisp is not a language

Re: Common Lisp is not a language

Re: Common Lisp is not a language

Re: Common Lisp is not a language

Re: Common Lisp is not a language

Re: Common Lisp is not a language

Re: Common Lisp is not a language

Re: Common Lisp is not a language

Re: Common Lisp is not a language

Re: Common Lisp is not a language

Re: Common Lisp is not a language

Similar Threads:

Who is online