Oh, and a little history
Thomas Bushnell, BSG
Since Scheme (1975) predates Common Lisp (1984), it is incorrect to
say that Scheme somehow "split off" from Common Lisp.
And the irony here is that one of the most important things that
Common Lisp did to replace MacLisp and ZetaLisp and FranzLisp and all
the rest was its dedication to lexical scoping.
The reason Common Lisp and Scheme both have lexical scoping is surely
do to the fact that Guy Steele was a critical factor in the
development of both.
Thomas
Kent M Pitman
> Since Scheme (1975) predates Common Lisp (1984), it is incorrect to
> say that Scheme somehow "split off" from Common Lisp.
Right. It diverged from the Maclisp family.
> And the irony here is that one of the most important things that
> Common Lisp did to replace MacLisp and ZetaLisp and FranzLisp and all
> the rest was its dedication to lexical scoping.
Well, important technically. But the truth is that the one and only
important thing that actually allowed it to replace all those dialects
was to seek community consensus on the single question "is this compromise
between those various dialects better than using Interlisp?"
My understanding is that CL arose because ARPA thought there were more
users of Interlisp than of Maclisp and wanted all contracts done in
one dialect, which was in danger of being Interlisp. The Maclisp
community was myriad incompatible but culturally similar dialects and
had more users than the Interlisp community, but only if they put aside
their petty differences and agreed that survival was more important than
this or that nitpicky little language bandwagon.
> The reason Common Lisp and Scheme both have lexical scoping is surely
> [due] to the fact that Guy Steele was a critical factor in the
> development of both.
Yes and no. There was a LOT of hassling about it and Steele's stature
and steady hand certainly helped with the mechanics, but the idea had
been around for a while. It was already the case that compiled
Maclisp code had lexical variables -- it was only the notion of
variable capture that was new. But the idea of "losing dynamic
nature" was old hat. Plus, those of us who had built and tried to
debug large systems full of specials _knew_ that there was a big gain
to be had in getting rid of specials where not needed, and we'd all
programmed in other languages that had lexicality of that kind. (Capture
only comes up when you have the first class procedure notion and so was
the only new issue.) Having lexicality _by default_ was probably the big
change, but lexicality itself was certainly something everyone was ready
to have to some degree. It was mostly a matter of convincing people that
since production code was mostly all compiled, that people were already
used to lexicality... I guess all I'm really saying is that Steele or not,
it was something whose time was coming. Sort of like a big change was due
in the Soviet Union, Gorbechev or not, even though having Gorbie there
definitely helped things happen at that instant.
Erik Naggum
| Since Scheme (1975) predates Common Lisp (1984), it is incorrect to
| say that Scheme somehow "split off" from Common Lisp.
Who has argued this?
The curse of stupidity is that it is so easy to argue against something
stupid that somebody else does in fact _not_ mean. Many idiots on the
Net spend all their time arguing about what others have _not_ said,
forcing those they portray as morons by virtue of arguing against moronic
drivel they impute to them. In general, these are the trolls in any
forum, but it happens to people who fail to get a following for their
views, too, but losing one's objectivity and ability to read what other
people are _actually_ writing is flat out extremely annoying.
It is a fact that the Scheme community has split off from the community
that went on to produce Common Lisp. Stupid non-arguments like which
language predates which is fantastically counter-productive, because it
is not an argument against anything anybody has actually said, but only
serves to portray those who have said something else as stupid and to
hold opinions that are so easily refutable that one has to assume that
every thinking person on the planet does _not_ hold them.
Expect other people to be more intelligent than you and know more than
you do -- it leads to an ability to _listen_ that far surpasses those who
think they are the smartest and most knowledgable person on planet earth,
in general or in some particular respect. If you assume that others are
idiots and argue against moronic arguments they have not actually made,
you only lower the level of the communication to that level.
Those who argue so fervently for Scheme's superiority, for instance,
usually impute all sorts of weird intents and purposes to those who
created Common Lisp, and argue against "historical baggage" and whatnot,
not even _realizing_ that a new, improved language is a package away.
///
--
In a fight against something, the fight has value, victory has none.
In a fight for something, the fight is a loss, victory merely relief.
Thomas Bushnell, BSG
> It is a fact that the Scheme community has split off from the community
> that went on to produce Common Lisp.
Who are those people? Steele? Sussman? Which people "left"?
> Expect other people to be more intelligent than you and know more than
> you do -- it leads to an ability to _listen_ that far surpasses those who
> think they are the smartest and most knowledgable person on planet earth,
> in general or in some particular respect.
I have seen no evidence that you follow your own advice here. But one
thing is clear: you are just irreforambly unpleasant.
I figured I'd do a reality check: I'd see whether a bajillion people
insult me on comp.lang.lisp, or just you. Yep, just you.
Then I'd check to see whether you insult only me, or a bajillion
others too. Yep, you insult a bajillion people.
It's clear to me that the reason we don't get along is that you've
chosen (for whatever reason) that you don't want to get along with
people in general.
It's a real shame, because I can remember when I respected you.
The only effect of your messages is that gnus now permanently scores
your articles so low, that I won't be bothered by them. Fortunately,
the rest of the newsgroup is still good reading, despite the way you
want to spew urine all over the floor.
Thomas
Erik Naggum
| Who are those people? Steele? Sussman? Which people "left"?
Troll. You know full well that the communities are different and how
they have developed differently and have different values, and are now
only being an annoying asshole. Such passive aggressiveness is perhaps
the leats honorable way of dealing with other people, but you are also
quite the master of it, accusing people of things they have not done by
responding to something as if they had.
| > Expect other people to be more intelligent than you and know more than
| > you do -- it leads to an ability to _listen_ that far surpasses those who
| > think they are the smartest and most knowledgable person on planet earth,
| > in general or in some particular respect.
|
| I have seen no evidence that you follow your own advice here. But one
| thing is clear: you are just irreforambly unpleasant.
People who lie and misreprsent me, who go out of their way to annoy me,
and who assume that the most idiotic thing they can think of is what I
have meant, generally do not prompt me to be nice to them. Is that a
surprise to you? You demand slack for yourself, but cut me none.
| I figured I'd do a reality check: I'd see whether a bajillion people
| insult me on comp.lang.lisp, or just you. Yep, just you.
You have been "insulted" by a "jibe" back at you when you were joking
about something, and you found something much less provocative than your
own stuff "strongly provocative", and then you spend your time attacking
me and portraying me as something I am not, and you expect _not_ to be
treated harshly in return? Gime me a break! Do you think I _like_ the
kind of holier-than-thou, moralistic bullshit that the likes of you
fault-finding, blame-throwing assholes squirt out of yourselves? Clean
up your own goddamn act before you hand out judgments!
Who is the "only" person you go out of your way to insult? Me! Why is
that? What is wrong with you who have to blame me for your own actions?
Only the morally delinquint have to resort to such tactics. Only those
of a criminal mind betray a permanent failure to accept responsibility
for their own actions. It is always somebody else's fault that they
cannot behave, and those who call them on their misbehavior are at fault
for their problems, too.
You have responded with hostilties to innocent jokes and gestful remarks
about the loser language Scheme, probably because it is near and dear to
you, but that is not my problem. Take charge of your own values, dimwit!
"Hey, I like Scheme" is such a better response than "Common Lisp sucks",
which you have engaged in when you felt I said something negative about
Scheme. This is _not_ a Scheme-lovers forum. Expect people to dislike
something you like when you are no longer in fora expressly dedicated to
what you like, but be smart enough not to insult what people have joined
a forum because they like. Is this so hard to understand for you?
| Then I'd check to see whether you insult only me, or a bajillion others
| too. Yep, you insult a bajillion people.
Yeah, try to make it my fault that you insult me. Pathetic loser.
If you have figured all these things out, why do you keep posting
inflammatory crap about and towards me? Is it somehow morally justified
in your twisted hypocritical ethics to attack those you blame for your
own misbehavior? Do you have no control over your actions because you
feel incensed? You choose to _act_ on your own accord, Thomas Bushnell.
| It's clear to me that the reason we don't get along is that you've chosen
| (for whatever reason) that you don't want to get along with people in
| general.
You have no idea what I want.
I want, for instance, to be relieved of religious crap about Scheme and
strong typing because I think those things are horrible wastes of human
ingenuity, and most people are smart enough to talk warmly about these
things elsewhere, because they know how annoying such topics are to at
lot of people, especially when they turn to talk about how Common Lisp
"lacks" so and so feature that Common Lisp people do not want to have in
the first place. I want, for instance, to be relieved of the terrible
speeches made by George W. Bush over this War on Terrorism, and lo and
behold, I find none of them here.
I actually want respect for the choices I have made. I actually like
Common Lisp just the way it is. A whole bunch of other people have made
the same choice, and some of us are here in comp.lang.lisp, and that is
_why_ we are here in comp.lang.lisp. However, _repeatedly_, we have some
jerkoff from some other language newsgroup come trolling here with his
"your choice is wrong" rhetoric, arguing for something I have made a very
conscious decision I do not want. I grow tired of defending my choice
all the time in the forum that was created to _cater_ to my choices.
You have told me about the soc.motss trolls who go into that forum with
the sole purpose of telling people how the choices made by the residents
are wrong, how they "should" choose something else, etc. You have found
a good way to deal with that. Perhaps it works well there. Over here,
we have self-righteous assholes from the Scheme camp in particular come
and preach their unwanted gospel and then have the gall to be _offended_
when they are told to leave! What kind of disrespect for other people's
choices and decisions do those Scheme freaks suffer from? Why are you so
unable to understand that those who inhabit comp.lang.lisp actually
_like_ what Common Lisp offers? All that arrogant nonsense about "Lisp"
being a large family and that D*lan and Scheme freaks have the right to
post about the superiority of their pet languages hwre instead of the
newsgroups that were created to let people who _agree_ to that nonsense
(in my view) enjoy their own company, _really_ bugs me. Cut it out!
I want, in general, to find refuge from the mind-numbing incompetence
that is so highly valued by the clueless bosses you are disloyal to.
| It's a real shame, because I can remember when I respected you.
Whereas I do not take your lack of ability to keep your Scheme rants to
an appropriate forum or your hypersensitivity about jokes about Scheme
personally. I think Scheme is a _bad_ language, and I say so. If you
take this personally, you _are_ a fool. Please note that you do in fact
respond with personal attacks when I have ridiculed Scheme or perhaps
your arguments. I have little respect for people who do that, and I
could not care less what they try to blame me for when they are clearly
responsible for it entirely on their own.
| The only effect of your messages is that gnus now permanently scores your
| articles so low, that I won't be bothered by them. Fortunately, the rest
| of the newsgroup is still good reading, despite the way you want to spew
| urine all over the floor.
Your own role in this is of course as a saint, you are an undeserving
victim of any "abuse" and "insult" -- even when it is not there -- and
there is of course no room for the kind of "humor" you want to reserve
for yourself. Such hypocrisy and holier-than-thou attitudes generally
produce hostilities everywhere.
Unlike you, I have a purpose with being here: I want to read about fun
and interesting stuff in, about, and with Common Lisp. I do not want to
read yet another discussion of why Common Lisp is broken by design, why
the choices made by Scheme or D*lan or whatever are better. I am so sick
and tired of the negativity that you fault-finding, blame-throwing
assholes have to bring to this forum that I probably pull out the .45 and
shoot you guys in the knee just for your failure to respect that the
choices people have made in this forum should be respected on their own
premises, but then I see that you think you have a goddamn _right_ to
annoy people here because you think D*lan or Scheme "is a Lisp" and
therefore _must_ be tolerated, and _you_ caanot deal with the fact that
my opinion is that you should go somewhere else. You have your own
little fan clubs. Go have your fun there and invite those who would like
to take part in it to do so, do _not_ force your stupid opinions on
people who have repeatedly told you to get lost.
Besides, the strongest reason I think Scheme sucks is that the only
people who have bothered to bring Scheme to my attention are assholes who
sneer at Common Lisp in one way or the other. Lacking call/cc is a great
plus. Funcall is much better than one namespace. Seeing recursion as
some sort of "superior" way to deal with things is dumb. Not seeing
assignment and side-effects as different is dumb. I would love never to
be reminded of Scheme's existence again. Trust me, if I want Scheme, I
know where to find it. Just like Perl or C++, two other languages for
whose apologists and propagandists I have absolutely no tolerance.
My message is simply: Take your Scheme discussions to comp.lang.scheme!
When you guys refuse and start being snotty and arrogant about Scheme
being a Lisp, you have lost track of whatever purpose you had in talking
about Scheme in the first place. It becomes much more important to you
to defend Scheme's status as "a Lisp" than to talk about _any_ other
interesting thing, and you get emotionally entangled in the rejection of
your pet language, even though you are not on that pet language's home
turf. You have to accept that your loser languages are disliked by some
people outside of their dedicated fan clubs. Inside the fan clubs, it
would be gravely insulting and annoying and trolling to denigrate them,
but somehow you unprincipled, hypocritical retards think that only Scheme
needs this respect, and Common Lisp does not. I reverse that and watch
you guys make a spectacle of yourselves, usually ending up with being
such low quality human beings that you have come out on top by throwing
all blame on someone else. Only _bad_ people who know they are bad need
to make somebody else responsible for their own bad actions. This is
what gets personal, because those who have an inability to accept a
simple rejection of their chosen language, certainly have no ability to
accept rejection of their behavior. Such are the nature of the people
you have chosen to be a member of, Thomas Bushnell, by putting yourself
in the "bajillion people" that I supposedly insult: idiots and morons who
fail to grasp the simplest little thing about rejection of their ideas.
But why do I bother to tell you things that I _expect_ that you will
respond to with 100% emotion and _no_ rational thought whatsoever? I
believe you have the choice to think and _could_ exercise it. Some
people resort to feeling when they feel pressed, others to thinking.
Some even figure out who is the real sort of their experience of pressure
(themselves) and figure out how to stop feeling pressure _without_ making
any sort of attempt to blame anyone else for it. Such people are maybe
not the majority, but they exist. Most people work that way when they
are not threatened, but what possible _threat_ could somebody's opinion
as stated on a newsgroup be? Being annoyed and asking someone to leave
does _not_ merit a personal attack in response from the _offender_.
I wager a bet that you were unable to read this message without being
engufled in hostile emotions, and consequently expect an emotional
response, rife with insults and innuendos, arguments against things I
have not said, omniscient insight into my mind and my desires and
intents, perfect and flawless understanding of everything I have said,
and absolutely none of the latitude you require for yourself.
Furthermore, your arrogance will most probably exceed itself with a
renewed display of your perfect insight into who I am, because you have
to take _revenge_ -- the least intelligent of all human emotions, the way
our psychology tells us that our intellect is insufficient to deal with
an unwanted situation. Surprise me, Thomas Bushnell, and be smart. I
know you can, because you can do it when you do not have to "win".
Thomas Bushnell, BSG
> But why do I bother to tell you things that I _expect_ that you will
> respond to with 100% emotion and _no_ rational thought whatsoever?
The amazing thing is that this sentence is embedded in a message
which, um, is a big giant emotional diatribe, completely devoid of any
content, let alone some semblance of rationality.
Ah well, gnus reports that it's probably the last message I'll see.
Thomas
Erik Naggum
> But why do I bother to tell you things that I _expect_ that you will
> respond to with 100% emotion and _no_ rational thought whatsoever?
* Thomas Bushnell, BSG
| The amazing thing is that this sentence is embedded in a message which,
| um, is a big giant emotional diatribe, completely devoid of any content,
| let alone some semblance of rationality.
No, the most amazing thing is that it was rhetorical and had its own
answer:
> I believe you have the choice to think and _could_ exercise it.
But you did not, exactly as I had expected. Your need to portray me as
the psychotic delusion you suffer from is disturbing. You see things and
refuse to listen to any advice to pull yourself together. But that is
not my problem, any more. You have proven that you cannot think under
the pressure you have created entirely on your own. Pretty damn stupid.
Rahul Jain
> Since Scheme (1975) predates Common Lisp (1984), it is incorrect to
> say that Scheme somehow "split off" from Common Lisp.
Scheme split off from LISP, not Common Lisp.
> And the irony here is that one of the most important things that
> Common Lisp did to replace MacLisp and ZetaLisp and FranzLisp
I thought that was where the name "Common" came from.
> and all the rest was its dedication to lexical scoping.
And addition of CLOS and standardization on defmacro-style macros (and
compiler macros?). What else?
> The reason Common Lisp and Scheme both have lexical scoping is
> surely do to the fact that Guy Steele was a critical factor in the
> development of both.
"Surely", then Java's lexical scoping would be a result of Steele's
involvement. I'm sure it was a small factor, but it seems to me that
the existing lisp system implementors were coming to that conclusion
slowly, too. I assume Steele was just the force that made them stick
to it as the universal default.
From what I've heard and understood myself, Scheme was the Lisp
lexical scoping (and other stuff) "experiement" and CL integrated the
findings into mainstream Lisp. From there, Scheme continued to evolve
into a language that the community that built around it wanted, as any
language does and should.
Note that I was a mere child during just the tail end of this
process. Did you experience all this firsthand, from the inside, as
you seem to want to imply? (And are attempting to "educate" people who
were as to what "really" happened.) I don't understand what you're
trying to prove here at all, besides the fact that you feel like
arguing about the implementation details about something you neither
want to implement nor want to understand how to implement. If you'd
like me (or anyone else who shares this view) to have a different
view, please make an effort to show us that it's not true.
--
-> -/ - Rahul Jain - \- <-
-> -\ http://linux.rice.edu/~rahul -=- mailto:rj...@techie.com /- <-
-> -/ "Structure is nothing if it is all you got. Skeletons spook \- <-
-> -\ people if [they] try to walk around on their own. I really /- <-
-> -/ wonder why XML does not." -- Erik Naggum, comp.lang.lisp \- <-
|--|--------|--------------|----|-------------|------|---------|-----|-|
(c)1996-2002, All rights reserved. Disclaimer available upon request.
Raymond Toy
Kent> tb+u...@becket.net (Thomas Bushnell, BSG) writes:
>> Since Scheme (1975) predates Common Lisp (1984), it is incorrect to
>> say that Scheme somehow "split off" from Common Lisp.
Kent> Right. It diverged from the Maclisp family.
>> And the irony here is that one of the most important things that
>> Common Lisp did to replace MacLisp and ZetaLisp and FranzLisp and all
>> the rest was its dedication to lexical scoping.
Kent> Well, important technically. But the truth is that the one and only
Kent> important thing that actually allowed it to replace all those dialects
Kent> was to seek community consensus on the single question "is this compromise
Kent> between those various dialects better than using Interlisp?"
Kent> My understanding is that CL arose because ARPA thought there were more
Kent> users of Interlisp than of Maclisp and wanted all contracts done in
Kent> one dialect, which was in danger of being Interlisp. The Maclisp
Kent> community was myriad incompatible but culturally similar dialects and
Kent> had more users than the Interlisp community, but only if they put aside
Kent> their petty differences and agreed that survival was more important than
Kent> this or that nitpicky little language bandwagon.
Can someone explain why Interlisp seems to be so bad? I've never used
any of these old dialects, so I'm curious.
Ray
Christopher Browne
> >>>>> "Kent" == Kent M Pitman <pit...@world.std.com> writes:
> Kent> tb+u...@becket.net (Thomas Bushnell, BSG) writes:
> >> Since Scheme (1975) predates Common Lisp (1984), it is incorrect to
> >> say that Scheme somehow "split off" from Common Lisp.
>
> Kent> Right. It diverged from the Maclisp family.
>
> >> And the irony here is that one of the most important things
> >> that Common Lisp did to replace MacLisp and ZetaLisp and
> >> FranzLisp and all the rest was its dedication to lexical
> >> scoping.
>
> Kent> Well, important technically. But the truth is that the
> Kent> replace all those dialects was to seek community consensus
> Kent> on the single question "is this compromise between those
> Kent> various dialects better than using Interlisp?"
>
> Kent> My understanding is that CL arose because ARPA thought
> Kent> wanted all contracts done in one dialect, which was in
> Kent> danger of being Interlisp. The Maclisp community was
> Kent> myriad incompatible but culturally similar dialects and
> Kent> had more users than the Interlisp community, but only if
> Kent> survival was more important than this or that nitpicky
> Kent> little language bandwagon.
>
> Can someone explain why Interlisp seems to be so bad? I've never
> used any of these old dialects, so I'm curious.
Interesting question indeed.
Interlisp seems to be quite the pariah, today.
I'm not sure but that it may be suffering from the "history is written
by the winners" problem. There are no apologists for Interlisp
around, but there certainly are, for CL, so we fairly exclusively hear
the CL side of the story.
In effect, Interlisp has the 'effete British accent' that allows it to
be treated as a Hollywood villain. Bad guys might have German or
Russian accents, but the Really Bad Guys always have British
accents...
--
(reverse (concatenate 'string "gro.gultn@" "enworbbc"))
http://www3.sympatico.ca/cbbrowne/wp.html
Barry Margolin
Rahul Jain <rj...@sid-1129.sid.rice.edu> wrote:
>tb+u...@becket.net (Thomas Bushnell, BSG) writes:
>> and all the rest was its dedication to lexical scoping.
>
>And addition of CLOS and standardization on defmacro-style macros (and
>compiler macros?). What else?
CLOS and compiler macros weren't part of the original Common Lisp, as
defined in CLTL1. They weren't added until CL was in extensive use and
undergoing ANSI standardization.
The most significant difference between Common Lisp and most of the Lisps
that it was derived from was, indeed, the consistent use of lexical
scoping. Maclisp was inconsistent about it: the interpreter was
dynamically scoped, while the compiler was lexically scoped except for
variables declared special.
Most of the other differences between CL and its progenitors were in
details (e.g. the inclusion of rational and complex numbers, some function
name changes), rather than overall language philosophy.
--
Barry Margolin, bar...@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.
Bijan Parsia
[snip]
> Interlisp seems to be quite the pariah, today.
It does? I thought it was undergoing a very small..well, "revival" is
wrong. Revival in interest?
> I'm not sure but that it may be suffering from the "history is written
> by the winners" problem. There are no apologists for Interlisp
> around, but there certainly are, for CL, so we fairly exclusively hear
> the CL side of the story.
[snip]
Except Kent recently (within the last year) expressed regret that Common
Lisp set out to slay Interlisp (without pilliging it first :)).
From what I can tell, it *was* the case that CL was (very
partially) intended for the slaughter of InterLisp. It succeeded and
there's no need to posit its *continued* villianhood to acknowledge that
it is pretty well dead and gone :)
I think InterLisp's lack of presence in the current Lisp intellectual
space is just the result of the earlier battles, not an ongoing
campaign. Lack of archeology, rather than active historicized propaganda,
seems to be the main culprit.
Cheers,
Bijan Parsia.
Tim Bradshaw
> Erik Naggum <er...@naggum.net> writes:
>
> > It is a fact that the Scheme community has split off from the community
> > that went on to produce Common Lisp.
>
> Who are those people? Steele? Sussman? Which people "left"?
Are you trying to imply that the communities are the same? Or,
alternatively that they were always different (and if so, how far
back? Which community did John McCarthy belong to in 1958?).
--tim
Kent M Pitman
> Raymond Toy <t...@rtp.ericsson.se> wrote:
...
> > Can someone explain why Interlisp seems to be so bad? I've never
> > used any of these old dialects, so I'm curious.
>
> Interesting question indeed.
>
> Interlisp seems to be quite the pariah, today.
>
> I'm not sure but that it may be suffering from the "history is written
> by the winners" problem. There are no apologists for Interlisp
> around, but there certainly are, for CL, so we fairly exclusively hear
> the CL side of the story.
Oh, I didn't mean it to be all of that. I meant actually to NOT
rewrite history. The fact is that the Maclisp community _did_
generally have a major dislike of the Interlisp community. And so
they didn't want to give up Maclisp. I personally think it was a
simple turf war in the sense that it was very much an "us" vs "them"
thing from where I stood, brought mostly about by the fact of a big
geographical divide (Interlisp being largely a west coast team and
Maclisp being largely an east coast team), and though we were all on
one big ARPAnet (all 256 or so computers of it, exhausting its address
space as I recall), that wasn't enough to bridge it.
I think that had the communities been swapped, with the east coasters
liking Interlisp and being threatened by a west coast Maclisp, east
coasters would have still won because they played better politics.
But that's just a guess. So in that sense it probably was a turf war.
I hadn't meant to comment on whether Interlisp was actually Bad.
Actually at the time I saw it as more unambiguously bad than
I do now. And so, with hindsight, I happen to personally think myself
less prone, not more prone, to be historically revisionist than I
would have been some years back. Because I think I finally appreciate
Interlisp better. ... but even so, I think the Maclisp people were
right and I more lament the need for conflict than the choice of victor.
More below.
> In effect, Interlisp has the 'effete British accent' that allows it to
> be treated as a Hollywood villain. Bad guys might have German or
> Russian accents, but the Really Bad Guys always have British
> accents...
Heh.
There were several material points of difference between the Interlisp
community:
One was that in Interlisp, you didn't have a real choice of editor. It
used a Lisp structure editor, not a text editor. It pretty printed
everything back at you, and things like #. or ; comments that are lost
during read would have been largely pointless. This irritated people
in the Maclisp community a lot because it made comment placement hard and
it didn't allow source text editing. But did have one surprising feature
that really stunned me to learn about later: it explained why the Interlisp
D-machine (effectively an Interlisp "lisp machine", though I'm not sure if
it was Lisp all the way down) window system came up with stretchy windows
(like modern resizable windows) and the Lisp Machine window system assumed
fixed size windows by default and you had to do more work to change the size.
Lisp Machine source text, being text, was fixed in size and didn't reshape
as you stretched the window, so it wanted a certain target size. Interlisp
source, because it was structural, not text, did reshape as windows did.
(Something for the Python crowd to contemplate.)
I never used Interlisp, contributing partly to my personal fear of it
then (which is only sadness now). But I've seen Interlisp people try
to turn Maclisp into Interlisp for comfort, and I've perused the
manual, and it seems did much more loading and saving of execution
worlds like organic critters, perhaps because source was deemphasized.
A major difference was DWIM (do what I mean) which was a very
controversial heuristic tool that invaded everything you did, fixing
things. DWIM stood for "Do What I Mean" though it was often called by
some "Do What Teitelman Meant" because its error corrections were
controversial. It could turn an expression like: 8setq x (plus y a9)
into (setq x (plus y a)) becuase it assumed you had failed to shift
your parens on the 8 and the 9... except some keyboards had parens on
the 9 and 0, and some systems had symbol names like 8setq. It would
perform "helpful" spelling correction with weird results. It even
"fix" coding errors for you.
DWIM horror stories were many, more often traded among Interlisp refugees
than Interlisp users, but that would be natural. Some of them were
not true and others were. One of them I heard went like this (and
again, I can't even say if this is an actual story of what DWIM would
do but it gives you the idea of what it had license to do and why
people both liked and feared it): A user didn't know how to use the
DECL facility so figured they would just say (DECL) and that DWIM would
help them. [This shows the trust aspect of a user who likes DWIM.] DWIM
realized that DECL was not actually a function name so searched for a
name to substitute that was better. It found DEL. [I think that was
the name. It's been many years now and I'm doing this from memory. The
function it found deletes files, anyway.] DEL isn't a function of no args
so DWIM "helpfully" assumed (DEL NIL) to pad out a good number of args.
But NIL was a wrong type of argument, so DWIM concluded a wildcard would be
most appropriate ... Well, you get the idea. A lot of people just wanted
DWIM turned off, and you can sort of see why. If you think Common Lisp
has fuzzy semantics, or you think some of my stories about Maclisp make it
sound like the unruly wild, wild west of Lisp, you should think of Interlisp
as all the more --- well, not unruly but weirdly ruly.
BUT, you couldn't just turn DWIM off because it had been around a long time
and lots of code needed it to survive. The case that troubled me, just
perusing the manual, was their "compiler macros" (which were not like our
compiler macros, but more like our "macros")... except they only worked
in the compiler. There was no equivalent interpreter feature as nearly as
I could tell. That was ok, of course, because when DWIM noticed you executing
a macro in the interpreter, it would "helpfully" expand it using the compiler
macro, and let you win. But this kind of help was not available if you
turned DWIM off.
All in all, when it came down to it, and the turf war began, my own
subjective impression was that Interlisp was not a good candidate for
an "implementation language". It was trying too much to suit the end-user
and not enough to suit the low-level user.
Now, Maclisp, in fairness, had a lot less user-friendliness than Interlisp
and that was bad, too. But my personal assessment, often stated at the time,
was that you could more easily build up from Maclisp to an Interlisp than
build up from Interlisp to a Maclisp.
The sad part was that it had to be either/or, but I gather this was an ARPA
decision, and more or less all money came from ARPA at the time because Lisp
was not out there in the marketplace and there wasn't much of a marketplace
to be out in for yet a couple more years. Pity.
Because when we beat Interlisp into submission, some very good work was
marginalized and it took a long time to get that crowd back "into the fold".
It wasn't until the ANSI process happened that the Interlisp folks showed
up again, and through their work in twisting Flavors (the de facto choice
of object system) into CLOS, putting their own mark onto things, that
Xerox PARC (the primary outcast) came back to our community.
And the real problem of having them be missing all that time was the loss
of a community that was very end-user focused. The interlisp community was
much more focused on tools that offered user interfaces, even at the price
of what I saw as a patchwork inside. While I might quibble with the insides,
it wouldn't have hurt us to end up with more UI widgets, such as
were offered by Visual Basic, HyperCard, and later web browsers... It might
have changed our position in the market at some critical times. It's hard
to know.
But evolution, whether for animals or for software systems, is like
that. At any given instant, it may be only one characteristic that
makes or breaks survival. Such as having a gray wing color in a moth
or the lack of DWIM for Interlisp. The fact that among moths
themselves, gray was always made fun of, or among Interlisp
programmers, DWIM was often revered, is hardly relevant. Selection is
often done from the outside, not the inside. That is, often by those
who understand and can appraise value the least. It's a wonder such a
mechanism works at all. But then, intelligence itself is an evolved
concept, and evolution itself can't rely on it in order to succeed.
Disclaimer: I did not use Interlisp and you should view the above comments
as more like the account of a war as later told by someone who was a
corporal at the time, not someone commanding troop movements. I was perhaps
a particularly well-placed corporal, since I had friends and even officemates
who were much higher in "rank" than I. But I'm sure there were some major
details that looked different to me than to others with more perspective.
My view is just one piece of a complex puzzle. But at least perhaps reading
my probably-faulty account is better than reading none at all.
Kent M Pitman
last post and ran across this entry in Risks Digest where DWIM was mentioned:
http://catless.ncl.ac.uk/Risks/7.13.html
So there's at least one more place to read about DWIM. Though I'd bet
Google (and perhaps even Risks) has plenty of others, too.
Thomas Bushnell, BSG
> A major difference was DWIM (do what I mean) which was a very
> controversial heuristic tool that invaded everything you did, fixing
> things.
DWIM was a great experiment, I think; in the sense that it was worth
trying, and produced a fairly clear conclusion: "bzzt, not the right
way."
In addition to the sorts of horror stories you give, DWIM has a
near-disastrous non-locality effect. A given piece of code will be
patched up to look "sane" given the current feature set of the
system. But when the feature set changes, the "nearest sane patchup"
may well be very different.
Consider something like an automatic spelling corrector on function
names. If the system (caveat: I can't remember if this is exactly how
Interlisp worked or not) corrects OPEN-WINDO (not defined) into
something "OPEN-WINDOWS", that may well be what the user intended.
But then the system evolves, and new dynamic wind management calls get
added, one of them called "OPEN-WIND". Whoops, suddenly OPEN-WINDO
has a new "nearest correction", and the same bit of source now calls
OPEN-WIND.
Thomas
Bradford W. Miller
Bushnell, BSG" <tb+u...@becket.net> sprach:
> Kent M Pitman <pit...@world.std.com> writes:
>
>> A major difference was DWIM (do what I mean) which was a very
>> controversial heuristic tool that invaded everything you did, fixing
>> things.
>
> DWIM was a great experiment, I think; in the sense that it was worth
> trying, and produced a fairly clear conclusion: "bzzt, not the right
> way."
There were other substantial environmental differences, e.g., on the D
machines. Having used three environments at the same time (Franz on Vax
750s, D machines, and Symbolics) porting code between them, I recall in
particular that the D machine environment was a function based organization
rather than file based. You had no way to introduce comments on a line other
than using the (comment "this is a comment") function. Function to file
mapping was done by the system, and files were for the most part "invisible"
to the programmer. This made it hard to write code that would port to other
lisps, because where do you put the #+ and #-? So you end up having ugly
code along the lines of (if (member :foo *features*) ...) which still didn't
help you when it came to differences the reader would choke on.
There were some nice things about InterLisp, which were never captured by
Common Lisp. The main thing I remember (only because the hack I had to come
up with for common lisp was so ugly and took so much time to debug) was that
in Interlisp the stack was a first class object. You could capture the stack
into a variable, and easily restore the stack to resume a prior programming
state. This let you implement scheme style continuations, and continuation
passing is actually quite useful in some situations (think oracular
computing, esp for NP problems). Continuations can be half-simulated using
the condition system (or even catch/throw) but only in the downward
direction (you can't pass a continuation upward on the stack). One can
coerce stack groups into such service, but only if you have enough source
code to copy stack groups rather than just allocate new ones (essentially
giving you the InterLisp capability directly).
Alas, I no longer have my Interlisp manual, so I can't reminisce further!
Brad
Carl Shapiro
I recall in
> particular that the D machine environment was a function based organization
> rather than file based. You had no way to introduce comments on a line other
> than using the (comment "this is a comment") function.
For what it's worth, I seem to remember that at least on Interlisp-D
(* comments looked like this ) and the pretty printer had some funky
way of moving comments closer to the right margin so that the
functional part of ones source code isn't cluttered by in-line
comments (perhaps that was just a hack that was always loaded in my
sysouts). Oddly enough, Zetalisp has a macro ZL:COMMENT which works
just like * on Interlisp. I always wondered how that ended up on the
LispM.
lin8080
> Erik Naggum <er...@naggum.net> writes:
*pssscht
Do you what to read this in 5 years ?
Than go on.
stefan
Kent M Pitman
It came from Maclisp. But it had the problem of creating lots of
random unwanted symbols and Maclisp, because it cared about image
size, being a fixed-address-space Lisp (I think unlike Interlisp,
which I vaguely recall as having virtual addressing built in
... although I have a dim memory of this being controversial, perhaps
because the way the memory was managed wasn't as efficient as on modern
systems...?)
Further, COMMENT could only be placed in certain places in programs, since
it was an actual form evaluation of which just returned the symbol COMMENT,
and so wasn't very practical for all cases. Semicolon comments supplanted
this. But Zetalisp tried hard to be Maclisp compatible so it could attract
Maclisp programs.
Also, comments usually have punctuation and so COMMENT wasn't good for
that. Though it was better back in the days before comma (,) was taken
over by backquote. In the early days of Maclisp, commas were whitespace
so you could write (3,5) instead of (3 5) to denote coordinate pairs.
That meant you could also write (comment i don't like this, do you?).
But as the macro character space got more fussy, this stuff was in danger.
Mostly COMMENT was useful for commenting out blocks of code, in the manner
that #|...|# does, modulo the following unpleasant issue of return value.
(DWIM would probably have just helpfully move the comment for you when
it was badly placed, for all I know... Not that I know what it would have
done about comments like (* The form immediately following this expression
is bogus). )
Tim Moore
>
>I never used Interlisp, contributing partly to my personal fear of it
>then (which is only sadness now). But I've seen Interlisp people try
>to turn Maclisp into Interlisp for comfort, and I've perused the
>manual, and it seems did much more loading and saving of execution
>worlds like organic critters, perhaps because source was deemphasized.
This seems to be the Xerox way. The Smalltalk system Squeak, which is
directly descended from Apple Smalltalk which is directly descended
from the classic Xerox Smalltalk, has not been compiled from source
files in over a decade. Fundamental changes, such as new object
representations or layouts, are made by grovelling over the current
image and writing out a transformed image. The state of the source
code corresponding to the image is maintained through change files.
Thanks for an interesting post!
Tim
Andreas Timmermann
> directly descended from Apple Smalltalk which is directly descended
> from the classic Xerox Smalltalk, has not been compiled from source
> files in over a decade.
It may even be 25 years. I've read a post claiming that remnants of
Smalltalk-76 are still present in the current (Squeak) image (even though it
didn't use a metaclass system introduced in ST-80).
It makes perfect sense in the Smalltalk world: The Squeak VM is written in a
subset of Smalltalk, tested and debugged in the image(!), and then converted
to C and compiled. No need to start from scratch.
Paul Wallich
(Tim Moore) wrote:
Of course, that's a very MacLisp- (and the rest of the world) centric way
of talking about things. My impression of Interlisp (from a very little use
but a quite a bit of time spent with the PARC and other people) was that
those files out there really weren't considered source code. The s-expressions
were the only "real" representation of the program or the system, and users
or programmers manipulated the running software directly rather than going
through edit-compile-load-run-curse like all those C and Fortran dweebs.
Common Lisp (and any lisp with a listener) maintains some of that flavor
because you can mess around with definitions and interact with a running
system, but once you've figure out what works, you've still got to go out
to your source files and make the changes that correspond to the state you
managed to achieve in your image. (Of course, most people just work in the
source files and recompile/load the changed definitions from there rather
than twiddling things directly in the listener, but it's not really the same.
Moore's Law just makes it seem the same.)
So Interlisp -- or so it seemed -- took the notion of code as data much more
seriously. As a result, the implementors had to pay a lot more attention to
multiple processes and the ability to maintain multiple incompatible states
of the world at the same time, much as MacLisp-family implementors have
had to pay enormous amounts of attention to maintaining information about
source-file contents to hide the fact that the "source" being manipulated
actually
lies outside the boundaries of the running lisp system.
I'm not anywhere near expert in this, but it struck me how that Tim Moore's
statement seemed to be using language and a set of reference points that
would be completely alien to an interlisp user (or a user of any other primarily
"in-core" language).
paul
Frank A. Adrian
> Alas, I no longer have my Interlisp manual, so I can't reminisce further!
Gosh ! That brings back memories! I ordered my manual from Xerox PARC in
1981 after I ordered the VAX port of Interlisp from whoever the heck was
doing that. The group I was working with had a killer machine for the day
(VAX-11/780 w/32 MB of RAM and 1 GB of hard drive space) and people still
complained whenever I fired up the image. Granted, Interlisp/VAX was never
touted as a speed demon (It's more interesting that the horse CAN dance...).
I think that your comments on stack reification points out one of the main
differences driving the MAC/Inter schism. The MAC folks wanted stuff to be
really fast (probably due to the influence of the Macsyma project) causing
them to eschew things like generators, spaghetti stacks, DWIM :-), which
the Inter folks thought were cool and neat implementation-wise and
ease-of-programming-wise (which they were, when they weren't totally FU'ed)
which always seemed to be a bit more important for the Inter folk than raw
speed. Looking at this with an outsider's view, it seems a classic case of
different values leading to different design choices. And, ultimately,
neither was wrong, one just won.
The CL community is probably a bit poorer for not doing more to mine the
Interlisp idea of doing away with files for source (you can still keep the
function source as a string in memory, after all), while they were probably
right for not exposing the stack in all its glory. In the end, I am just
happy that there was a language that was flexible enough to foster the
creation of these two communities and even happier that this language is
still around to be used.
Larry Clapp
> Consider something like an automatic spelling corrector on function names.
> If the system (caveat: I can't remember if this is exactly how Interlisp
> worked or not) corrects OPEN-WINDO (not defined) into something
> "OPEN-WINDOWS", that may well be what the user intended. But then the
> system evolves, and new dynamic wind management calls get added, one of them
> called "OPEN-WIND". Whoops, suddenly OPEN-WINDO has a new "nearest
> correction", and the same bit of source now calls OPEN-WIND.
Why didn't they do something analogous to what spell checkers do: ask "did you
mean ...?" and patch the code permanently? I read a bit about DWIM in
Steele's (and somebody else's) History of Lisp, but just assumed (incorrectly,
obviously) that it made permanent code changes.
-- Larry
Carl Shapiro
> Why didn't they do something analogous to what spell checkers do: ask "did you
> mean ...?" and patch the code permanently?
When DWIM is enabled it can operate in two modes, either "cautious" or
"trusting". When in "cautious" mode, DWIM would query the user with
its proposed correction before it made any changes. Only when the
user specifically changed the mode to "trusting" would DWIM
automatically go ahead with its proposed edits. As far as I know (and
the oldest reference I have, which predates my first encounter with
Interlisp, confirms this) Interlisp always shipped with DWIM enabled
and in "cautious" mode.
Thomas Bushnell, BSG
> It may even be 25 years. I've read a post claiming that remnants of
> Smalltalk-76 are still present in the current (Squeak) image (even though it
> didn't use a metaclass system introduced in ST-80).
So I've often wondered about this. Might there not be weird little
objects, live for no good reason, that are still hanging around? It
seems like this strategy is inclined to produce little bits of crufty
live data that hang on for years...
Is this a real problem? Does it get ignored, or do people have
techniques for making sure that the images really only have the
objects people want them to have?
Thomas
Thomas Bushnell, BSG
> There were some nice things about InterLisp, which were never captured by
> Common Lisp. The main thing I remember (only because the hack I had to come
> up with for common lisp was so ugly and took so much time to debug) was that
> in Interlisp the stack was a first class object. You could capture the stack
> into a variable, and easily restore the stack to resume a prior programming
> state. This let you implement scheme style continuations...
Wow, I'd never heard about that feature; kinda freaky from a
present-day perspective.
Do you know if people really did this in serious code, or was it just
entertained as a theoretical possibility?
Thomas Bushnell, BSG
> Why didn't they do something analogous to what spell checkers do:
> ask "did you mean ...?" and patch the code permanently? I read a
> bit about DWIM in Steele's (and somebody else's) History of Lisp,
> but just assumed (incorrectly, obviously) that it made permanent
> code changes.
A technique works like that for my copy of the code, but it doesn't
work for your copy. That is, if the code is published widely with the
spelling error, the system has no way of tracking down whatever copies
are lying on backup tapes and wherever else, and whose meaning is
changing weirdly over time.
Rahul Jain
> > I read a bit about DWIM in Steele's (and somebody else's) History
> > of Lisp, but just assumed (incorrectly, obviously) that it made
> > permanent code changes.
> A technique works like that for my copy of the code, but it doesn't
> work for your copy. That is, if the code is published widely with the
> spelling error, the system has no way of tracking down whatever copies
> are lying on backup tapes and wherever else, and whose meaning is
> changing weirdly over time.
but the error wouldn't have been made, since they had a structure
editor, where they could have easily put the DWIM features instead.
Tim Bradshaw
> It came from Maclisp. But it had the problem of creating lots of
> random unwanted symbols and Maclisp, because it cared about image
> size, being a fixed-address-space Lisp (I think unlike Interlisp,
> which I vaguely recall as having virtual addressing built in
> ... although I have a dim memory of this being controversial, perhaps
> because the way the memory was managed wasn't as efficient as on modern
> systems...?)
I don't know about interlisp in the abstract, but on the D machines
they definitely had VM, and it was efficient: when we moved away from
them someone did some benchmarks of (I think) KCL (may have been AKCL
by then) on various machines, ACL on various machines, and Medley
Interlisp (running CL code) on 1186s (doves) and 1109s (dandytigers).
The `various machines' were probably a vax 11/750 for KCL, an HLH
Orion 1/10 for KCL, and Sun3/80s, Sparcstation 1+s and 4/330s for KCL
and ACL.
The Suns in particular ate the D machines alive, *except* when the
problem became big enough to require significant paging, when the D
machines did astonishingly well (not well enough to stop us moving,
but much better than they otherwise did)
They also had a function called VM.PURE.STATE which altered the paging
algorithm such that dirty pages were written to new disk pages. Using
this you could do cheap checkpoints: VM.PURE.STATE followed by
something that ate the system and then a warm-boot (not sure if it was
called that) would get you back to where you were at the point when
you said VM.PURE.STATE. You could get the same effect by saving a
sysout (world load) but it was much, much slower, and the 1109s didn't
have enough disk to save very many sysouts (like 1).
Another thing about the D machines which was bad was that they did
reference counting and it wasn't very tweakable either. So they
leaked circular structure, and you had to be careful about that
(closures involved circular structure...) and there was really no way
of controlling the `GC' (if you call reference counting GC).
One other random thing I remember: they had a hard limit of 64k
symbols. Less than you'd like.
And the screens on the 1186s were *awful*. People used to swap them
at night to try and get a good one.
--tim
Paolo Amoroso
environment and the debate on structure vs text editing:
"Interactive Programming Environments"
D.R. Barstow, H.E. Shrobe, E. Sandewall
McGraw-Hill, 1984
ISBN 0-07-003885-6
610 pages
I got a used copy several months ago at AbeBooks. If I recall correctly,
when I placed my order there were at least half a dozen more used copies
available, at bargain prices (around a dozen bucks).
The book, for example, includes a paper with screen shots of a graphical
debugging session in which email was used for troubleshooting the problem.
Given that the original paper was published in the late seventies, this
must have looked really impressive.
Another not so obvious source of information on Interlisp may be your
nearest computer science department's library. Even if your library doesn't
apparently include much Lisp material, I suggest that you look in its
catalog anyway for keywords such as "interlisp" or systems written in
Interlisp, e.g. "notecards".
I was lucky with my library, which has some interesting material on
Interlisp. I found, for example, a bunch of very interesting papers on
NoteCards. But the most interesting paper on NoteCards, i.e. the one
describing its design and implementation, is unfortunately missing :-(
Paolo
--
EncyCMUCLopedia * Extensive collection of CMU Common Lisp documentation
http://www.paoloamoroso.it/ency/README
[http://cvs2.cons.org:8000/cmucl/doc/EncyCMUCLopedia/]
Erik Winkels
> "Andreas Timmermann" <Andreas_DOT...@t-online.de> writes:
>
> > It may even be 25 years. I've read a post claiming that remnants
> > of Smalltalk-76 are still present in the current (Squeak) image
>
> crufty live data that hang on for years...
This all reminds me of "A Deepness In The Sky" by Vernor Vinge. A
rather good science fiction book, if one is into that.
Erik.
Michael Parker
I was into Squeak when I first read this book, and the similarities
immediately hit me as well :-)
I never was able to get comfortable with the idea of not being able
to rebuild from sources. I guess the mindset you need is (and
certainly the one the Xeroxers seem to have) is to comfortably think
of the image itself as "The Source".
Heres a question for the ex-Symbolics people: How were the Ivory
and 36xx images built? From sources? Once an image had a
sufficiently-working image, new images (esp distribution images)
regularly built from sources?
Thomas Bushnell, BSG
> I never was able to get comfortable with the idea of not being able
> to rebuild from sources. I guess the mindset you need is (and
> certainly the one the Xeroxers seem to have) is to comfortably think
> of the image itself as "The Source".
I have a similar worry. Part of the problem is that I don't have an
easy way to "look over the whole image", and I *do* know how to "look
over the whole source" when that's a bunch of text files.
Thomas
Kent M Pitman
> Heres a question for the ex-Symbolics people: How were the Ivory
> and 36xx images built? From sources? Once an image had a
> sufficiently-working image, new images (esp distribution images)
> regularly built from sources?
I recall thinking it must be very much like the birthing of a
mammalian child, starting from a fetus in the womb. By relying on the
parent for basic services in the early times, you're freed of having
to actually accomplish tasks that, were you born rather than "under
construction", you'd have to accomplish on your own. (From a technical
point of view, by the way, this somewhat confirms that the political
notion some have that "life begins at conception" is probably not
technically defensible, at least for mammals, since structurally there
is not a whole new animal up and running at the moment of conception.
It is only partly there for quite a while, which I guess is what the
whole issue of "viability" is addressing.)
The problem is that there are cross-dependencies back and forth among
the innermost core sources that make it difficult to construct the
child without access to the parent. You could try to arrange things
so that everything happened linearly and the entire thing could grow
in isolation, but it makes it administratively harder. So what you do
is rely on the set of definitions in the parent to process the initial
definition setup and to get everything for basic life-support into
place. Then you output what's called a "breath of life" (BOL) world,
and you go to the FEP (Front End Processor, outside of Lisp) and you
kickstart the BOL world, telling it to compile and load everything
else it needs from external sources, sort of like spanking a newborn and
telling it to switch on its real world systems and to start learning
to walk and talk.
So the generation of a new BOL is done from sources but relies on a
pre-existing processor to execute. (Note that the first BOL had to be
cross-compiled by something on another processor, such as Maclisp.)
I think, though I've never attempted it myself, that it becomes
remarkably more difficult to start everything, even if you have all
the sources, if you don't have a running version somewhere.
It might be that you iterate this process once to assure that the BOL
is actually compiled by itself and not the previous version, but I'm not
sure it matters.
I could be wrong on some details of the above, and I hope that anyone
with better knowledge will chime in...
Michael Parker
>
> Michael Parker <des...@pdq.net> writes:
>
> > Heres a question for the ex-Symbolics people: How were the Ivory
> > and 36xx images built? From sources? Once an image had a
> > sufficiently-working image, new images (esp distribution images)
> > regularly built from sources?
> The problem is that there are cross-dependencies back and forth among
> the innermost core sources that make it difficult to construct the
> child without access to the parent. You could try to arrange things
> so that everything happened linearly and the entire thing could grow
> in isolation, but it makes it administratively harder. So what you do
> is rely on the set of definitions in the parent to process the initial
> definition setup and to get everything for basic life-support into
> place. Then you output what's called a "breath of life" (BOL) world,
> and you go to the FEP (Front End Processor, outside of Lisp) and you
> kickstart the BOL world, telling it to compile and load everything
> else it needs from external sources, sort of like spanking a newborn and
> telling it to switch on its real world systems and to start learning
> to walk and talk.
>
> So the generation of a new BOL is done from sources but relies on a
> pre-existing processor to execute. (Note that the first BOL had to be
> cross-compiled by something on another processor, such as Maclisp.)
From your description it sounds pretty much like the way metacompiling
Forth systems do it. It does get a bit subtle on occasion :-)
Joe Marshall
"Kent M Pitman" <pit...@world.std.com> wrote in message
news:sfwelio...@shell01.TheWorld.com...
>
> I think, though I've never attempted it myself, that it becomes
> remarkably more difficult to start everything, even if you have all
> the sources, if you don't have a running version somewhere.
>
There is a scarier problem. You may not be able to start everything
even if you *do* have a running version somewhere.
Under certain circumstances, you have to store a copy of the processor
state in the image itself (on stack-group switch and when pushing catch
frames). If there was a pending callback from the microcode to
Lisp, then the Lisp image will contain `pointers' that make sense
only to the revision of the microcode that was in effect. So it is
*conceivable* that you could get yourself into a state where you
could not advance the microcode because the image depended on the
old microcode, but you couldn't back out the microcode to an earlier
version because there were no extant images for it!
When we discovered this at LMI, we were rather horrified that this
vulnerability had been lurking in the system for years. Fortunately
for us the amount of microcode necessary for a `cold load' was small
and was quite stable.
Thomas Bushnell, BSG
> So it is *conceivable* that you could get yourself into a state
> where you could not advance the microcode because the image depended
> on the old microcode, but you couldn't back out the microcode to an
> earlier version because there were no extant images for it!
I'm confused; why would there be no extant images for the earlier
microcode? Is there some reason that ordinary backups would not be
sufficient? I mean, why not always keep a series of old images
around?
Joe Marshall
"Thomas Bushnell, BSG" <tb+u...@becket.net> wrote in message
news:87ofhrk...@becket.becket.net...
Disk space was quite a bit more expensive back then. A couple of
bootable bands would take up the entire disk. So it was rare
that anyone kept around old bands. Certainly backups were made of
`releases' and such, but the day-to-day builds were not usually
kept forever. We wouldn't have lost the ability to develop code,
but it was certainly possible to lose several months worth of
work.
Scott McKay
"Michael Parker" <des...@pdq.net> wrote in message
news:68CADFC306BE6A17.9783CE3C...@lp.airnews.net...
".
>
> Heres a question for the ex-Symbolics people: How were the Ivory
> and 36xx images built? From sources? Once an image had a
> sufficiently-working image, new images (esp distribution images)
> regularly built from sources?
We built "world loads" once every month or two. Doing this
involved doing minimal system builds in a sort of "sandbox"
and then running a program called the "cold loader" that composed
the binaries into a rudimentary world image. You would then
start this minimal world and compile the rest of the system into
it. Any errors during this had to be debugged using the FEP's
debugger. A bunch of us got pretty good at this, although I would
be amazed if I could still do it.
Arun Welch
wrote:
>I think that had the communities been swapped, with the east coasters
>liking Interlisp and being threatened by a west coast Maclisp, east
>coasters would have still won because they played better politics.
>But that's just a guess. So in that sense it probably was a turf war.
>
The demise of Interlisp can also be traced to Xerox's unwillingness to
open up the standard and source to other people. They had the rather
misconcieved idea that their Lisp was better, and that they could
dominate the market in spite of an ARPA standard.
To be honest, I think this belief was held more by the Xerox
management than by the Interlisp-D programmers, most of whom were more
interested in creating interesting systems than being language
fanatics. Most of the advances in Interlisp-D were driven by the
desire of researchers to advance their own research system, with a
side effect of producing software to achieve those ideas. Examples of
this include LOOPS (which was written as a tool for AI research),
NoteCards (hypertext research), most of the pretty bits of the user
interface, etc. The focus wasn't so much on efficient language
implementation as it was on interesting tools built on top of the
language. The bulk of the changes between the various releases was not
in language changes or improvements but in new tools. I'd guess that
most releases were something like 30% bugfixes and 70% new tools. I
can't remember any instances where user code produced using the
original Interlisp-10 documentation didn't run under the last release
of Interlisp-D. There were very few people in the Interlisp world who
were obssesed with making the system faster or more efficient, but
there were lots of people obssesed with making the user interface
better. This is why things like the reference-counting GC lived on as
long as they did, it was always good enough. But there were three
different structure editors, a typesetter-quality text editor, things
like that.
>
>DWIM horror stories were many, more often traded among Interlisp refugees
>than Interlisp users, but that would be natural.
I think most Interlisp users knew enough about DWIM that it didn't
bite them as much. Once you expected DWIM you were less fanatical
about spell-checking, for instance. The default setting on DWIM was to
be conservative and ask you to accept changes anyway, so you could
always go back and correct the source if it was wrong. Fear and
loathing of DWIM always seemed to be from outside the Interlisp crowd.
DWIM also allowed for the "conversational Lisp" mode of so you could
write incredibly complex iteration structures that were readable:
(do SOMETHING while STATE unless STATE until STATE by INCREMENT)
Interlisp people found Common Lisp's iteration structures horribly
archaic.
>All in all, when it came down to it, and the turf war began, my own
>subjective impression was that Interlisp was not a good candidate for
>an "implementation language". It was trying too much to suit the end-user
>and not enough to suit the low-level user.
As an Interlisp fanatic, I'd agree with that. Interlisp's user
interface on top of a modern CL implementation would be a dream come
true.
...arun
Julian Stecklina
[...]
> >All in all, when it came down to it, and the turf war began, my own
> >subjective impression was that Interlisp was not a good candidate for
> >an "implementation language". It was trying too much to suit the end-user
> >and not enough to suit the low-level user.
>
> As an Interlisp fanatic, I'd agree with that. Interlisp's user
> interface on top of a modern CL implementation would be a dream come
> true.
You mean e.g. that "structure editor"? If yes, could you point out
where the difference is comparing it with plain text editing. And
where are its strengths and weaknesses?
I hope I got this not totally wrong. :)
Regards,
Julian
--
Meine Hompage: http://julian.re6.de
Um meinen oeffentlichen Schluessel zu erhalten:
To get my public key:
http://math-www.uni-paderborn.de/pgp/
Robert Bechtel
Arun Welch wrote:
>
> The demise of Interlisp can also be traced to Xerox's unwillingness to
> open up the standard and source to other people. They had the rather
> misconcieved idea that their Lisp was better, and that they could
> dominate the market in spite of an ARPA standard.
Hmmm. Not having been at Xerox or in the trenches of the
standardization work that became CL, I can't say for sure that there was
unwillingness to open up the standard, but it is clear that Xerox (and
BBN, which was another major Interlisp hotbed) was relaxed enough about
things to let ISI implement Interlisp-VAX on DARPA's nickel. The
complexity and cost of that effort was mooted to be a key event in
motivating the CL effort -- the Navy (where I was working at the time)
was getting ready to fund Interlisp development efforts for other
machines so as to have their preferred platform more widely available
upon the demise of DEC's Jupiter. BBN implemented most, if not all, of
Interlisp for their proprietary Jericho workstation. (I remember at
least one version was lacking a garbage collector.)
Of course, propagating Interlisp everywhere wouldn't address how to
provide constructs and tools that the Maclisp community would find
acceptable. As I recall, at least part of the response was "use
TRANSOR" (the pattern-match source code transformation tool).
> The focus wasn't so much on efficient language
> implementation as it was on interesting tools built on top of the
> language. The bulk of the changes between the various releases was not
> in language changes or improvements but in new tools. I'd guess that
> most releases were something like 30% bugfixes and 70% new tools. I
> can't remember any instances where user code produced using the
> original Interlisp-10 documentation didn't run under the last release
> of Interlisp-D. There were very few people in the Interlisp world who
> were obssesed with making the system faster or more efficient, but
> there were lots of people obssesed with making the user interface
> better. This is why things like the reference-counting GC lived on as
> long as they did, it was always good enough. But there were three
> different structure editors, a typesetter-quality text editor, things
> like that.
I moved out of the Interlisp environment before I had a chance to work
with Interlisp-D. Certainly Interlisp-10 was acceptable in
performance. Part of that may have been due to substantial portions
being written directly in Lisp assembly -- it could be a lot like just
reading MACRO-10.
> Interlisp's user
> interface on top of a modern CL implementation would be a dream come
> true.
Agreed. And I'm remembering the text-terminal oriented version!
bob bechtel
Paolo Amoroso
wrote:
[...about the Interlisp environment...]
> long as they did, it was always good enough. But there were three
> different structure editors, a typesetter-quality text editor, things
What was the name of that editor? What do you mean by typesetter-quality?
Was it a WYSIWYG tool or a formatting language (or something different, of
course)?
T. Kurt Bond
> On Thu, 21 Mar 2002 20:35:21 GMT, we...@removeme-anzus.com (Arun Welch)
> wrote:
>
> [...about the Interlisp environment...]
> > long as they did, it was always good enough. But there were three
> > different structure editors, a typesetter-quality text editor, things
>
> What was the name of that editor? What do you mean by typesetter-quality?
> Was it a WYSIWYG tool or a formatting language (or something different, of
> course)?
Is that typesetter-quality text editor available in Medley, which,
according to the web site, includes Interlisp?
(Is it the Tedit mentioned in the Medley description?)
http://top2bottom.net/medley.html
Anybody here used Medley?
--
T. Kurt Bond, t...@tkb.mpl.com