If I asked an easy question about mulisp here, what are the chances
someone would know the answer?
If I asked a difficult qustion (same)?
Was mulisp highly popular or influential?
Did it influence CL, or Scheme?
or any dialect of lisp that has an NG dedicated to it?
From: Brian P Templeton
Subject: Re: how popular and/or influential was/is mulisp?
Date:
Message-ID: <87lmdsnh0x.fsf@tunes.org>
······@ureach.com (zaphod) writes:
> If I asked an easy question about mulisp here, what are the chances
> someone would know the answer?
> If I asked a difficult qustion (same)?
> Was mulisp highly popular or influential?
> Did it influence CL, or Scheme?
> or any dialect of lisp that has an NG dedicated to it?
``The Evolution of Lisp'' (by GLS and RPG) mentions muLisp exactly
once, listing it as one of the ``unCommon Lisps'' advertised to
correct some deficiency in Common Lisp; ``TEoL'' has no further
explanation of it. I don't think it's very popular :).
hth,
--
BPT <···@tunes.org> /"\ ASCII Ribbon Campaign
backronym for Linux: \ / No HTML or RTF in mail
Linux Is Not Unix X No MS-Word in mail
Meme plague ;) ---------> / \ Respect Open Standards
From: Tim Bradshaw
Subject: Re: how popular and/or influential was/is mulisp?
Date:
Message-ID: <ey3y9hr1zwu.fsf@cley.com>
(note I'm following up only to cll)
* Brian P Templeton wrote:
> ``The Evolution of Lisp'' (by GLS and RPG) mentions muLisp exactly
> once, listing it as one of the ``unCommon Lisps'' advertised to
> correct some deficiency in Common Lisp; ``TEoL'' has no further
> explanation of it. I don't think it's very popular :).
I think it may have been reasonably popular in its day, but not on big
machines - it originated on CP/M class machines (possibly actually on
CP/M) and in the mid 80s it was pretty competitive on MSDOS machines -
Gold Hill CL was the only other serious system I was aware of and it
was ludicrously more resource hungry. I did non-trivial computer
algebra calculations on an MSDOS machine with half a meg of memory
using mulisp (took some time...).
And of course mulisp is related to things like musimp and mumath,
which are in turn related to the algebra systems that run in TI
calculators. That's not uninfluential, I think.
--tim
"Tim Bradshaw" <···@cley.com> schrieb im Newsbeitrag
····················@cley.com...
>
> (note I'm following up only to cll)
>
> * Brian P Templeton wrote:
> > ``The Evolution of Lisp'' (by GLS and RPG) mentions muLisp exactly
> > once, listing it as one of the ``unCommon Lisps'' advertised to
> > correct some deficiency in Common Lisp; ``TEoL'' has no further
> > explanation of it. I don't think it's very popular :).
>
> I think it may have been reasonably popular in its day, but not on big
> machines - it originated on CP/M class machines (possibly actually on
> CP/M) and in the mid 80s it was pretty competitive on MSDOS machines -
> Gold Hill CL was the only other serious system I was aware of and it
> was ludicrously more resource hungry. I did non-trivial computer
> algebra calculations on an MSDOS machine with half a meg of memory
> using mulisp (took some time...).
>
> And of course mulisp is related to things like musimp and mumath,
> which are in turn related to the algebra systems that run in TI
> calculators. That's not uninfluential, I think.
Derive was written in muLisp and it was (it is) so compact and needed only
sparse ressources and was so powerful that I did not want to believe it was
written in Lisp (I had the usual prejudice against Lisp at that time). They
first tried to implement their muLisp on the TI calculators but the chief
architect of Derive (most unfortunately I forgot his name as I forget all
names nowadays) told me that they did not succeed as the calculators did not
have enough memory. So they reimplemented Derive in C.
J.B.
-----= Posted via Newsfeeds.Com, Uncensored Usenet News =-----
http://www.newsfeeds.com - The #1 Newsgroup Service in the World!
Check out our new Unlimited Server. No Download or Time Limits!
-----== Over 80,000 Newsgroups - 19 Different Servers! ==-----
In article <····························@posting.google.com>,
······@ureach.com (zaphod) wrote:
>If I asked an easy question about mulisp here, what are the chances
>someone would know the answer?
>If I asked a difficult qustion (same)?
>Was mulisp highly popular or influential?
>Did it influence CL, or Scheme?
>or any dialect of lisp that has an NG dedicated to it?
Highly unlikely though only the CL designers know for sure.
The only innovation I remember in muLisp was a merged
COND and LOOP syntax where
(cond | loop form*)
had the following new rule:
if form was a list of expressions, then it meant
the normal (test ...) in COND, and (exit-test ...)
in LOOP. (I forget if it was a WHILE or UNTIL test.)
if form was an expression, then it meant "just do this"
in both COND and LOOP.
This idea was not carried over into CL and Scheme, I
presume because it was a bad idea.
From: Tim Bradshaw
Subject: Re: how popular and/or influential was/is mulisp?
Date:
Message-ID: <ey3adu61so6.fsf@cley.com>
* Chris Riesbeck wrote:
> The only innovation I remember in muLisp was a merged
> COND and LOOP syntax where
> (cond | loop form*)
> had the following new rule:
> if form was a list of expressions, then it meant
> the normal (test ...) in COND, and (exit-test ...)
> in LOOP. (I forget if it was a WHILE or UNTIL test.)
I think that this was more general -- there was some kind of implicit
COND anywhere you'd expect a PROGN, so:
(defun foo (x)
((integerp x) t)
((floatp x) nil))
would work I think. This depends crucially on it being a Lisp2 of
course...
--tim
[ replying to comp.lang.lisp only
http://world.std.com/~pitman/pfaq/cross-posting.html ]
Chris Riesbeck <········@cs.northwestern.edu> writes:
> In article <····························@posting.google.com>,
> ······@ureach.com (zaphod) wrote:
>
> >If I asked an easy question about mulisp here, what are the chances
> >someone would know the answer?
> >If I asked a difficult qustion (same)?
> >Was mulisp highly popular or influential?
I'm not sure what this means. It had a happy audience and did what it
set out to do quite well. It was disconnected from many other Lisp
dialects in terms of its syntax and semantics, but it was conceptually
well within the Lisp family of languages.
> >Did it influence CL, or Scheme?
Hopefully this is not a restatement of the prior question, since this is a
very limited notion of what it is to be popular or influential.
It did not, to my knowledge, influence either of these.
It did, however, contribute to MuMath, which contributed to the symbolic
algebra community. And that, in turn, put Lisp in good stead, adding
yet another system to the several others (such as Reduce and Macsyma)
written in Lisp.
> >or any dialect of lisp that has an NG dedicated to it?
Wow, that's an even weirder criterion. Why does this matter, other than
if you wanted to have a long discussion about it and were without a forum.
> Highly unlikely though only the CL designers know for sure.
>
> The only innovation I remember in muLisp was a merged
> COND and LOOP syntax where
>
> (cond | loop form*)
>
> had the following new rule:
>
> if form was a list of expressions, then it meant
> the normal (test ...) in COND, and (exit-test ...)
> in LOOP. (I forget if it was a WHILE or UNTIL test.)
>
> if form was an expression, then it meant "just do this"
> in both COND and LOOP.
>
> This idea was not carried over into CL and Scheme, I
> presume because it was a bad idea.
I'm not familiar with the LOOP form, so won't comment on that.
The COND form was a shorthand that Al Rich devised originally because
he thought there was no case where ((something ...) ...) ever occurred
in the language and he figured it was a waste of a CONS to have to put
COND in there. He did an amazing amount of cool stuff with Lisp given
he'd only had one piece of source material to work with, I think.
Mostly I think he just kind of got inspired and then was off and
running. He demo'd the system for me at a Macsyma Users Conference, I
think, probably the 1979 one. I remember I wrote an "animal game" for
it to try it out, which they later distributed to users. But when
doing that program, both he and I were totally confused when I wrote a
lambda combination [something like ((lambda (x) x) 1)] and it didn't
work. Apparently, he had not known until that moment about lambda
expressions. ;) I'm pretty sure he patched the language after that so
that the ((...) ...) handler to looked specially for LAMBDA and to
treat it differently than a "normal" conditional.
In general, as this "leaving off the word COND" illustrates, the
design of MuLisp emphasizes a relentless attempt to squish every last
byte of the language and implementation, so that it could run
efficiently on tiny processors.
Also noteworthy are the fact that there were only four kinds of "hard"
errors in the language. I can't remember what they all are any more after
20 years or so since I saw early MuLisp, but I'm pretty sure of the
number. One was an out-of-storage thing. I don't know the other
three. Everything else was "defined", often in quite odd ways. For
example, (+ 'a 3) would reliably return NIL, and this fact is heavily
used in the symbolic algebra system, where it did things like vaguely like:
(defun plus (x y) (or (+ x y) (list 'plus x y)))
From: Tim Bradshaw
Subject: Re: how popular and/or influential was/is mulisp?
Date:
Message-ID: <ey3664u1p8e.fsf@cley.com>
* Kent M Pitman wrote:
> Also noteworthy are the fact that there were only four kinds of "hard"
> errors in the language. I can't remember what they all are any more after
> 20 years or so since I saw early MuLisp, but I'm pretty sure of the
> number. One was an out-of-storage thing. I don't know the other
> three. Everything else was "defined", often in quite odd ways. For
> example, (+ 'a 3) would reliably return NIL, and this fact is heavily
> used in the symbolic algebra system, where it did things like vaguely like:
> (defun plus (x y) (or (+ x y) (list 'plus x y)))
And unbound variables would spring into existence, bound to themselves
(sort of like keywords in CL). I *hated* that feature since it made
detecting errors in code significantly harder. Perl does more-or-less
the same thing, or at least did and probably still does unless you set
some flag.
--tim
"Kent M Pitman" <······@world.std.com> ha scritto nel messaggio
····················@shell01.TheWorld.com...
> In general, as this "leaving off the word COND" illustrates, the
> design of MuLisp emphasizes a relentless attempt to squish every last
> byte of the language and implementation, so that it could run
> efficiently on tiny processors.
Let me quote from the muLISP-83 manual:
"The 64K address space of the 8080 and the Z80 microprocessors
imposes a very severe restrictions on the maximum size of LISP
programs. To ameliorate this problem for the CP/M-80 version of
muLISP-83, two slightly different copies of the muLISP interpreter
have been included on the Master Diskette: a full feature version
and a smaller, limited feature version.
...
"The file ML.COM is the limited feature version of the muLISP
interpreter. By pruning out some of the less used LISP functions,
ML.COM provides more than 1K of additional memory for user defined
functions and data. ..."
> Also noteworthy are the fact that there were only four kinds of "hard"
> errors in the language. I can't remember what they all are any more after
> 20 years or so since I saw early MuLisp, but I'm pretty sure of the
> number.
You must be remembering muLISP-79, which I used only briefly
on a homebuilt CP/M computer of a friend.
muLISP-83 was already getting bloated. It had the
following error conditions:
Directory Full
Disk Full
End-Of-File
Insufficient Memory, Aborting
Memory Space Exhausted
Nonnumeric Argument
SYS File Not Found
Undefined Function
Zero Divide
P.