Happy holidays.
I've been digging through the sources to shrdlu (from the CMU AIR
I think), and was wondering if anyone has done anything with them in
recent memory.
The references to shrdlu that tend to come up via internet search
engines usually lament that it hasn't been updated or operational
lately (er, the last 20 yrs?). I'm not competent to judge what place
its parsing techniques have in contemporary NL practice, but judging
from the session transcripts that are available, it would be a very
interesting program to have captive.
The dialect seems to be Lisp Machine Lisp, is that right? On first
inspection, there don't seem to be any major obstacles to pulling the
code into CL.
As to the value of such a project, are there other other available
examples of this type of synthesis of a parser, semantics and planner
that I could more profitably study, with an eye primarily towards
having fun with computational linguistics?
Thanks,
Jesse Bouwman
·····@onshore.com
·····@onshore.com (Jesse Bouwman) wrote:
> The dialect seems to be Lisp Machine Lisp, is that right? On first
>inspection, there don't seem to be any major obstacles to pulling the
>code into CL.
I thought that SHRDLU predate Lisp machines, so if I'm right, either
the code's been updated or more likely is MACLISP.
>Jesse Bouwman
Le Hibou http://homepages.enterprise.net/hibou/
"What the ... This is Lambic! Where's my culture of amoebic
dysentery?" -- Gary Larson
In article <·············@news.enterprise.net>, hibou at enterprise dot
net wrote:
> ·····@onshore.com (Jesse Bouwman) wrote:
>
> > The dialect seems to be Lisp Machine Lisp, is that right? On first
> >inspection, there don't seem to be any major obstacles to pulling the
> >code into CL.
>
> I thought that SHRDLU predate Lisp machines, so if I'm right, either
> the code's been updated or more likely is MACLISP.
The original code was Maclisp, so the easiest translation would be to
old Bzerkeley Franzlisp. Translation to Common Lisp is possible, but would
probably require lots of declarations. I seem to recall that Jack Holloway
may have played around with a Lisp Machine version of SHRDLU as one of the
first demos of the original Lisp Machine. I haven't the foggiest idea
where this code might be, though.
I agree that this program should be running somewhere on the Internet
as a kind of 'code museum', along with other famous programs such as
Samuel's checker-playing program, etc.
In article <·······················@10.0.2.1>, ······@netcom.com (Henry
Baker) wrote:
>The original code was Maclisp, so the easiest translation would be to
>old Bzerkeley Franzlisp. Translation to Common Lisp is possible, but would
>probably require lots of declarations.
MacLisp also, as I recall (dimly) is not lexically scoped. Some code I
have seen of that vintage made pretty free and cunning use of that fact,
so translation might require more than just declaring selected variables
as special.
--
Michael Kilgore
········@cyberramp.net (Michael Kilgore) writes:
> MacLisp also, as I recall (dimly) is not lexically scoped. Some code I
> have seen of that vintage made pretty free and cunning use of that fact,
> so translation might require more than just declaring selected variables
> as special.
Actually, only in interpreted code was Maclisp reliably dynamically
scoped. If it ever ran compiled, then it would have to already
contain SPECIAL declarations because Maclisp code became more-or-less
lexical when compiled. (Well, it didn't auto-create lexical closures
as some would expect from modern lexicality, but at least it no longer
shared data promiscuously function to function...) So if it ever ran
compiled, it will largely be compatible except you will have to change
toplevel (DECLARE (SPECIAL ...)) to (PROCLAIM '(SPECIAL ...)).
Incidentally, the worst porting nightmare between Maclisp and CL is
the / operator (called // in Maclisp, which used / instead of \ to
quote syntax). It is utterly incompatible in a way that is not lexically
observable and that has to be handled by runtime checking and/or deep
understanding of the code being translated.
By the way, I have a set of notes somewhere I could physmail you on
exactly how to translate Maclisp to Common Lisp. I made them at
Symbolics and Symbolics promised to publish them ... but then they sat
on them until they felt it was no longer timely and so they went to
waste. (For historical reasons, I'll try to put them online someday.)
If Jesse (or anyone else with old Maclisp code to port ;-) needs a
copy of my notes, they should send me e-mail.
Kent M Pitman wrote:
>
(snip)
> By the way, I have a set of notes somewhere I could physmail you on
> exactly how to translate Maclisp to Common Lisp. I made them at
> Symbolics and Symbolics promised to publish them ... but then they sat
> on them until they felt it was no longer timely and so they went to
> waste. (For historical reasons, I'll try to put them online someday.)
> If Jesse (or anyone else with old Maclisp code to port ;-) needs a
> copy of my notes, they should send me e-mail.
I'm working my way through SICP to teach myself programming. Porting a
classic program like SHRDLU sounds like a neat project, and hopefully
would be something that would be a good learning experience.
I didn't get the original post. Do you know who proposed this?
Do you think that this would be a good project for someone to get their
feet wet learning Lisp?
--
*********************************************
Semi-encrypted email address: m_b_p_o_m_i_j_e_ a_t_ i_n_a_v_ d_o_t_
n_e_t_
All non-solicited commercial email will be billed $1,000.
······@netcom.com (Henry Baker) writes:
> In article <·············@news.enterprise.net>, hibou at enterprise dot
> net wrote:
> The original (SHRDLU) code was Maclisp, so the easiest translation
> would be to old Bzerkeley Franzlisp. Translation to Common Lisp is
> possible, but would probably require lots of declarations.
It wouldn't be so hard to put in the declarations.
Performance-oriented declarations would be nice, but not really
necessary. The original SHRDLU seemed to work acceptably on a Dec-10
under ITS Maclisp. I think that a version in compiled (but not
tweaked) Common Lisp on a 233 MHz Pentium or an Alpha would be
faster. You'd need declarations for variables used dynamically, but
at least such declarations exist in CL. You'd have to walk through all
the code once anyway to change names and so on. There were tools at
one time to automate some of this, but I'm sure they have all rotted
by now.
A more difficult problem is that some portions of SHRDLU (at least the
blocks-world planning parts, and perhaps some of the NL stuff as well)
were written in Micro-Planner, an embedded "AI" language written on
top of Maclisp. Micro-planner was a pattern-matching langauge with a
database of assertions and a backup control structure -- close to
modern Prolog, though without the good compilers and without the
attitutde.
Porting those parts of SHRDLU from Micro-Planner to something else,
like an embedded Prolog, would be nasty. Porting Micro-Planner to CL
would be even more nasty, since it did some kinky things with
readtables and used some deep-down hacks.
An archive of ancient and venerable AI code would be interesting and
useful. One good use would be to help knock down bogus patents that
are being issued when this stuff is rediscovered 20 years later. But
making this code run in the real world is another matter. The only
way to make it straightforward would be to build a system that
accurately emulates (at machine-instruction level) a
PDP-6/Dec-10/Dec-20 and some of the mutant versions that appeared at
MIT and Stanford in the old days. Plus emulations for ITS and Tenex
system calls. Plus emulation or real working versions of the various
Lisp machines and Xerox D-series machines... SOunds like too much
work for a neat hack.
-- Scott
===========================================================================
Scott E. Fahlman Internet: ···@cs.cmu.edu
Principal Research Scientist Phone: 412 268-2575
Department of Computer Science Fax: 412 268-5576
Carnegie Mellon University Latitude: 40:26:46 N
5000 Forbes Avenue Longitude: 79:56:55 W
Pittsburgh, PA 15213 Mood: :-)
===========================================================================
In article <··············@CLYDE.BOLTZ.CS.CMU.EDU>, Scott Fahlman
(···@clyde.boltz.cs.cmu.edu) says...
>...>
>
>An archive of ancient and venerable AI code would be interesting and
>useful. One good use would be to help knock down bogus patents that
>are being issued when this stuff is rediscovered 20 years later. But
>making this code run in the real world is another matter. The only
>way to make it straightforward would be to build a system that
>accurately emulates (at machine-instruction level) a
>PDP-6/Dec-10/Dec-20 and some of the mutant versions that appeared at
>MIT and Stanford in the old days. Plus emulations for ITS and Tenex
>system calls. Plus emulation or real working versions of the various
>Lisp machines and Xerox D-series machines... SOunds like too much
>work for a neat hack.
A portable Interlisp-D virtual machine ought to be fairly straightforward to
implement, perhaps using C++ and a portable GUI framework - and not
uninteresting as an ancestor of the Java VM. Maybe a master's or a
collaborative term project. I suspect the major issue would be drawing up an
accurate specification of the byte codes, tricky without the assistance of a
former Xerox developer.
The real problem would be reading the 8" floppies ... perhaps a parallel
project for the EE dept!
/df
--
Dirk Fieldhouse Logica UK Limited
··········@logica.com 75 Hampstead Road
c=gb;a=attmail;p=logica; London NW1 2PL
o=lg;ou1=lgwct;s=fieldhouse UK
+44 (171) 637 9111
* Dirk Fieldhouse wrote:
> A portable Interlisp-D virtual machine ought to be fairly straightforward to
> implement, perhaps using C++ and a portable GUI framework - and not
> uninteresting as an ancestor of the Java VM. Maybe a master's or a
> collaborative term project. I suspect the major issue would be drawing up an
> accurate specification of the byte codes, tricky without the assistance of a
> former Xerox developer.
There was/is a version of Interlisp-D that ran on Suns using an
emulator like this. It may have run on PCs as well. It was
commercial, done by Envos?
--tim
Tim Bradshaw wrote:
> There was/is a version of Interlisp-D that ran on Suns using an
> emulator like this. It may have run on PCs as well. It was
> commercial, done by Envos?
>
> --tim
It was commercially available when last I worked for Venue (1994). Venue is
still alive, and findable in the Lisp FAQ.
Scott Fahlman <···@clyde.boltz.cs.cmu.edu> wrote:
·······@netcom.com (Henry Baker) writes:
;
;
;> In article <·············@news.enterprise.net>, hibou at enterprise dot
;> net wrote:
;
;> The original (SHRDLU) code was Maclisp, so the easiest translation
;> would be to old Bzerkeley Franzlisp. Translation to Common Lisp is
;> possible, but would probably require lots of declarations.
;
;It wouldn't be so hard to put in the declarations.
;
;A more difficult problem is that some portions of SHRDLU (at least the
;blocks-world planning parts, and perhaps some of the NL stuff as well)
;were written in Micro-Planner, an embedded "AI" language written on
Yet another problem is that the waythe code is written it's virtually
impossible (or at least very hard) to understand what it's supposed to
be doing. I recall reading somewhere that there was once a project at the MIT
AI lab to expand shrdlu to something more general, which was ultimately
abandoned. Was anyone here involved in that project? (I myself thought about
trying to hack shrdlu, but gave up after about 10 minutes.)
And speaking of old projects, what about the famous raincoat program written by
you, Scott, detailed in "Into the Heart of Mind"? I wouldn't mind seeing that
thing running. Was your source ever available? I know that PEARL of course was
made available with the Franz distribution. (Er, that was you, wasn't it?)
"Torniamo al' antico -- sera una progressa," said Verdi.