From: J W Dalton
Subject: Re: Why do people like C? (Was: Comparison: Beta - Lisp)
Date:
Message-ID: <CxBJ7o.9Kv@festival.ed.ac.uk>
·····@RedRock.com (Bob Hutchison) writes:
>[Note, I've had to butcher the References: line in the header to post
>this message, sorry for any inconvenience...]
>In <··········@cogsci.ed.ac.uk>, ····@aiai.ed.ac.uk (Jeff Dalton) writes:
>>In article <··········@relay.tor.hookup.net> ·····@RedRock.com (Bob Hutchison) writes:
>>
>>Presumably you have tried to predict the behavior of C programs
>>and found that it can be difficult. That is, you've written C
>>programs that didn't behave as you expected and had to be debugged.
>>Presumably you don't think it's easy to predict the behavior of
>>C programs in general.
>You presume correctly. I don't think I am suggesting anything magical
>here. In fact, I don't think that I am suggesting that a hardware model,
>in fact, helps any programmer at all. I only suggest that programmers,
>perhaps, learn like other adults and attempt to use simple or already
>understood frameworks to learn new things. I only suggest that because
>of this they believe they can learn C more easily than lisp, and perhaps
>this is true.
>I am also suggesting that this is probably a mistake on their part.
Ok. That was not clear (to me) before.
>>Surely there's a wide range of Lisp programs whose behavior is
>>as easy to predict as that of similar C programs.
>And surely there is a wide range of lisp programs that are not
>similar to their C counterparts. Surely this is true of any language
>that is 'higher level' than another.
Yes, though I'm not sure I understand what people mean by "higher
level" these days. Look at "very high level" which seems to include
ML on one hand and very specialized languages such as eqn, with
awk, perl, etc near the specialized end.
>>>I think that hardware is designed to support already common environments,
>>>like UNIX and DOS/Windows.
>>
>>Really? Is that what hardware designers say?
>If not the designers themselves then their (pay) masters. The
>ones I know are *very* concerned about this, they were burned once...
>I would't think this is necessarily true of academic designers, but then,
>we are talking about a world that largely requires commercial sponsorship
>for university research.
Humm. I find it hard to see Intel 386-boxes as being designed to
support Unix, and yet they're very successful as products. Earlier
Intels were far worse, but also successful. Many people went wrong
thinking that hardware should be oriented towards particular languages
-- consider Lisp machines; the idea that we should microcode instruction
sets for Prolog, Lisp, etc; object-oriented machines like the Rekursiv;
and so on.
-- jd
On Fri, 7 Oct 1994, J W Dalton wrote:
> .... Many people went wrong
> thinking that hardware should be oriented towards particular languages
> -- consider Lisp machines; the idea that we should microcode instruction
> sets for Prolog, Lisp, etc; object-oriented machines like the Rekursiv;
> and so on.
This may be a different thread, but: it isn't clear to me that "thinking
that hardware should be oriented towards particular languages" was where
the Lisp machine makers "went wrong."
From: Jeff Dalton
Subject: Re: Why do people like C? (Was: Comparison: Beta - Lisp)
Date:
Message-ID: <CxtyIG.GtK@cogsci.ed.ac.uk>
In article <········································@swim5.eng.sematech.org> "William D. Gooch" <······@swim5.eng.sematech.org> writes:
>On Tue, 11 Oct 1994, Jeff Dalton wrote:
>
>> ....
>> But specialized hardware was *a* mistake because ordinary hardware
>> often worked just as well or better. Consider Lingo, the language
>> for the Rekursiv. An implementation on a not very fast Sun was
>> faster than the one on the specialized machine. Or consider what
>> happened to the early-80s trend towards microcoding once RISC came
>> along. Specialized machines are CISC++, so to speak.
>>
>> Non-specialized machines were cheaper and faster as well as supporting
>> a wider range of software....
>
>The latter is of course generally correct, but I disagree with the
>assertion that stock hardware is/was cheaper and faster for doing
>Lisp work than Lisp machines. When Lisp machines were first created,
>they were faster than anything available for doing Lisp (early 3600s
>benchmarked very favorably relative to DEC20s, which were still fairly
>commonly used for Lisp at that time. Sun had yet to offer a
>reasonably-priced system in those days.)
>
>Price/performance has improved markedly since then. Nowadays, you could
>probably get a used Symbolics XL1200 for around $10k or less, and even when
>they were newer they were cost-competetive with Unixes.
I assume that some specialized machines were faster than the
alternatives, because otherwise the idea that specialized machines
were the right way to go wouldn't have lasted as long as it did.
Symbolics machines may well have been among these faster machines.
Indeed, I did use a Symbolics a bit at a time when it was faster
for Lisp than Lucid CL on whatever Sun I had access too. But
storage management (and other things) got a lot better in Lucid
after that.
But for how long could specialized/specially-microcoded machines
continue to be faster than the alternatives? The value of a used
Symbolics these days is not really a fair measure.
-- jeff
From: Simon Brooke
Subject: Re: Why do people like C? (Was: Comparison: Beta - Lisp)
Date:
Message-ID: <CxMo10.514@rheged.dircon.co.uk>
This thread has been rumbling on for some time, and the longer it
rumbles the more it bothers me. In it, various people (Jeff Dalton,
Bob Hutchinson, and the implausibly named Cyber Surfer amongst others)
have been arguing about whether C is easier to learn than LisP because
it more closely models hardware. Guys, what's hardware?
Xerox used to have a chip (it was never marketed, I think) which did
selector-method resolution (working out which method of which class is
being referred to in a message passed to an object) in one machine
instruction -- no, I do not jest. People can build in hardware any
unit of logic that we programmers use sufficiently frequently. Part of
the art of carving silicon is judging which operations are
sufficiently general to be made part of the sculpture, rather than
part of the song.
OK, so now we have a silicon aesthetic which says we don't carve out
any piece of logic we can't evaluate in a single tick of the clock,
but that's a fashion. It ain't graven in stone. Likewise, I once
spent a bored couple of days while recovering from 'flu working out
how you could build a LisP interpreter using only clockwork components
(rods, levers, cams and cogs).
The only difference between hardware and software is that software
works by logic, and consequently one can understand it. Hardware works
by improbable and unlikely things like quantum mechanics and electron
tunneling, and anyone who understands that hasn't got *time* for a life.
--
·····@rheged.dircon.co.uk
-- mens vacua in medio vacuo --
In article <··········@rheged.dircon.co.uk>
·····@rheged.dircon.co.uk "Simon Brooke" writes:
> This thread has been rumbling on for some time, and the longer it
> rumbles the more it bothers me. In it, various people (Jeff Dalton,
> Bob Hutchinson, and the implausibly named Cyber Surfer amongst others)
> have been arguing about whether C is easier to learn than LisP because
> it more closely models hardware. Guys, what's hardware?
I haven't been wondering that. I was merely sucked into this thread
from another. I'm not interested in comparisons between Lisp and C.
Such discussions often bore me. I'm far more interested in issues
which are specific to Lisp. I'm certainly don't want to discuss the
hardware "model" that programmers learn, as I feel the model could
just as easily be an abstract machine nothing like the actual hardware.
C could be relevant to this thread while we discuss the way that the
first computer language(s) we learn help define the "model" we use
for the computer. As I've said, I originally used Basic, altho I later
learned that the hardware was very different. I just had no way of
knowing that when I began programming.
Some Lisp tutorials provide a Lisp interpreter at some point (like
the "Lisp in Lisp" chapter in Winston and Horn), and that might help
give a new programmer a model for the language (not the machine) which
is defined using the language itself.
I remember that Smalltalk-80 was treated in a similar way, in one of
the Xerox books. The ST80 definition is not just a language, tho. It
defined the way an "virtual machine" behaved. This was done using a
virtual machine written in Smalltalk, instead of C, Pascal, etc.
--
"Internet? What's that?" -- Simon "CompuServe" Bates
http://cyber.sfgate.com/examiner/people/surfer.html