From: Christopher C. Stacy
Subject: Re: PDP-10 Common Lisp
Date:
Message-ID: <ur8dp99nc.fsf@dtpq.com>
>>>>> On 13 Nov 2002 08:34:24 +0100, Lars Brinkhoff ("Lars") writes:
Lars> Was there ever a Common Lisp implementation for the PDP-10(/DEC-10/DEC-20)?
No, but Common Lisp was largely based on the Lisp Machine dialect,
which was in turn based on MACLISP, which was developed on the PDP-10.
The effort to define Common Lisp was started in late 1981, and Lisp
language development at MIT had already moved onto Lisp Machines and
the VAX, and at CMU onto the SPICE project. The reference book,
"Common Lisp: the Language" (CLtL1) was not published until 1984.
Today when people say "Common Lisp", they mean "ANSI Common Lisp".
The ANSI effort didn't form until 1986.
At the time when Common Lisp was being developed, most of the
development action was with Lisp Machines, VMS, and Unix.
Among language developers, the venerable PDP-10s had mostly become
the platforms for running EMACS, TeX, sending email, and other
pedestrian functions.
At Xerox, INTERLISP development was on the new D-machines.
They (and BBN) may also have been actively developing on PDP-10s
(I don't know), but they were not working on Common Lisp.
They were the enemy.
There was also something called Portable Standard Lisp,
which I don't know much about. It was not Common Lisp.
> No, but Common Lisp was largely based on the Lisp Machine dialect,
> which was in turn based on MACLISP, which was developed on the
> PDP-10.
Actually when I was at Stanford in the late '80s, there was a Common
Lisp implementation running on the PDP-10s we used. I don't remember
anything in particular about it. It didn't, as far as I know, have
any `lineage' of interest.
I know it was Common Lisp because I specifically remember the teacher
of the Lisp class I took saying we should use that if we couldn't use
any other Common Lisp (he definitely considered it a last resort).
--
Fred Gilham ······@csl.sri.com
Communism is a murderous failure.
Socialism is communism with movie stars.
From: Christopher C. Stacy
Subject: Re: PDP-10 Common Lisp
Date:
Message-ID: <uznsdfhpw.fsf@dtpq.com>
>>>>> On 13 Nov 2002 08:00:33 -0800, Fred Gilham ("Fred") writes:
>> No, but Common Lisp was largely based on the Lisp Machine dialect,
>> which was in turn based on MACLISP, which was developed on the
>> PDP-10.
Fred> Actually when I was at Stanford in the late '80s, there was a Common
Fred> Lisp implementation running on the PDP-10s we used. I don't remember
Fred> anything in particular about it. It didn't, as far as I know, have
Fred> any `lineage' of interest.
Fred> I know it was Common Lisp because I specifically remember the teacher
Fred> of the Lisp class I took saying we should use that if we couldn't use
Fred> any other Common Lisp (he definitely considered it a last resort).
It was probably PSL, but that wasn't Common Lisp.
Paul Dietz <············@motorola.com> writes:
> Fred Gilham wrote:
>>
>> > Fred> No, it was definitely Common Lisp.
>> > Fred> I think it was called CLISP or something like that.
>> >
>> > What operating system was it running under (and what year again?)
>>
>> I think it was tops-20. The year was 1987.
>
> There was a lisp called ELISP (from Hedrick at Rutgers) on the
> 20.
From reading the c.l.l archives, it appears to me that Elisp was
*not* a Common Lisp implementation. Elisp was Rutgers/UCI Lisp with
extended addressing capabilities (it used 23 bits for addressing,
which R/UCI used only 18 bits). The decision was made to *not*
extend Elisp to be a Common Lisp, but to start fresh.
In 1982, Rutgers got a contract from DEC to implement Common Lisp
for the TOPS-20 (really, for the Jupiter machine) - for that they
ported CMU's Spice Lisp. When the Jupiter got cancelled, the
project lost steam.
There is a really interesting message from Arun Welch, posted on
1994-10-20, that gives a long run down of the history of Common
Lisp, including some of these details. Others were gleaned from
postings by Chuck Hedrick himself, circa 1988.
-jon
--
------------------
Jon Allen Boone
········@delamancha.org
Jon Allen Boone <········@delamancha.org> writes:
> In 1982, Rutgers got a contract from DEC to implement Common Lisp
> for the TOPS-20 (really, for the Jupiter machine) - for that they
> ported CMU's Spice Lisp. When the Jupiter got cancelled, the
> project lost steam.
Interestingly, in CLtL (section 32.1.6 Pathname Functions in the
second edition), the examples assume a host named CMUC running
TOPS-20. Perhaps there is a connection to the project above?
--
Lars Brinkhoff http://lars.nocrew.org/ Linux, GCC, PDP-10,
Brinkhoff Consulting http://www.brinkhoff.se/ HTTP programming
From: Christopher C. Stacy
Subject: Re: PDP-10 Common Lisp
Date:
Message-ID: <ubs4qlo6n.fsf@dtpq.com>
>>>>> On 15 Nov 2002 12:11:57 +0100, Lars Brinkhoff ("Lars") writes:
Lars> Jon Allen Boone <········@delamancha.org> writes:
>> In 1982, Rutgers got a contract from DEC to implement Common Lisp
>> for the TOPS-20 (really, for the Jupiter machine) - for that they
>> ported CMU's Spice Lisp. When the Jupiter got cancelled, the
>> project lost steam.
Lars> Interestingly, in CLtL (section 32.1.6 Pathname Functions in the
Lars> second edition), the examples assume a host named CMUC running
Lars> TOPS-20. Perhaps there is a connection to the project above?
I don't think that referred to any real TOPS-20 Common Lisp; it was
just a made-up example. In reality, I think CMUC ran TOPS-10 or TENEX.
A more realistic example would be a program running on the Lisp
Machine and accessing files on a TOPS-20 server such as MIT-XX.
The Lisp Machine had transparent network access to all the native
file systems, so PATHNAME-HOST could refer to any kind of host.
Pathname namestrings were in their native format, with the first
colon character seperating the host from the rest of the filename.
So, you could type all of the following examples at the Lisp Machine
whenever you were entering a pathname:
File Server Pathname namestring
----------- -----------------------------------------
ITS AI:FOO;SYSDCL >
LispM S:>CStacy>demo>src>sysdcl.lisp.newest
TOPS-20 MIT-XX:<CSTACY.DEMO.SRC>SYSDCL.LISP.33
VMS PYG:[CSTACY.DEMO.SRC]SYSDCL.LISP;33
UNIX wheaties:/home/cstacy/demo/sysdcl.lisp.~33~
Logical ALPHA:CSTACY;DEMO;SYSDCL.LISP
It handled a variety of others -- pretty much all known network
accessible operating systems, in fact -- and was extensible.
The HOST in a pathname was actually an object, and multiple-inheritance
was heavily used. The pathname host objects knew about the syntax of
the pathnames for their operating system, parsing, defaulting, etc.
It was very hairy to get this and all the necessary associated
functionality right, even for just your own Lisp's native pathnames;
X3J13 pretty much punted on the pathname system, unable to accept
that it was so complex and being fed up with Symbolics for having
gotten yet another thing right. So now every Common Lisp programmer
has to write their own pathname system on top of what ANSI CL provides.
At least ANSI CL pathnames are slightly better than anything provided
in the other competing languages.
Random excerpt examples of some of the kinds of magic:
(DEFFLAVOR TENEX-FAMILY-HOST-MIXIN ()
(CASE-SENSITIVE-PATHNAME-HOST-MIXIN PATHNAME-HOST-MIXIN)
(:REQUIRED-FLAVORS HOST))
(DEFFLAVOR HOST-MULTICS-MIXIN ()
(NO-DEVICE-OR-VERSION-HOST-MIXIN CASE-SENSITIVE-PATHNAME-HOST-MIXIN
PATHNAME-HOST-MIXIN)
(:REQUIRED-FLAVORS HOST))
(DEFMETHOD (:DEFAULT-HOMEDIR HOST-MULTICS-MIXIN) (USER-NAME)
(SEND (SEND SELF :SAMPLE-PATHNAME) :NEW-PATHNAME
:RAW-DIRECTORY `("udd" "Project" ,USER-NAME) :NAME NIL :TYPE NIL :VERSION NIL))
(DEFFLAVOR HOST-VM370-MIXIN ()
(NO-DIRECTORY-OR-VERSION-HOST-MIXIN PATHNAME-HOST-MIXIN))
The pathname system also knew the "type" extension to use for
standard file types on the different operating systems:
(DEFINE-CANONICAL-TYPE :LISP "LISP"
((:TENEX :TOPS-20) "LISP" "LSP")
(:ITS :UNSPECIFIC)
(:UNIX "L" "LISP")
(:UNIX42 "LISP" "L")
((:VMS4 :VMS4.4) "LISP" "LSP")
((:VMS :MSDOS :OS//2) "LSP"))
For getting to those hosts, the Lisp Machine also implemented all the
file server protocols, such as its own winning NFILE protocol, along
with FTP, NFS, and others. It would automatically select and invoke
the best protocol for the host, based on hints from the distributed
"network namespace" database (which was similar to DNS) and from DNS.
The selected protocol was transparently invoked and the implementation
would try to handle or emulate all the desired features (eg. directory
operations, links, version numbers) so that the software had a generic
uniform interface.
Some operations didn't work across all systems: for example, "Expunge"
and "Undelete" (versus a hard "Delete File") was only available on the
TOPS-20 and LispM file systems. So (FS:EXPUNGE-DIRECTORY "u:/usr/local/"),
or as an "Expunge" command in Zmacs, would signal an appropriate error.
As far as users were concerned, they just typed in and used their
filenames as if they were using their file server's operating system
(just like when they would TELNET over to timesharing to run TeX or
whatever). One difference was that it was often easier to manipulate
files from the Lisp Machine, rather than commands on the file server.
For example, "Copy File" with wildcards and subdirectories does the
right thing for Unix when you do it from the Lisp Machine, but not
from a Unix shell, because the pathname system of course actually knew
what was meant to be happenning!
Nowadays this kind of thing is all just an impossible dream, of course.
Welcome to the 21st century.
Christopher C. Stacy wrote:
> The Lisp Machine had transparent network access to all the native
> file systems, so PATHNAME-HOST could refer to any kind of host.
Arg!! I inherited support for this stuff under Xerox's implementation,
which also had support for XNS and PUP servers. On the one hand, it was
a bitch to get right for the implementor. On the other hand, from the
users perspective it was a thing of beauty, especially when it gave you
a versioned file system on an OS that didn't otherwise support it (like
any "modern" OS). But that argument's been hashed out on the UNIX-HATERS
mailing list already :-).
...arun
* Christopher C. Stacy
| I don't think that referred to any real TOPS-20 Common Lisp; it was
| just a made-up example. In reality, I think CMUC ran TOPS-10 or TENEX.
I have been unable to find any documentation or anything else useful to
prove this, but I did use a Common Lisp system on TOPS-20. It was an
impressive system and among its most important features was that it could
use a lot more of the available memory than most TOPS-20 applications,
which were limited to 18 address bits, but this turned out to be a problem
on a machine that was intended to support a lot of Emacs users, too.
--
Erik Naggum, Oslo, Norway
Act from reason, and failure makes you rethink and study harder.
Act from faith, and failure makes you blame someone and push harder.
From: Christopher C. Stacy
Subject: Re: PDP-10 Common Lisp
Date:
Message-ID: <u7kfdtbdv.fsf@dtpq.com>
>>>>> On Fri, 15 Nov 2002 17:48:01 GMT, Christopher C Stacy ("Christopher") writes:
Christopher> In reality, I think CMUC ran TOPS-10 or TENEX.
I am reliably informed tht CMU-10A and CMU-10B ran TOPS-10,
but CMU-20C ran TOPS-20.
······@dtpq.com (Christopher C. Stacy) writes:
> I am reliably informed tht CMU-10A and CMU-10B ran TOPS-10,
> but CMU-20C ran TOPS-20.
This just in:
Charles Hedrick <·······@nbcs.rutgers.edu> writes:
> On Monday, November 18, 2002, at 05:22 AM, Lars Brinkhoff wrote:
> > Is it correct that you were involved in a project to create a
> > Common Lisp implementation for TOPS-20? If so, do you know if
> > there is any chance it has survived on any machine or backup tape?
> yes, we did do a common lisp. We've checked recently, and don't
> think there are any copies of this or other tops-20 work at
> Rutgers. It was distributed fairly widely through DECUS, so there
> are probably copies somewhere, but I don't know where.
--
Lars Brinkhoff http://lars.nocrew.org/ Linux, GCC, PDP-10,
Brinkhoff Consulting http://www.brinkhoff.se/ HTTP programming
······@dtpq.com (Christopher C. Stacy) writes:
> Among language developers, the venerable PDP-10s had mostly become
> the platforms for running EMACS, TeX, sending email, and other
> pedestrian functions.
hey, I actually thought that I was way cool and cutting edge when I
learned to use TeX on the DEC-10 ;-) In addition, I could use it to
run Edinburgh Prolog, which was extremely well designed and must take
quite a bit of the blame that large parts of the Computational
Linguistics scene dropped lisp and fell in love with Prolog.
--
(espen)
In article <·············@dtpq.com>,
Christopher C. Stacy <······@dtpq.com> wrote:
>At the time when Common Lisp was being developed, most of the
>development action was with Lisp Machines, VMS, and Unix.
What about NIL (New Implementation of Lisp)? Wasn't that a PDP-10 Lisp
that was based on the CL development?
--
Barry Margolin, ······@genuity.net
Genuity, Woburn, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.
From: Christopher C. Stacy
Subject: Re: PDP-10 Common Lisp
Date:
Message-ID: <u4ralgwbs.fsf@dtpq.com>
>>>>> On Wed, 13 Nov 2002 15:39:47 GMT, Barry Margolin ("Barry") writes:
Barry> In article <·············@dtpq.com>,
Barry> Christopher C. Stacy <······@dtpq.com> wrote:
>> At the time when Common Lisp was being developed, most of the
>> development action was with Lisp Machines, VMS, and Unix.
Barry> What about NIL (New Implementation of Lisp)? Wasn't that a PDP-10 Lisp
Barry> that was based on the CL development?
NIL was on VAX\VMS.
In article <·············@dtpq.com>,
Christopher C. Stacy <······@dtpq.com> wrote:
>>>>>> On Wed, 13 Nov 2002 15:39:47 GMT, Barry Margolin ("Barry") writes:
>
> Barry> In article <·············@dtpq.com>,
> Barry> Christopher C. Stacy <······@dtpq.com> wrote:
> >> At the time when Common Lisp was being developed, most of the
> >> development action was with Lisp Machines, VMS, and Unix.
>
> Barry> What about NIL (New Implementation of Lisp)? Wasn't that a PDP-10 Lisp
> Barry> that was based on the CL development?
>
>NIL was on VAX\VMS.
Right. But I thought I remembered something similar on ITS at the time.
Was there a NIL emulator that ran in Maclisp?
--
Barry Margolin, ······@genuity.net
Genuity, Woburn, MA
*** DON'T SEND TECHNICAL QUESTIONS DIRECTLY TO ME, post them to newsgroups.
Please DON'T copy followups to me -- I'll assume it wasn't posted to the group.
Barry Margolin <······@genuity.net> writes:
>
> In article <·············@dtpq.com>,
> Christopher C. Stacy <······@dtpq.com> wrote:
> >At the time when Common Lisp was being developed, most of the
> >development action was with Lisp Machines, VMS, and Unix.
>
> What about NIL (New Implementation of Lisp)? Wasn't that a PDP-10 Lisp
> that was based on the CL development?
Not exactly. NIL was an implementation of Common Lisp, but on a VAX
under VMS. Glenn Burke was the main lead for developing it, with,
I believe, assistance from George Carrett and a couple of other folks.
-Tom.
P.S. I did random and the floating point format directives :)
--
Thomas A. Russ, USC/Information Sciences Institute ···@isi.edu
Lars Brinkhoff wrote:
>
> Was there ever a Common Lisp implementation for the PDP-10(/DEC-10/DEC-20)?
Yes, Chuck Hedrik at Rutgers wrote one (CLtL1, of course).
...arun
From: Christopher C. Stacy
Subject: Re: PDP-10 Common Lisp
Date:
Message-ID: <u65uy11nr.fsf@dtpq.com>
>>>>> On Fri, 15 Nov 2002 22:31:52 -0600, Arun Welch ("Arun") writes:
Arun> Lars Brinkhoff wrote:
>>
>> Was there ever a Common Lisp implementation for the PDP-10(/DEC-10/DEC-20)?
Arun> Yes, Chuck Hedrik at Rutgers wrote one (CLtL1, of course).
That wasn't a version of UCI Lisp?