For my introduction (which I'm now revising) I need a list of
programming language innovations first introduced in Lisp family
languages. My current list is:
recursive functions, dynamically allocated memory, garbage
collection, macros, generic functions, lexical closures.
I'm sure there are many I'm missing. And it's possible I'm wrong about
some of those I just listed. Any other ideas?
-Peter
--
Peter Seibel ·····@javamonkey.com
Lisp is the red pill. -- John Fraser, comp.lang.lisp
Peter Seibel <·····@javamonkey.com> writes:
> For my introduction (which I'm now revising) I need a list of
> programming language innovations first introduced in Lisp family
> languages. My current list is:
>
> recursive functions, dynamically allocated memory, garbage
> collection, macros, generic functions, lexical closures.
>
> I'm sure there are many I'm missing. And it's possible I'm wrong about
> some of those I just listed. Any other ideas?
Don't forget symbolic processing and code-as-data. Also dynamic
redefinition.
--
Duane Rettig ·····@franz.com Franz Inc. http://www.franz.com/
555 12th St., Suite 1450 http://www.555citycenter.com/
Oakland, Ca. 94607 Phone: (510) 452-2000; Fax: (510) 452-0182
Peter Seibel wrote:
> For my introduction (which I'm now revising) I need a list of
> programming language innovations first introduced in Lisp family
> languages.
What about XML? :-)
...In the sense that there's a printer, a reader, and print/read
equivalence such that data can be moved between machines (possibly
having incompatible internal representations). I got the impression from
the LISP 1.5 manual that users were already doing that way back then.
Lists as a built in data type and all the functions to manipulate them
seemed pretty important at the time. Most languages have many
different types of collections and plenty of ways to manipulate them
now.
Data and code are treated the same. You could build a list then
evaluate it like code. That was new at the time.
Dynamic scoping of variables, which is not used anymore for the most
part. I think emacs lisp might still have them.
The way people developed code was also very important. Lisp allowed
for incremental and interactive development in small pieces instead of
the huge boxes of cards we were using for Fortran code.
Don Wells
On Tue, 15 Feb 2005 22:49:02 GMT, Peter Seibel <·····@javamonkey.com>
wrote:
>For my introduction (which I'm now revising) I need a list of
>programming language innovations first introduced in Lisp family
>languages. My current list is:
>
> recursive functions, dynamically allocated memory, garbage
> collection, macros, generic functions, lexical closures.
>
>I'm sure there are many I'm missing. And it's possible I'm wrong about
>some of those I just listed. Any other ideas?
>
>-Peter
Don Wells wrote:
> Lists as a built in data type...
...
> Data and code are treated the same...
>
> Dynamic scoping of variables, ...
>
> The way people developed code was also very important. Lisp allowed
> for incremental and interactive development in small pieces ...
>
To paraphrase you and others: reflexiveness (reflexivity?),
higher-level abstractions, bottom-up programming, and RAD.
These may perhaps not have appeared first in Lisp, but they sure apply
(<g>), and are elegantly realized in, Lisp. They seem
buzzword-compliant too! What's the target audience again? ;-)
Olivier
"Don Wells" <···········@comcast.net> schrieb im Newsbeitrag
·······································@4ax.com...
...
> Dynamic scoping of variables, which is not used anymore for the most
> part. I think emacs lisp might still have them.
...
>
> Don Wells
>
...
I still feel a bit new to lisp - but - don't we have dynamic scoping? Using
defvar and let I think we have. CL-PDF for example seems to make heavy use
of it. For *one* variable in my current application I also make heavy use of
it. I even read somewhere that dynamic scoping has gone away from Lisp. Did
I understand something wrong?
(Of course this is non functional programming with side effects.)
Andreas
Andreas Thiele wrote:
> "Don Wells" <···········@comcast.net> schrieb im Newsbeitrag
> ·······································@4ax.com...
> > Dynamic scoping of variables, which is not used anymore for the
most
> > part. I think emacs lisp might still have them.
>
> I still feel a bit new to lisp - but - don't we have dynamic scoping?
Perhaps he means that when Common Lispers say "dynamic scope," they
really mean "indefinite scope and dynamic extent," as CLtL2 explains?
MfG,
Tayssir
"Tayssir John Gabbour" <···········@yahoo.com> writes:
> Perhaps he means that when Common Lispers say "dynamic scope," they
> really mean "indefinite scope and dynamic extent," as CLtL2
> explains?
Could you explain this? (I don't have CLtL2.) I don't see how a
variable such as that set up by (let ((*print-base* 10)) ..) can be
described as indefinite scope..?
--
Frode Vatvedt Fjeld
Frode Vatvedt Fjeld wrote:
> "Tayssir John Gabbour" <···········@yahoo.com> writes:
> > Perhaps he means that when Common Lispers say "dynamic scope," they
> > really mean "indefinite scope and dynamic extent," as CLtL2
> > explains?
>
> Could you explain this? (I don't have CLtL2.) I don't see how a
> variable such as that set up by (let ((*print-base* 10)) ..) can be
> described as indefinite scope..?
Fortunately it's free online:
http://www.supelec.fr/docs/cltl/clm/node43.html#SECTION00700000000000000000
"In addition to the above terms, it is convenient to define dynamic
scope to mean indefinite scope and dynamic extent. Thus we speak of
'special' variables as having dynamic scope, or being dynamically
scoped, because they have indefinite scope and dynamic extent: a
special variable can be referred to anywhere as long as its binding is
currently in effect."
"The term 'dynamic scope' is a misnomer. Nevertheless it is both
traditional and useful."
I've never quite understood it, because you'd think that a particular
binding (set up by LET) has dynamic scope, not indefinite.
For what it's worth, the Hyperspec agrees: "dynamic scope n. indefinite
scope along with dynamic extent."
MfG,
Tayssir
Frode Vatvedt Fjeld asks:
> > Perhaps he means that when Common Lispers say "dynamic scope," they
> > really mean "indefinite scope and dynamic extent," as CLtL2
> > explains?
>
> Could you explain this? (I don't have CLtL2.) I don't see how a
> variable such as that set up by (let ((*print-base* 10)) ..) can be
> described as indefinite scope..?
Compare
* (progn
(defvar *foo*)
(let ((*foo* 'outer))
(defun bar () (print *foo*))
(bar)
(let ((*foo* 'inner))
(bar)))
(values))
OUTER
INNER
with
* (progn
(let ((foo 'outer))
(defun bar () (print foo))
(bar)
(let ((foo 'inner))
(bar)))
(values))
OUTER
OUTER
The inner binding of FOO is not seen by (PRINT FOO) because
that from is outside of the (let ... )
The inner binding of *FOO* is seen by (PRINT *FOO*) even
though that form is outside of the (let ... ). That is what
is indefinite about the scope of *FOO*.
A different pair of examples illustrate the difference
between indefinite extent and dynamic extent.
* (progn
(let ((foo 'outer))
(let ((foo 'inner))
(defun bar () (print foo))
(bar))
(bar))
(values))
INNER
INNER
The inner binding is still going after we leave the inner LET
* (progn
(defvar *foo*)
(let ((*foo* 'outer))
(let ((*foo* 'inner))
(defun bar () (print *foo*))
(bar))
(bar))
(values))
INNER
OUTER
Having dynamic extent, the inner binding has gone and we
fall back to the outer one.
I found CLtL's unpacking of lexical versus special into
lexical scope and indefinite extent
versus
indefinite scope and dynamic extent
made things clearer for me.
And then there are GO targets
have lexical scope and dynamic extent....
Alan Crowe
Edinburgh
Scotland
+ "Andreas Thiele" <······@nospam.com>:
| "Don Wells" <···········@comcast.net> schrieb im Newsbeitrag
| ·······································@4ax.com...
| ...
| > Dynamic scoping of variables, which is not used anymore for the most
| > part. I think emacs lisp might still have them.
|
| I still feel a bit new to lisp - but - don't we have dynamic scoping?
I believe we do, but perhaps he intended to refer to the fact that
elisp doesn't have any other kind.
(setf bar :bar)
(defun bar () bar)
(defun foo (bar) (bar))
(bar) => :bar
(foo :foo) => :foo
--
* Harald Hanche-Olsen <URL:http://www.math.ntnu.no/~hanche/>
- Debating gives most of us much more psychological satisfaction
than thinking does: but it deprives us of whatever chance there is
of getting closer to the truth. -- C.P. Snow
Andreas Thiele wrote:
> "Don Wells" <···········@comcast.net> schrieb im Newsbeitrag
> ·······································@4ax.com...
> ...
>
>>Dynamic scoping of variables, which is not used anymore for the most
>>part. I think emacs lisp might still have them.
> I still feel a bit new to lisp - but - don't we have dynamic scoping? Using
> defvar and let I think we have.
Perhaps he means "not used as default anymore" - the default being
lexical scope. That would also explain the comment about Emacs Lisp.
--
Jens Axel Søgaard
From: Sam Steingold
Subject: Re: Lisp innovations?
Date:
Message-ID: <uk6p9v1nm.fsf@gnu.org>
> * Peter Seibel <·····@wninzbaxrl.pbz> [2005-02-15 22:49:02 +0000]:
>
> Any other ideas?
<http://paulgraham.com/diff.html>
--
Sam Steingold (http://www.podval.org/~sds) running w2k
<http://www.camera.org> <http://www.iris.org.il> <http://www.memri.org/>
<http://www.mideasttruth.com/> <http://www.honestreporting.com>
char*a="char*a=%c%s%c;main(){printf(a,34,a,34);}";main(){printf(a,34,a,34);}
Peter Seibel wrote:
> For my introduction (which I'm now revising) I need a list of
> programming language innovations first introduced in Lisp family
> languages. My current list is:
>
> recursive functions, dynamically allocated memory, garbage
> collection, macros, generic functions, lexical closures.
>
> I'm sure there are many I'm missing. And it's possible I'm wrong
about
> some of those I just listed. Any other ideas?
Here's a list.
http://c2.com/cgi/wiki?GroundBreakingLanguages
I wouldn't be surprised if there were other things not listed like that
stack group stuff in Lisp machines, and various parallel Lisp stuff.
Stack groups I'd like to see...
Interlisp had structure editing, predating Intentional Programming by
far, though I don't know if they were the first. Also GUIs might've
conceivably been a first; Alan Kay explained that they existed before
Xerox Parc.
MfG,
Tayssir
Peter Seibel <·····@javamonkey.com> writes:
> For my introduction (which I'm now revising) I need a list of
> programming language innovations first introduced in Lisp family
> languages. My current list is:
>
> recursive functions, dynamically allocated memory, garbage
> collection, macros, generic functions, lexical closures.
>
> I'm sure there are many I'm missing. And it's possible I'm wrong about
> some of those I just listed. Any other ideas?
I believe the conditional expression is an innovation of Lisp.
Christophe
Peter Seibel wrote:
> For my introduction (which I'm now revising) I need a list of
> programming language innovations first introduced in Lisp family
> languages. My current list is:
>
> recursive functions, dynamically allocated memory, garbage
> collection, macros, generic functions, lexical closures.
>
> I'm sure there are many I'm missing. And it's possible I'm wrong about
> some of those I just listed. Any other ideas?
>
> -Peter
>
How about an interactive REPL?
David Sletten:
>
> Peter Seibel wrote:
> > For my introduction (which I'm now revising) I need a list of
> > programming language innovations first introduced in Lisp family
> > languages. My current list is: [...] I'm sure there are many I'm
> > missing. And it's possible I'm wrong about some of those I just
> > listed. Any other ideas?
>
> How about an interactive REPL?
Not only an interactive REPL but the distinction that an interactive
REPL does not necessarily imply an interpreter. I know of other
languages with something like a REPL, e.g. Python and Tcl, but none
which include a compiler in the mix. Are there others? Googling
around a bit, it looks like maybe Forth has an interactive, compiled
environment but I really know practically nothing about Forth.
In article <·····················@edtnps89>,
Wade Humeniuk <··················@telus.net> wrote:
> I do not know about these, but how about?
>
> structures
Structures were in COBOL and PL/I decades before they were added to Lisp.
--
Barry Margolin, ······@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
Barry Margolin wrote:
> In article <·····················@edtnps89>,
> Wade Humeniuk <··················@telus.net> wrote:
>
>
>>I do not know about these, but how about?
>>
>>structures
>
>
> Structures were in COBOL and PL/I decades before they were added to Lisp.
>
also true for generic functions (PL/I)
hs
In article <·················@newscontent-01.sprint.ca>,
Hartmann Schaffer <··@hartmann.schaffernet> wrote:
> Barry Margolin wrote:
> > In article <·····················@edtnps89>,
> > Wade Humeniuk <··················@telus.net> wrote:
> >
> >
> >>I do not know about these, but how about?
> >>
> >>structures
> >
> >
> > Structures were in COBOL and PL/I decades before they were added to Lisp.
> >
>
> also true for generic functions (PL/I)
PL/I's generic functions are more like C++'s overloading -- they're
based on the declared, static type of the parameters, not dynamic type
like CLOS generic functions and C++ virtual functions.
--
Barry Margolin, ······@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
> recursive functions, dynamically allocated memory, garbage
> collection, macros, generic functions, lexical closures.
I would add:
- metaobject programming (i.e. defining the behaviour of classes
in the language itself),
- the ability to redefine functions and classes at runtime,
- the concept of "virtual machine" (taught through these metacircular
interpreters at university)
Bruno
Bruno Haible <·····@clisp.org> writes:
>> recursive functions, dynamically allocated memory, garbage
>> collection, macros, generic functions, lexical closures.
>
> I would add:
> - metaobject programming (i.e. defining the behaviour of classes
> in the language itself),
Do you think the Smalltalkers might try to claim that one? While they
don't have, as I understand it, anything as rich as the CLOS MOP, they
do have meta classes and much of Smalltalk is written in Smalltalk.
And did Lisp really have "classes" prior to Smalltalk?
-Peter
--
Peter Seibel ·····@javamonkey.com
Lisp is the red pill. -- John Fraser, comp.lang.lisp
In article <············@laposte.ilog.fr>,
Bruno Haible <·····@clisp.org> wrote:
> > recursive functions, dynamically allocated memory, garbage
> > collection, macros, generic functions, lexical closures.
>
> I would add:
> - metaobject programming (i.e. defining the behaviour of classes
> in the language itself),
Smalltalk did that before Lisp, didn't it?
--
Barry Margolin, ······@alum.mit.edu
Arlington, MA
*** PLEASE post questions in newsgroups, not directly to me ***
······@news.dtpq.com (Christopher C. Stacy) writes:
> Did anyone mention IF-THEN statements with a consequence other than
> GOTO?
Yes, they did.
Christophe
Peter Seibel wrote:
> For my introduction (which I'm now revising) I need a list of
> programming language innovations first introduced in Lisp family
> languages.
Hate to bring up PG here (since you probably want your introduction to
be unique), but:
http://store.yahoo.com/paulgraham/diff.html
Here's waiting to read what you put together,
Jeff M.
--
http://www.retrobyte.org
··············@gmail.com
Peter Seibel <·····@javamonkey.com> writes:
> For my introduction (which I'm now revising) I need a list of
> programming language innovations first introduced in Lisp family
> languages. My current list is:
>
> recursive functions, dynamically allocated memory, garbage
> collection, macros, generic functions, lexical closures.
>
> I'm sure there are many I'm missing. And it's possible I'm wrong about
> some of those I just listed. Any other ideas?
Well I would not use the term "macros", because assemblers had already
had "textual macros" before the advent of macros in Lisp in 1963.
However, I'm relatively sure Lisp had the first "syntactic macros".
Kind regards,
Dirk Gerrits
>>>>> "Peter" == Peter Seibel <·····@javamonkey.com> writes:
Peter> I'm sure there are many I'm missing. And it's possible I'm
Peter> wrong about some of those I just listed. Any other ideas?
According to
ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-039.pdf
the Lisp 1.5 compiler "is the first compiler that has ever compiled
itself by being executed interpretively."
Andru
--
Andru Luvisi
Quote Of The Moment:
Quidquid latine dictum sit, altum viditur.
( Whatever is said in Latin sounds profound. )
Andru Luvisi <······@andru.sonoma.edu> wrote:
>>>>>> "Peter" == Peter Seibel <·····@javamonkey.com> writes:
> Peter> I'm sure there are many I'm missing. And it's possible I'm
> Peter> wrong about some of those I just listed. Any other ideas?
>
> According to
> ftp://publications.ai.mit.edu/ai-publications/pdf/AIM-039.pdf
> the Lisp 1.5 compiler "is the first compiler that has ever compiled
> itself by being executed interpretively."
The first self-hosting compiler for any high-level language, if my
research is not completely mistaken.
--
Karl A. Krueger <········@example.edu> { s/example/whoi/ }
If lots of people are doing something, and it isn't working for them,
don't expect that you're special and that it will work for you.