* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 0:51 ` Dan Cross
@ 2018-02-16 1:06 ` Clem cole
2018-02-16 3:10 ` Toby Thain
2018-02-16 1:18 ` Larry McVoy
` (3 subsequent siblings)
4 siblings, 1 reply; 41+ messages in thread
From: Clem cole @ 2018-02-16 1:06 UTC (permalink / raw)
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 3267 bytes --]
The whole reason VM was developed at UCB was because Ernie (the original) Vax was funded to develop the ability to port MacLisp and more importantly Macsyma from ITS.
V32’s static address space was not going to work.
Btw the program we used to debug the VM system on the original mc500 was macsyma’s competition, sms (which would later become wolfram).
In both cases the idea was to ensure the memory system was being exercised.
Clem
Sent from my PDP-7 Running UNIX V0 expect things to be almost but not quite.
> On Feb 15, 2018, at 7:51 PM, Dan Cross <crossd at gmail.com> wrote:
>
>> On Thu, Feb 15, 2018 at 7:01 PM, Dave Horsfall <dave at horsfall.org> wrote:
>> On Wed, 14 Feb 2018, Toby Thain wrote:
>>>> ALGOL, one of the most influential languages ever, with just about every programming language in use today tracing its roots to it.
>>>
>>> Worth mentioning one significant exception: the Lisp family.
>>
>> I know about LISP (and even used it); it's on my history list.
>>
>> Actually, I can't think of any language that derived exclusively from LISP (other than Scheme etc)... Oh, and EMACS :-)
>
> There were (and are!) a whole bunch of dialects of Lisp: Common Lisp and Scheme might be the best known, with Clojure a modern entrant. Arc is sort of a thing. Most folks know about emacs Lisp. All of these derive from the original Lisp.
>
> But there were a whole slew of historical dialects descended from Lisp 1.5: MacLisp, InterLisp, FranzLisp, Lisp Machine Lisp, the original variant implemented by Symbolics before they adopted Common Lisp, Portable Standard Lisp...and any number of others that were implemented as extension languages: AutoLisp from AutoCAD, the aforementioned Emacs Lisp, the pseudo-Lisp from Gosling's Emacs, and plenty of others. And how about implementations? VAX Lisp, LispWorks, Allegro, etc. I think the thing is that "Lisp" isn't a single language, but rather a family of languages that all share common features (code is data, macros, etc, etc, etc) with lots of variation between them (I understand that there was serious argument about whether integer literals should be written in octal in Common Lisp, as they were in MacLisp. Somehow common sense prevailed).
>
> So, how's this relevant to Unix? Well, I'd like to know more about the historical interplay between the Unix and Lisp communities. What about the Lisp done at Berkeley on the VAX (Franz Lisp).
>
> One of the things that strikes me about Lisp and Unix is the conceptual similarity between image based languages (like Lisp) with a REPL and the Unix "process as virtual machine" model with a shell and set of utilities. An image is a sort of virtual machine and a REPL is a sort of shell; callable functions in the REPL are sort of like discrete programs in the $PATH. To a first order approximation, at any rate.
>
> So anyway...some of you who were there, was there cross-pollination? Was Franz Lisp a thing Unix people at Berkeley played with, or was it mostly Lisp people who just happened to be using Unix because VAXen were expensive?
>
> - Dan C.
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180215/00914085/attachment.html>
^ permalink raw reply [flat|nested] 41+ messages in thread* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 1:06 ` Clem cole
@ 2018-02-16 3:10 ` Toby Thain
2018-02-16 13:36 ` Clem Cole
0 siblings, 1 reply; 41+ messages in thread
From: Toby Thain @ 2018-02-16 3:10 UTC (permalink / raw)
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1448 bytes --]
On 2018-02-15 8:06 PM, Clem cole wrote:
> The whole reason VM was developed at UCB was because Ernie (the
> original) Vax was funded to develop the ability to port MacLisp and more
> importantly Macsyma from ITS.
> V32’s static address space was not going to work.
>
>
> Btw the program we used to debug the VM system on the original mc500 was
> macsyma’s competition, sms (which would later become wolfram).
>
You probably meant "SMP", built by Wolfram and others at Caltech:
http://www.stephenwolfram.com/publications/smp-symbolic-manipulation-program/
It sounds like Mathematica probably did not _directly_ derive from SMP
due to a court ruling.
"A dispute with the administration over the intellectual property
rights regarding SMP—patents, copyright, and faculty involvement in
commercial ventures—eventually caused him to resign from Caltech.
SMP was further developed and marketed commercially by Inference Corp.
of Los Angeles during 1983–1988."
Curiously, the above text has been copied and pasted verbatim all
over the web and it's not clear where it originated. "SMP was
essentially Version Zero of the more ambitious Mathematica system" is
also all over the web including Wikipedia.
> In both cases the idea was to ensure the memory system was being exercised.
Nowadays we'd just run gcc :)
--Toby
>
> Clem
>
>
> Sent from my PDP-7 Running UNIX V0 expect things to be almost but not
> quite.
> ...
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 3:10 ` Toby Thain
@ 2018-02-16 13:36 ` Clem Cole
0 siblings, 0 replies; 41+ messages in thread
From: Clem Cole @ 2018-02-16 13:36 UTC (permalink / raw)
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1179 bytes --]
On Thu, Feb 15, 2018 at 10:10 PM, Toby Thain <toby at telegraphics.com.au>
wrote:
> On 2018-02-15 8:06 PM, Clem cole wrote:
> > The whole reason VM was developed at UCB was because Ernie (the
> > original) Vax was funded to develop the ability to port MacLisp and more
> > importantly Macsyma from ITS.
> > V32’s static address space was not going to work.
> >
> >
> > Btw the program we used to debug the VM system on the original mc500 was
> > macsyma’s competition, sms (which would later become wolfram).
> >
>
> You probably meant "SMP",
yes thank you... typo/dyslexia (I did not notice the error until you
pointed it out).
> > In both cases the idea was to ensure the memory system was being
> exercised.
>
> Nowadays we'd just run gcc :)
>
indeed
- as for wolfram vs SMP sorry not trying to dig into old wounds, just
trying to point out how ironic that two early UNIX VM systems used the same
style of application (symbolic math) as a way to find corner cases in the
VM code.
ᐧ
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180216/3de29b8f/attachment.html>
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 0:51 ` Dan Cross
2018-02-16 1:06 ` Clem cole
@ 2018-02-16 1:18 ` Larry McVoy
2018-02-16 1:55 ` George Michaelson
2018-02-16 1:56 ` Lawrence Stewart
2018-02-16 1:25 ` Ian Zimmerman
` (2 subsequent siblings)
4 siblings, 2 replies; 41+ messages in thread
From: Larry McVoy @ 2018-02-16 1:18 UTC (permalink / raw)
On Thu, Feb 15, 2018 at 07:51:14PM -0500, Dan Cross wrote:
> >> Worth mentioning one significant exception: the Lisp family.
>
> So anyway...some of you who were there, was there cross-pollination? Was
> Franz Lisp a thing Unix people at Berkeley played with, or was it mostly
> Lisp people who just happened to be using Unix because VAXen were expensive?
This is just my opinion so there is a grain of salt. Or a salt shaker.
I think there are two (at least) sorts of programmers, the systems people
and the lisp people. Sometimes you get both kinds in the same person
but that tends to be rare (and awesome, I've employeed several of those,
they were magic).
I'm a systems guy. I've played with lisp, even wrote a tiny lisp (haven't
we all?), tried to get to like it and utterly failed. All sorts of smart
people I knew in my career loved lisp, sneered at any other language,
tended to think in ASTs, etc, etc. I definitely felt inferior and tried
to like lisp but just never got what was so neat about it.
For good reason, I think. Nobody has written a serious operating system,
or a serious $BIG_PROJECT in Lisp. Not one that has been commercially
successful, so far as I know. I know there were attempts but all those
attempts failed. Why? Performance I think. C performs far better even
though it is, in the eyes of lisp people, far more awkward to do things.
I can't tell you the number of times I've heard "If we were using Lisp
we'd be done by now". 100's, 1000's. What I have never heard is "I
recoded this pile of C in lisp and it's 10x faster".
I think the thing is that lisp programmers were optimizing for speed
of coding and C programmers were optimizing for speed of execution.
So I suspect that Franz Lisp was mostly lisp people who happened to be
using Unix. But I wasn't at Berkeley so what do I know?
--lm
^ permalink raw reply [flat|nested] 41+ messages in thread* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 1:18 ` Larry McVoy
@ 2018-02-16 1:55 ` George Michaelson
2018-02-16 1:56 ` Lawrence Stewart
1 sibling, 0 replies; 41+ messages in thread
From: George Michaelson @ 2018-02-16 1:55 UTC (permalink / raw)
syntactically, semantically, a lot of the strongly typed functional
programming outcomes have roots into ideas explored in the LISP
family.
the quants are using it heavily. The declarative, checked-at-compile
qualities reduce errors, the statements have some authority and the
formulaic expression of things as compositions over functions works
for their brains. the typing wasn't strong in LISP but the FP
expressive quality and lazy eval was. Sure, it was in Algol family
languages too, but I think it got sort-of left out when C hit the
road.
I struggle with FP. I have major envy of minds which can think like
that. I wish I had that kind of mind. I sit with someone who does. He
front loads his problems with type statements and produces terse but
very efficient code. Its a marketable skill in the right place.
I think you're right its not very system-y but the lines are blurring.
Go introduces the need for GC. Once you need GC, you enter a door
where all the things we said we didn't do pop back into view,
including lazy evaluation which is in the foundation of FP, and ..
LISP. So for the set of problems which people say "coded in GO" you
can think "hmm: maybe GHC with the right frobs would work there"
Rust apparently doesn't do GC. So maybe its more in the 'not in my
world' camp. Syntactically Go is of course nothing LIKE an FP as I
understand it, but then I can't program functionally, so I don't
entirely know what I know any more here.
On Fri, Feb 16, 2018 at 11:18 AM, Larry McVoy <lm at mcvoy.com> wrote:
> On Thu, Feb 15, 2018 at 07:51:14PM -0500, Dan Cross wrote:
>> >> Worth mentioning one significant exception: the Lisp family.
>>
>> So anyway...some of you who were there, was there cross-pollination? Was
>> Franz Lisp a thing Unix people at Berkeley played with, or was it mostly
>> Lisp people who just happened to be using Unix because VAXen were expensive?
>
> This is just my opinion so there is a grain of salt. Or a salt shaker.
>
> I think there are two (at least) sorts of programmers, the systems people
> and the lisp people. Sometimes you get both kinds in the same person
> but that tends to be rare (and awesome, I've employeed several of those,
> they were magic).
>
> I'm a systems guy. I've played with lisp, even wrote a tiny lisp (haven't
> we all?), tried to get to like it and utterly failed. All sorts of smart
> people I knew in my career loved lisp, sneered at any other language,
> tended to think in ASTs, etc, etc. I definitely felt inferior and tried
> to like lisp but just never got what was so neat about it.
>
> For good reason, I think. Nobody has written a serious operating system,
> or a serious $BIG_PROJECT in Lisp. Not one that has been commercially
> successful, so far as I know. I know there were attempts but all those
> attempts failed. Why? Performance I think. C performs far better even
> though it is, in the eyes of lisp people, far more awkward to do things.
>
> I can't tell you the number of times I've heard "If we were using Lisp
> we'd be done by now". 100's, 1000's. What I have never heard is "I
> recoded this pile of C in lisp and it's 10x faster".
>
> I think the thing is that lisp programmers were optimizing for speed
> of coding and C programmers were optimizing for speed of execution.
>
> So I suspect that Franz Lisp was mostly lisp people who happened to be
> using Unix. But I wasn't at Berkeley so what do I know?
>
> --lm
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 1:18 ` Larry McVoy
2018-02-16 1:55 ` George Michaelson
@ 2018-02-16 1:56 ` Lawrence Stewart
2018-02-16 2:38 ` Dan Cross
1 sibling, 1 reply; 41+ messages in thread
From: Lawrence Stewart @ 2018-02-16 1:56 UTC (permalink / raw)
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 3429 bytes --]
ITA’s airline flight booking system, that was used by Orbitz and others was pretty much entirely written in Common LISP, and it was certainly both large and commercially successful. Orbitz was bought by Google for $700 million. I don’t know how much of the LISP survived sustained attention by Google.
Paul Graham’s company Viaweb was all LISP. It was bought by Yahoo! for $50 million and became Yahoo! Store.
I think of myself as a systems person and C is still my primary language, but I wrote the routing software for the wacky Kautz graph in the Sicortex machines in Common LISP. It was substantially easier! After it worked I recoded in C for production. It isn’t that Common LISP isn’t perfectly fast enough, we just didn’t want garbage collection at that level of the software.
My favorite LISP story is the time I was hired to evaluate a proposed Cryptosystem. I was handed 40 pages of C code. I reimplemented it in 15 (short) lines of Common LISP. It wasn’t hard to crack after it fit on one page!
I came to LISP 30 years late because I was in 6-1 at MIT rather than 6-3 so I didn’t learn LISP or Scheme. I am not one of the awesome folks of which you speak, but I’ve met them and know what you mean. One MIT physicist I met thought MILC was too complicated so his quantum chromodynamics code was in LISP. He wrote his own LISP->C translator to get it to generate exactly the code he wanted.
-L
> On 2018, Feb 15, at 8:18 PM, Larry McVoy <lm at mcvoy.com> wrote:
>
> On Thu, Feb 15, 2018 at 07:51:14PM -0500, Dan Cross wrote:
>>>> Worth mentioning one significant exception: the Lisp family.
>>
>> So anyway...some of you who were there, was there cross-pollination? Was
>> Franz Lisp a thing Unix people at Berkeley played with, or was it mostly
>> Lisp people who just happened to be using Unix because VAXen were expensive?
>
> This is just my opinion so there is a grain of salt. Or a salt shaker.
>
> I think there are two (at least) sorts of programmers, the systems people
> and the lisp people. Sometimes you get both kinds in the same person
> but that tends to be rare (and awesome, I've employeed several of those,
> they were magic).
>
> I'm a systems guy. I've played with lisp, even wrote a tiny lisp (haven't
> we all?), tried to get to like it and utterly failed. All sorts of smart
> people I knew in my career loved lisp, sneered at any other language,
> tended to think in ASTs, etc, etc. I definitely felt inferior and tried
> to like lisp but just never got what was so neat about it.
>
> For good reason, I think. Nobody has written a serious operating system,
> or a serious $BIG_PROJECT in Lisp. Not one that has been commercially
> successful, so far as I know. I know there were attempts but all those
> attempts failed. Why? Performance I think. C performs far better even
> though it is, in the eyes of lisp people, far more awkward to do things.
>
> I can't tell you the number of times I've heard "If we were using Lisp
> we'd be done by now". 100's, 1000's. What I have never heard is "I
> recoded this pile of C in lisp and it's 10x faster".
>
> I think the thing is that lisp programmers were optimizing for speed
> of coding and C programmers were optimizing for speed of execution.
>
> So I suspect that Franz Lisp was mostly lisp people who happened to be
> using Unix. But I wasn't at Berkeley so what do I know?
>
> --lm
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 1:56 ` Lawrence Stewart
@ 2018-02-16 2:38 ` Dan Cross
2018-02-16 2:41 ` Larry McVoy
0 siblings, 1 reply; 41+ messages in thread
From: Dan Cross @ 2018-02-16 2:38 UTC (permalink / raw)
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 4287 bytes --]
On Thu, Feb 15, 2018 at 8:56 PM, Lawrence Stewart <stewart at serissa.com>
wrote:
> ITA’s airline flight booking system, that was used by Orbitz and others
> was pretty much entirely written in Common LISP, and it was certainly both
> large and commercially successful. Orbitz was bought by Google for $700
> million. I don’t know how much of the LISP survived sustained attention by
> Google.
>
Google bought ITA, not Orbitz. Most of the logic in QPX is still in Common
Lisp, but it's not what you'd call "idiomatic" CL code. If one reads a
bunch of Paul Graham and Peter Norvig books and then gets onto QPX with the
expectation of that sort of elegance, you end up pretty unhappy pretty
quick. They do a lot of things very differently to squeeze as much
performance as they can out of what has, historically speaking, been a
fairly mediocre compiler.
- Dan C.
Paul Graham’s company Viaweb was all LISP. It was bought by Yahoo! for $50
> million and became Yahoo! Store.
>
> I think of myself as a systems person and C is still my primary language,
> but I wrote the routing software for the wacky Kautz graph in the Sicortex
> machines in Common LISP. It was substantially easier! After it worked I
> recoded in C for production. It isn’t that Common LISP isn’t perfectly
> fast enough, we just didn’t want garbage collection at that level of the
> software.
>
> My favorite LISP story is the time I was hired to evaluate a proposed
> Cryptosystem. I was handed 40 pages of C code. I reimplemented it in 15
> (short) lines of Common LISP. It wasn’t hard to crack after it fit on one
> page!
>
> I came to LISP 30 years late because I was in 6-1 at MIT rather than 6-3
> so I didn’t learn LISP or Scheme. I am not one of the awesome folks of
> which you speak, but I’ve met them and know what you mean. One MIT
> physicist I met thought MILC was too complicated so his quantum
> chromodynamics code was in LISP. He wrote his own LISP->C translator to
> get it to generate exactly the code he wanted.
>
> -L
>
> > On 2018, Feb 15, at 8:18 PM, Larry McVoy <lm at mcvoy.com> wrote:
> >
> > On Thu, Feb 15, 2018 at 07:51:14PM -0500, Dan Cross wrote:
> >>>> Worth mentioning one significant exception: the Lisp family.
> >>
> >> So anyway...some of you who were there, was there cross-pollination? Was
> >> Franz Lisp a thing Unix people at Berkeley played with, or was it mostly
> >> Lisp people who just happened to be using Unix because VAXen were
> expensive?
> >
> > This is just my opinion so there is a grain of salt. Or a salt shaker.
> >
> > I think there are two (at least) sorts of programmers, the systems people
> > and the lisp people. Sometimes you get both kinds in the same person
> > but that tends to be rare (and awesome, I've employeed several of those,
> > they were magic).
> >
> > I'm a systems guy. I've played with lisp, even wrote a tiny lisp
> (haven't
> > we all?), tried to get to like it and utterly failed. All sorts of smart
> > people I knew in my career loved lisp, sneered at any other language,
> > tended to think in ASTs, etc, etc. I definitely felt inferior and tried
> > to like lisp but just never got what was so neat about it.
> >
> > For good reason, I think. Nobody has written a serious operating system,
> > or a serious $BIG_PROJECT in Lisp. Not one that has been commercially
> > successful, so far as I know. I know there were attempts but all those
> > attempts failed. Why? Performance I think. C performs far better even
> > though it is, in the eyes of lisp people, far more awkward to do things.
> >
> > I can't tell you the number of times I've heard "If we were using Lisp
> > we'd be done by now". 100's, 1000's. What I have never heard is "I
> > recoded this pile of C in lisp and it's 10x faster".
> >
> > I think the thing is that lisp programmers were optimizing for speed
> > of coding and C programmers were optimizing for speed of execution.
> >
> > So I suspect that Franz Lisp was mostly lisp people who happened to be
> > using Unix. But I wasn't at Berkeley so what do I know?
> >
> > --lm
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180215/987cb5b1/attachment-0001.html>
^ permalink raw reply [flat|nested] 41+ messages in thread* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 2:38 ` Dan Cross
@ 2018-02-16 2:41 ` Larry McVoy
2018-02-16 2:51 ` Dan Cross
` (2 more replies)
0 siblings, 3 replies; 41+ messages in thread
From: Larry McVoy @ 2018-02-16 2:41 UTC (permalink / raw)
On Thu, Feb 15, 2018 at 09:38:02PM -0500, Dan Cross wrote:
> On Thu, Feb 15, 2018 at 8:56 PM, Lawrence Stewart <stewart at serissa.com>
> wrote:
>
> > ITA???s airline flight booking system, that was used by Orbitz and others
> > was pretty much entirely written in Common LISP, and it was certainly both
> > large and commercially successful. Orbitz was bought by Google for $700
> > million. I don???t know how much of the LISP survived sustained attention by
> > Google.
> >
>
> Google bought ITA, not Orbitz. Most of the logic in QPX is still in Common
> Lisp, but it's not what you'd call "idiomatic" CL code. If one reads a
> bunch of Paul Graham and Peter Norvig books and then gets onto QPX with the
> expectation of that sort of elegance, you end up pretty unhappy pretty
> quick. They do a lot of things very differently to squeeze as much
> performance as they can out of what has, historically speaking, been a
> fairly mediocre compiler.
Which is sort of my point. I don't know all the details but lisp and
performance is not a thing.
^ permalink raw reply [flat|nested] 41+ messages in thread* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 2:41 ` Larry McVoy
@ 2018-02-16 2:51 ` Dan Cross
2018-02-16 2:56 ` George Michaelson
2018-02-16 2:51 ` [TUHS] Clueless programmers - was " Toby Thain
2018-02-16 10:26 ` [TUHS] " Tim Bradshaw
2 siblings, 1 reply; 41+ messages in thread
From: Dan Cross @ 2018-02-16 2:51 UTC (permalink / raw)
On Thu, Feb 15, 2018 at 9:41 PM, Larry McVoy <lm at mcvoy.com> wrote:
> On Thu, Feb 15, 2018 at 09:38:02PM -0500, Dan Cross wrote:
> > On Thu, Feb 15, 2018 at 8:56 PM, Lawrence Stewart <stewart at serissa.com>
> > wrote:
> >
> > > ITA???s airline flight booking system, that was used by Orbitz and
> others
> > > was pretty much entirely written in Common LISP, and it was certainly
> both
> > > large and commercially successful. Orbitz was bought by Google for
> $700
> > > million. I don???t know how much of the LISP survived sustained
> attention by
> > > Google.
> > >
> >
> > Google bought ITA, not Orbitz. Most of the logic in QPX is still in
> Common
> > Lisp, but it's not what you'd call "idiomatic" CL code. If one reads a
> > bunch of Paul Graham and Peter Norvig books and then gets onto QPX with
> the
> > expectation of that sort of elegance, you end up pretty unhappy pretty
> > quick. They do a lot of things very differently to squeeze as much
> > performance as they can out of what has, historically speaking, been a
> > fairly mediocre compiler.
>
> Which is sort of my point. I don't know all the details but lisp and
> performance is not a thing.
>
That's a tad unfair.
It *can* be fast, it's just that the "Lisp" you're writing in that case
probably isn't the Lisp you wanted to be writing when you read about how
cool and elegant Lisp was: you're avoiding some constructs to prevent
boxing and unboxing arguments (e.g., put things inside of labels or flet's
instead of defun's or passing arbitrary lambdas around) or generating
useless garbage (don't cons up a list; setq the cdr) and favoring others
that are less elegant to get better object code out of the compiler.
If you can stomach the death-defying twists and turns from all the hoops
you have to jump through for all of that nonsense, then you can make it
fast -- but at the loss of the expressive advantage. But that trade-off
begs the question: why not write in a language that lets you write fast
(executing) code without jumping through hoops? That's a fair thing to ask
and most of the answers in Lisp's favor aren't particularly great.
- Dan C.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180215/7b1768ab/attachment.html>
^ permalink raw reply [flat|nested] 41+ messages in thread* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 2:51 ` Dan Cross
@ 2018-02-16 2:56 ` George Michaelson
0 siblings, 0 replies; 41+ messages in thread
From: George Michaelson @ 2018-02-16 2:56 UTC (permalink / raw)
I tried to hire an engineer in the 1990s. She came to the interview
with her (probably over-controlling) father who was the founder of the
two person consulting company she'd been working for. They coded a
huge traffic-light management system entirely in LISP. Major stuff.
From memory, we offered but I think daddy didn't like the way we
behaved, she didn't accept. I think she was an incredibly good
programmer. Really smart, competent. It was my first clue that out in
the "real world" (I was working in a university) you could code in
LISP and sell solutions that ran things like traffic lights: People
die if you get that wrong. Awesome. (it's equally likely we didn't
offer, being stupid)
On Fri, Feb 16, 2018 at 12:51 PM, Dan Cross <crossd at gmail.com> wrote:
> On Thu, Feb 15, 2018 at 9:41 PM, Larry McVoy <lm at mcvoy.com> wrote:
>>
>> On Thu, Feb 15, 2018 at 09:38:02PM -0500, Dan Cross wrote:
>> > On Thu, Feb 15, 2018 at 8:56 PM, Lawrence Stewart <stewart at serissa.com>
>> > wrote:
>> >
>> > > ITA???s airline flight booking system, that was used by Orbitz and
>> > > others
>> > > was pretty much entirely written in Common LISP, and it was certainly
>> > > both
>> > > large and commercially successful. Orbitz was bought by Google for
>> > > $700
>> > > million. I don???t know how much of the LISP survived sustained
>> > > attention by
>> > > Google.
>> > >
>> >
>> > Google bought ITA, not Orbitz. Most of the logic in QPX is still in
>> > Common
>> > Lisp, but it's not what you'd call "idiomatic" CL code. If one reads a
>> > bunch of Paul Graham and Peter Norvig books and then gets onto QPX with
>> > the
>> > expectation of that sort of elegance, you end up pretty unhappy pretty
>> > quick. They do a lot of things very differently to squeeze as much
>> > performance as they can out of what has, historically speaking, been a
>> > fairly mediocre compiler.
>>
>> Which is sort of my point. I don't know all the details but lisp and
>> performance is not a thing.
>
>
> That's a tad unfair.
>
> It *can* be fast, it's just that the "Lisp" you're writing in that case
> probably isn't the Lisp you wanted to be writing when you read about how
> cool and elegant Lisp was: you're avoiding some constructs to prevent boxing
> and unboxing arguments (e.g., put things inside of labels or flet's instead
> of defun's or passing arbitrary lambdas around) or generating useless
> garbage (don't cons up a list; setq the cdr) and favoring others that are
> less elegant to get better object code out of the compiler.
>
> If you can stomach the death-defying twists and turns from all the hoops you
> have to jump through for all of that nonsense, then you can make it fast --
> but at the loss of the expressive advantage. But that trade-off begs the
> question: why not write in a language that lets you write fast (executing)
> code without jumping through hoops? That's a fair thing to ask and most of
> the answers in Lisp's favor aren't particularly great.
>
> - Dan C.
>
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Clueless programmers - was Re: Happy birthday, Niklaus Wirth!
2018-02-16 2:41 ` Larry McVoy
2018-02-16 2:51 ` Dan Cross
@ 2018-02-16 2:51 ` Toby Thain
2018-02-16 2:55 ` Larry McVoy
2018-02-16 10:26 ` [TUHS] " Tim Bradshaw
2 siblings, 1 reply; 41+ messages in thread
From: Toby Thain @ 2018-02-16 2:51 UTC (permalink / raw)
On 2018-02-15 9:41 PM, Larry McVoy wrote:
> On Thu, Feb 15, 2018 at 09:38:02PM -0500, Dan Cross wrote:
>> On Thu, Feb 15, 2018 at 8:56 PM, Lawrence Stewart <stewart at serissa.com>
>> wrote:
>>
>>> ITA???s airline flight booking system, that was used by Orbitz and others
>>> was pretty much entirely written in Common LISP, and it was certainly both
>>> large and commercially successful. Orbitz was bought by Google for $700
>>> million. I don???t know how much of the LISP survived sustained attention by
>>> Google.
>>>
>>
>> Google bought ITA, not Orbitz. Most of the logic in QPX is still in Common
>> Lisp, but it's not what you'd call "idiomatic" CL code. If one reads a
>> bunch of Paul Graham and Peter Norvig books and then gets onto QPX with the
>> expectation of that sort of elegance, you end up pretty unhappy pretty
>> quick. They do a lot of things very differently to squeeze as much
>> performance as they can out of what has, historically speaking, been a
>> fairly mediocre compiler.
>
> Which is sort of my point. I don't know all the details but lisp and
> performance is not a thing.
>
You can stop at "I don't know all the details". That meme about
performance is not actually true, but it's popular among people who
don't know Lisp technically or use it professionally.
There are a number of mature Common Lisp compilers and some of them
boast outstanding performance.
--T
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Clueless programmers - was Re: Happy birthday, Niklaus Wirth!
2018-02-16 2:51 ` [TUHS] Clueless programmers - was " Toby Thain
@ 2018-02-16 2:55 ` Larry McVoy
0 siblings, 0 replies; 41+ messages in thread
From: Larry McVoy @ 2018-02-16 2:55 UTC (permalink / raw)
On Thu, Feb 15, 2018 at 09:51:21PM -0500, Toby Thain wrote:
> On 2018-02-15 9:41 PM, Larry McVoy wrote:
> > On Thu, Feb 15, 2018 at 09:38:02PM -0500, Dan Cross wrote:
> >> On Thu, Feb 15, 2018 at 8:56 PM, Lawrence Stewart <stewart at serissa.com>
> >> wrote:
> >>
> >>> ITA???s airline flight booking system, that was used by Orbitz and others
> >>> was pretty much entirely written in Common LISP, and it was certainly both
> >>> large and commercially successful. Orbitz was bought by Google for $700
> >>> million. I don???t know how much of the LISP survived sustained attention by
> >>> Google.
> >>>
> >>
> >> Google bought ITA, not Orbitz. Most of the logic in QPX is still in Common
> >> Lisp, but it's not what you'd call "idiomatic" CL code. If one reads a
> >> bunch of Paul Graham and Peter Norvig books and then gets onto QPX with the
> >> expectation of that sort of elegance, you end up pretty unhappy pretty
> >> quick. They do a lot of things very differently to squeeze as much
> >> performance as they can out of what has, historically speaking, been a
> >> fairly mediocre compiler.
> >
> > Which is sort of my point. I don't know all the details but lisp and
> > performance is not a thing.
> >
>
> You can stop at "I don't know all the details". That meme about
> performance is not actually true, but it's popular among people who
> don't know Lisp technically or use it professionally.
>
> There are a number of mature Common Lisp compilers and some of them
> boast outstanding performance.
I'm fine with your claim but I'd like to see a pile of C code that was
rewritten in lisp and it is faster. I'm 99.9% sure that's not a thing.
Lisp is fantastic for programmers who know how to use it, which is why
so many people are lisp fanatics. But performant it is not. Feel free
to show me how I'm wrong, I love being wrong, that's where I learn.
--lm
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 2:41 ` Larry McVoy
2018-02-16 2:51 ` Dan Cross
2018-02-16 2:51 ` [TUHS] Clueless programmers - was " Toby Thain
@ 2018-02-16 10:26 ` Tim Bradshaw
2 siblings, 0 replies; 41+ messages in thread
From: Tim Bradshaw @ 2018-02-16 10:26 UTC (permalink / raw)
On 16 Feb 2018, at 02:41, Larry McVoy <lm at mcvoy.com> wrote:
>
> I don't know all the details but lisp and
> performance is not a thing.
What this actually means is three things.
(1) Once upon a time, a very long time ago, there may have been some implementations of Lisp-family languages which, because people didn't know much about writing compilers or memory management systems in the early 1960s, were significantly slow compared to hand-written assembler or FORTRAN. This problem got solved in the 1970s and 1980s as people learnt about compiling high-level languages and about how to manage memory efficiently.
(2) The most distinctive (but never the only) compound data structure in Lisp-family languages is the singly-linked list (which Lisp calls just 'lists'). Incompetent or poorly-taught programmers make use of lists without understanding their performance characteristics (particularly they treat them like arrays), and this can result in programs which have terrible performance characteristics: they're slow and they scale poorly. This is made worse because Lisp is an enormously safer language than, say, C. This means that incompetent programmers can make their programs work *at all* which, in C, would be a mass of memory errors.
(3) People use Lisp-family languages to solve hard problems, such as 'attempt to show that this metric in GR describes the same spacetime as this other metric'. Problems which don't *have* general solutions and whose heuristic solutions involve enormous amounts of computation, much of it speculative as the program searches for ways of simplifying expressions. These programs are 'slow' in the sense that it takes them many minutes to do what a human can spend three years getting a PhD doing (oh, and the program finds that the human made some mistakes).
The end result of this is that a myth grows up: 'Lisp is slow'. This might have been true once, although even that is doubtful: like cannibals, it turns out that the implementation you can find was never, really, slow, but always, just across the river, over the hills, there was another implementation, which was.
But still the myth persists: it will always persist.
--tim
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180216/be85fd2c/attachment.html>
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 0:51 ` Dan Cross
2018-02-16 1:06 ` Clem cole
2018-02-16 1:18 ` Larry McVoy
@ 2018-02-16 1:25 ` Ian Zimmerman
2018-04-24 0:59 ` Ian Zimmerman
2018-02-16 2:09 ` Bakul Shah
2018-02-16 3:17 ` Dan Stromberg
4 siblings, 1 reply; 41+ messages in thread
From: Ian Zimmerman @ 2018-02-16 1:25 UTC (permalink / raw)
On 2018-02-15 19:51, Dan Cross wrote:
> So, how's this relevant to Unix? Well, I'd like to know more about the
> historical interplay between the Unix and Lisp communities. What about
> the Lisp done at Berkeley on the VAX (Franz Lisp).
I know one of the Franz founders, I'll ask him when I have a chance.
--
Please don't Cc: me privately on mailing lists and Usenet,
if you also post the followup to the list or newsgroup.
To reply privately _only_ on Usenet and on broken lists
which rewrite From, fetch the TXT record for no-use.mooo.com.
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 1:25 ` Ian Zimmerman
@ 2018-04-24 0:59 ` Ian Zimmerman
2018-04-24 3:26 ` Dave Horsfall
2018-04-24 4:31 ` Dan Stromberg
0 siblings, 2 replies; 41+ messages in thread
From: Ian Zimmerman @ 2018-04-24 0:59 UTC (permalink / raw)
On 2018-02-15 17:25, Ian Zimmerman wrote:
> I know one of the Franz founders, I'll ask him when I have a chance.
So, the main link seems to be John Foderaro, who worked on both BSD and Franz.
According to my source, he wrote biff(1).
--
Please don't Cc: me privately on mailing lists and Usenet,
if you also post the followup to the list or newsgroup.
To reply privately _only_ on Usenet and on broken lists
which rewrite From, fetch the TXT record for no-use.mooo.com.
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-04-24 0:59 ` Ian Zimmerman
@ 2018-04-24 3:26 ` Dave Horsfall
2018-04-24 4:31 ` Dan Stromberg
1 sibling, 0 replies; 41+ messages in thread
From: Dave Horsfall @ 2018-04-24 3:26 UTC (permalink / raw)
On Mon, 23 Apr 2018, Ian Zimmerman wrote:
> According to my source, he wrote biff(1).
http://en.wikipedia.org/wiki/BIFF
(I'd post the whole thing, but Warren would probably have my nuts.)
--
Dave Horsfall DTM (VK2KFU) "Those who don't understand security will suffer."
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-04-24 0:59 ` Ian Zimmerman
2018-04-24 3:26 ` Dave Horsfall
@ 2018-04-24 4:31 ` Dan Stromberg
2018-04-24 13:42 ` Clem Cole
1 sibling, 1 reply; 41+ messages in thread
From: Dan Stromberg @ 2018-04-24 4:31 UTC (permalink / raw)
On Mon, Apr 23, 2018 at 5:59 PM, Ian Zimmerman <itz at very.loosely.org> wrote:
> On 2018-02-15 17:25, Ian Zimmerman wrote:
>
>> I know one of the Franz founders, I'll ask him when I have a chance.
>
> So, the main link seems to be John Foderaro, who worked on both BSD and Franz.
>
> According to my source, he wrote biff(1).
I had been of the impression that biff(1) was named after a dog that
barked at the slightest provocation...
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-04-24 4:31 ` Dan Stromberg
@ 2018-04-24 13:42 ` Clem Cole
0 siblings, 0 replies; 41+ messages in thread
From: Clem Cole @ 2018-04-24 13:42 UTC (permalink / raw)
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 875 bytes --]
On Tue, Apr 24, 2018 at 12:31 AM, Dan Stromberg <drsalists at gmail.com> wrote:
> On Mon, Apr 23, 2018 at 5:59 PM, Ian Zimmerman <itz at very.loosely.org>
> wrote:
> > On 2018-02-15 17:25, Ian Zimmerman wrote:
> >
> >> I know one of the Franz founders, I'll ask him when I have a chance.
> >
> > So, the main link seems to be John Foderaro, who worked on both BSD and
> Franz.
> >
> > According to my source, he wrote biff(1).
>
> I had been of the impression that biff(1) was named after a dog
Indeed - Biff was Heidi's dog.
> that
>
> barked at the slightest provocation...
>
Hmm, I'm not sure that is fair. Biff just warned Heidi that someone had
entered their office.
ᐧ
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180424/4fa835b3/attachment-0001.html>
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 0:51 ` Dan Cross
` (2 preceding siblings ...)
2018-02-16 1:25 ` Ian Zimmerman
@ 2018-02-16 2:09 ` Bakul Shah
2018-02-16 2:31 ` Toby Thain
2018-02-16 10:01 ` Tim Bradshaw
2018-02-16 3:17 ` Dan Stromberg
4 siblings, 2 replies; 41+ messages in thread
From: Bakul Shah @ 2018-02-16 2:09 UTC (permalink / raw)
On Thu, 15 Feb 2018 19:51:14 -0500 Dan Cross <crossd at gmail.com> wrote:
Dan Cross writes:
>
> On Thu, Feb 15, 2018 at 7:01 PM, Dave Horsfall <dave at horsfall.org> wrote:
>
> > On Wed, 14 Feb 2018, Toby Thain wrote:
> >
> >> ALGOL, one of the most influential languages ever, with just about every
> >>> programming language in use today tracing its roots to it.
> >>>
> >>
> >> Worth mentioning one significant exception: the Lisp family.
> >>
> >
> > I know about LISP (and even used it); it's on my history list.
> >
> > Actually, I can't think of any language that derived exclusively from LISP
> > (other than Scheme etc)... Oh, and EMACS :-)
> >
>
> There were (and are!) a whole bunch of dialects of Lisp: Common Lisp and
> Scheme might be the best known, with Clojure a modern entrant. Arc is sort
> of a thing. Most folks know about emacs Lisp. All of these derive from the
> original Lisp.
Scheme's lexical scope and block structure came from Algol.
The rest from Lisp. The joke was that the shortest and longest
language specs were of lisp dialects. The C++ spec may be
longer now.
> But there were a whole slew of historical dialects descended from Lisp 1.5:
> MacLisp, InterLisp, FranzLisp, Lisp Machine Lisp, the original variant
> implemented by Symbolics before they adopted Common Lisp, Portable Standard
> Lisp...and any number of others that were implemented as extension
> languages: AutoLisp from AutoCAD, the aforementioned Emacs Lisp, the
IIRC AutoLISP came from David Betz' Xlisp. Before it became a
superset of Scheme.
> So, how's this relevant to Unix? Well, I'd like to know more about the
> historical interplay between the Unix and Lisp communities. What about the
> Lisp done at Berkeley on the VAX (Franz Lisp).
>
> One of the things that strikes me about Lisp and Unix is the conceptual
> similarity between image based languages (like Lisp) with a REPL and the
> Unix "process as virtual machine" model with a shell and set of utilities.
> An image is a sort of virtual machine and a REPL is a sort of shell;
> callable functions in the REPL are sort of like discrete programs in the
> $PATH. To a first order approximation, at any rate.
They feel very different to me. Lisp was/is a closed world
& its FFI (foreign func. interface) always seemed like an
afterthought. In a shell you can string together programs
written in any language so long as they input/output text
lines. Its pipe symbol allowed infix notation for function
composition. As a programming language I prefer Scheme over
almost everything else but have to admit that most of my
oneliner scripts are in sh and I mostly program in Go these
days.
^ permalink raw reply [flat|nested] 41+ messages in thread* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 2:09 ` Bakul Shah
@ 2018-02-16 2:31 ` Toby Thain
2018-02-16 10:01 ` Tim Bradshaw
1 sibling, 0 replies; 41+ messages in thread
From: Toby Thain @ 2018-02-16 2:31 UTC (permalink / raw)
On 2018-02-15 9:09 PM, Bakul Shah wrote:
> Scheme's lexical scope and block structure came from Algol.
I'd have said lambda calculus
but OK
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 2:09 ` Bakul Shah
2018-02-16 2:31 ` Toby Thain
@ 2018-02-16 10:01 ` Tim Bradshaw
2018-02-16 12:10 ` Bakul Shah
1 sibling, 1 reply; 41+ messages in thread
From: Tim Bradshaw @ 2018-02-16 10:01 UTC (permalink / raw)
On 16 Feb 2018, at 02:09, Bakul Shah <bakul at bitblocks.com> wrote:
>
> Scheme's lexical scope and block structure came from Algol.
> The rest from Lisp. The joke was that the shortest and longest
> language specs were of lisp dialects. The C++ spec may be
> longer now.
I don't think this is true in any meaningful sense. There are famous plays on words which relate Scheme to Algol (The Scheme specifications are 'revised^n reports on the algorithmic language scheme', and I think lexical scope in Lisps probably originated with the Scheme people, but Scheme was the first standard language, anywhere, which took lexical scope seriously: in particular it was the first standard language with first-class continuations. (I'm saying 'standard language' because I'm sure there were research prototype implementations.).
The Common Lisp spec was very long at the time -- I think it was 1100 pages. It was mostly as long as it was because they decided not to split out what other languages would call parts of the standard library.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180216/5f246f0a/attachment.html>
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 10:01 ` Tim Bradshaw
@ 2018-02-16 12:10 ` Bakul Shah
2018-02-16 12:37 ` tfb
0 siblings, 1 reply; 41+ messages in thread
From: Bakul Shah @ 2018-02-16 12:10 UTC (permalink / raw)
On Fri, 16 Feb 2018 10:01:36 +0000 Tim Bradshaw <tfb at tfeb.org> wrote:
Tim Bradshaw writes:
>
> On 16 Feb 2018, at 02:09, Bakul Shah <bakul at bitblocks.com> wrote:
> >=20
> > Scheme's lexical scope and block structure came from Algol.
> > The rest from Lisp. The joke was that the shortest and longest
> > language specs were of lisp dialects. The C++ spec may be
> > longer now.
>
> I don't think this is true in any meaningful sense. There are famous
> plays on words which relate Scheme to Algol (The Scheme specifications
> are 'revised^n reports on the algorithmic language scheme', and I think
> Scheme was the first standard language, anywhere, which took lexical
> scope seriously: in particular it was the first standard language with
> first-class continuations. (I'm saying 'standard language' because I'm
> sure there were research prototype implementations.).
On the second page of Sussman & Steele's "Scheme, an
Interpreter for Extended Lambda Calculus", AI Memo 349, it
says "The solution, which Hewitt also uses, is to adopt an
ALGOLesque block syntax". And it goes on to describe lexical
scoping. They even call it BLOCK! Algol is mentioned a number
of times. The discovery of correspondence between actor
semantics and lambda calculus was a happy coincidence. From
wikipedia article on the history of Scheme:
25 years later, in 1998, Sussman and Steele reflected that
the minimalism of Scheme was not a conscious design goal,
but rather the unintended outcome of the design process. "We
were actually trying to build something complicated and
discovered, serendipitously, that we had accidentally
designed something that met all our goals but was much
simpler than we had intended... we realized that the lambda
calculus, a small, simple formalism, could serve as the core
of a powerful and expressive programming language."
Now you may quibble about "came from" but I think the debt is
to Algol or at least Algol related papers. Even the connection
to lambda calculus is via Algol (Peter Landin's papers on
mechanical evaluation expressions (1964) and formal
description of Algol60 (1965)).
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 12:10 ` Bakul Shah
@ 2018-02-16 12:37 ` tfb
2018-02-16 13:34 ` Bakul Shah
0 siblings, 1 reply; 41+ messages in thread
From: tfb @ 2018-02-16 12:37 UTC (permalink / raw)
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 807 bytes --]
On 16 Feb 2018, at 12:10, Bakul Shah <bakul at bitblocks.com> wrote:
>
> Now you may quibble about "came from"
I do so quibble. In particular I quibble that features *that were not present in Algol*, such as full continuations (which I think exist in the AIM-349 language via CATCH) can have 'come from Algol'. Full continuations are the place where Scheme actually takes lexical scope seriously.
But I'm not interested in getting into a fight about this.
(I think, in terms of modern Scheme, CATCH is:
(define-syntax catch
(syntax-rules ()
((_ tag form ...)
(call/cc (λ (tag) form ...)))))
although I might be wrong)
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180216/44bcec77/attachment.html>
^ permalink raw reply [flat|nested] 41+ messages in thread* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 12:37 ` tfb
@ 2018-02-16 13:34 ` Bakul Shah
2018-02-16 14:07 ` Bakul Shah
2018-02-16 20:13 ` tfb
0 siblings, 2 replies; 41+ messages in thread
From: Bakul Shah @ 2018-02-16 13:34 UTC (permalink / raw)
On Fri, 16 Feb 2018 12:37:39 +0000 tfb at tfeb.org wrote:
tfb at tfeb.org writes:
>
> On 16 Feb 2018, at 12:10, Bakul Shah <bakul at bitblocks.com> wrote:
> >=20
> > Now you may quibble about "came from"=20
>
> I do so quibble. In particular I quibble that features *that were not
> present in Algol*, such as full continuations (which I think exist in
> the AIM-349 language via CATCH) can have 'come from Algol'. Full
> continuations are the place where Scheme actually takes lexical scope
> seriously.
They did lexical scoping "right", no doubt. But back when
Landin first found that lambda calculus was useful for
modeling programming languages these concepts were not clearly
understood. I do not recall reading anything about whether
Algol designers not allowing full lexical scopin was due to an
oversight or realizing that efficient implementation of
functional argument was not possible. May be Algol's call by
name was deemed sufficient? At any rate Algol's not having
full lexical scoping does not mean one can simply reject the
idea of being influenced by it. Often at the start there is
lots of fumbling before people get it right. May be someone
should ask Steele?
And no, I do not think first class continuations automatically
follow from lexical scoping. Go has lexical scoping including
closures but no call/cc. The idea of representing future
program state as a function I think comes from Strachey,
Wadsworth and Reynolds. They used it extensively in
denotational semantics to model program behavior.
> But I'm not interested in getting into a fight about this.
We are just presenting our interpretation of history! Not
that anybody cares!
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 13:34 ` Bakul Shah
@ 2018-02-16 14:07 ` Bakul Shah
2018-02-16 20:13 ` tfb
1 sibling, 0 replies; 41+ messages in thread
From: Bakul Shah @ 2018-02-16 14:07 UTC (permalink / raw)
On Fri, 16 Feb 2018 05:34:56 -0800 Bakul Shah <bakul at bitblocks.com> wrote:
Bakul Shah writes:
> closures but no call/cc. The idea of representing future
> program state as a function I think comes from Strachey,
s/state/behavior/
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 13:34 ` Bakul Shah
2018-02-16 14:07 ` Bakul Shah
@ 2018-02-16 20:13 ` tfb
1 sibling, 0 replies; 41+ messages in thread
From: tfb @ 2018-02-16 20:13 UTC (permalink / raw)
On 16 Feb 2018, at 13:34, Bakul Shah <bakul at bitblocks.com> wrote:
>
> At any rate Algol's not having
> full lexical scoping does not mean one can simply reject the
> idea of being influenced by it. Often at the start there is
> lots of fumbling before people get it right. May be someone
> should ask Steele?
Yes, I certainly did not mean to imply that Scheme was not influenced by Algol: sorry if my message read that way. What I was arguing against was that Scheme just somehow imported some concepts from Algol into Lisp: it *did* do that, but it also invented (or, at least, implemented in a practical, standardised language) a bunch of new concepts which were *not* present in Algol.
You are right of course that someone should ask Steele &co.
> And no, I do not think first class continuations automatically
> follow from lexical scoping.
I think they don't either, but I think that's because we've been talking about two things under one name: scope and extent. What Scheme did was to say that it was going to be a language with lexical scope and indefinite extent, and it was going to take that seriously. Most languages, even ones which purport to be lexically scoped, are usually both not entirely lexically scoped, and only take the indefinite extent thing seriously in sufficiently easy cases if they are. An example of that is Common Lisp (I'm picking CL because CL is my favourite programming language which I've used for a very long time, so I think I'm allowed to be rude about it without causing offence).
CL has lexical scope and indefinite extent for variable and function bindings, so it has closures, for instance. But it has dynamic scope and definite extent for condition handlers, for instance, as well as catch tags. And finally it has lexical scope but definite extent for block names and go tags.
Scheme has lexical scope and indefinite extent for everything, and takes the attitude that if that makes it hard to implement then fine. And I think that *that* was the new thing that Scheme did. Whether the people designing Scheme knew that at the beginning (and whether their attitude was that rigorous from the beginning) I don't know.
(Of course, Scheme also made other Lisp people realise that lexical scope and mostly-indefinite-extent was a better approach than the older dynamic-scope-except-that-compiled-code-is-mostly-lexical horridness. And I think all the Scheme implementations I've used have some mechanism of adding dynamic scope / definite extent for various things, because that's the obviously right scope for, say, condition handlers.)
I think this may be off-topic for this list, although I'm enjoying talking about it.
--tim
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180216/81591cbc/attachment.html>
^ permalink raw reply [flat|nested] 41+ messages in thread
* [TUHS] Happy birthday, Niklaus Wirth!
2018-02-16 0:51 ` Dan Cross
` (3 preceding siblings ...)
2018-02-16 2:09 ` Bakul Shah
@ 2018-02-16 3:17 ` Dan Stromberg
4 siblings, 0 replies; 41+ messages in thread
From: Dan Stromberg @ 2018-02-16 3:17 UTC (permalink / raw)
On Thu, Feb 15, 2018 at 4:51 PM, Dan Cross <crossd at gmail.com> wrote:
> One of the things that strikes me about Lisp and Unix is the conceptual
> similarity between image based languages (like Lisp) with a REPL and the
> Unix "process as virtual machine" model with a shell and set of utilities.
> An image is a sort of virtual machine and a REPL is a sort of shell;
> callable functions in the REPL are sort of like discrete programs in the
> $PATH. To a first order approximation, at any rate.
>
> So anyway...some of you who were there, was there cross-pollination? Was
> Franz Lisp a thing Unix people at Berkeley played with, or was it mostly
> Lisp people who just happened to be using Unix because VAXen were expensive?
I definitely "wasn't there", but it's occurred to me before that
/bin/sh going through a file line by line, is similar to LISP going
through a list element by element.
When I took a "comparative languages" course, the professor said there
were two kinds of languages:
1) Languages that make you add convenience yourself to keep things
fast even though many people don't need the speed
2) Languages that make everyone pay (in performance) for conveniences
many developers will never need
So it's kind of the C vs. LISP thing from a (very) slightly different
perspective.
I still count C and bash among my favorites, but I mostly use Python
these days, and although I haven't done a ton in LISP, Python feels
kind of LISPy semantically - but not syntactically or lexically. But
that's a happy accident: Python wasn't particularly influence by LISP.
On the other hand, with LISP focused on Linked Lists, and Python
focused on realloc()'d arrays, the similarly isn't especially deep.
But they're both "convenience at the expense of performance, even
though not everyone will need those conveniences".
And yes, there are exceptions. As has already been mentioned, LISP
has some impressive compilers, and Python has things like Pypy and
Shedskin.
^ permalink raw reply [flat|nested] 41+ messages in thread