On 2024-04-04, Lawrence D'Oliveiro <ldo@nz.invalid> wrote:
> On Wed, 03 Apr 2024 15:29:52 -0700, Paul Rubin wrote:
>
>> I think lazy evaluation is not needed since the
>> input to the Church boolean (I hope I have the jargon right) is two
>> lambda abstractions. The boolean selects one of them, and the result is
>> applied to whatever the next thing is.
>
> I use this in Python, to try to avoid that abortion that is the Python
> conditional expression. Instead of, say,

Category error: "that abortion" is Python. If you're in the middle of it,
you've already lost the ideological battle. Use it like it was meant to be.

> a = x / y if y != 0 else 0
>
> I would do
>
> a = (lambda : 0, lambda : x / y)[y != 0]()

Not only is it more verbose, but it's unlikely that Python's compiler
recognizes the idiom and optimizes away the lambdas.

import dis

def f0():
return x / y if y != 0 else 0

def f1():
(lambda : 0, lambda : x / y)[y != 0]()

print('disasembly of f0')
dis.dis(f0)
print('disasembly of f1')
dis.dis(f1)

disasembly of f0
4 0 LOAD_GLOBAL 0 (y)
2 LOAD_CONST 1 (0)
4 COMPARE_OP 3 (!=)
6 POP_JUMP_IF_FALSE 16
8 LOAD_GLOBAL 1 (x)
10 LOAD_GLOBAL 0 (y)
12 BINARY_TRUE_DIVIDE
14 RETURN_VALUE
>> 16 LOAD_CONST 1 (0)
18 RETURN_VALUE
disasembly of f1
7 0 LOAD_CONST 1 (<code object <lambda> at 0xb77c88b8, file "distest.py", line 7>)
2 LOAD_CONST 2 ('f1.<locals>.<lambda>')
4 MAKE_FUNCTION 0
6 LOAD_CONST 3 (<code object <lambda> at 0xb77c8910, file "distest.py", line 7>)
8 LOAD_CONST 2 ('f1.<locals>.<lambda>')
10 MAKE_FUNCTION 0
12 BUILD_TUPLE 2
14 LOAD_GLOBAL 0 (y)
16 LOAD_CONST 4 (0)
18 COMPARE_OP 3 (!=)
20 BINARY_SUBSCR
22 CALL_FUNCTION 0
24 POP_TOP
26 LOAD_CONST 0 (None)
28 RETURN_VALUE

Deliberately writing longer, harder-to-read code, that is also slower, takes a
special sort of cretin.

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal
Mastodon: @Kazinator@mstdn.ca

Kaz Kylheku <643-408-1753@kylheku.com> writes:

http://jmc.stanford.edu/articles/lisp/lisp.pdf

(Don't try HTTPS, it doesn't resolve to the PDF. There may be other
hostings of it.)

Quote:

I invented conditional expressions in connection with a set of chess
legal move routines I wrote in FORTRAN for the IBM 704 at M.I.T.
during 1957-58. This program did not use list processing. The IF
statement provided in FORTRAN 1 and FORTRAN 2 was very awkward to use,
and it was natural to invent a function XIF(M,N1,N2) whose value was
N1 or N2 according to whether the expression M was zero or not. The
function shortened many programs and made them easier to understand,
but it had to be used sparingly, because all three arguments had to be
evaluated before XIF was entered, since XIF was called as an ordinary
FORTRAN function though written in machine language. This led to the
invention of the true conditional expression which evaluates only one
of N1 and N2 according to whether M is true or false and to a desire
for a programming language that would allow its use.

A paper defining conditional expressions and proposing their use in
Algol was sent to the Communications of the ACM but was arbitrarily
demoted to a letter to the editor, because it was very short.

You can find his CACM letter online at: https://doi.org/10.1145/368405.1773349

Interestingly he did not propose using "if A then B else C" as the
syntax but rather "(A → B, T → C)", almost the same as in M-expressions!
(It would be cool if you were allowed to use the "(→,→)" form in what
Algol calls the "publication language", where you can write "x₉" instead
of "x[9]", but that is not the case.)

There you go; no hallucination or urban legends. Now, this does not
establish that MacCarthy ever worked with (if A B C) in Lisp. But
that is just a variation on the same idea; a footnote, if you will.

MacCarthy used XIF(A, B, C), in his own words, to shorten many programs,
and make them easier to understand, in his own words. (In Lisp, we
can use IF to shorten programs that use COND!)

Not really the same as "invented the ternary IF, AS A SHORTHAND FOR A
ONE CLAUSE COND", but yeah it's certainly another way to get confused
about what actually happened.

As for Fortran, it eventually caved in and got a conditional operator.
In the year 2021!!! https://j3-fortran.org/doc/year/21/21-157r2.txt

Now that's a hoot. But that seems to just be a proposal. Does anyone
know if this was accepted?

- Alan

On Thu, 04 Apr 2024 04:17:15 -0400, Alan Bawden wrote:

> and it was natural to invent a function XIF(M,N1,N2) whose value
> was N1 or N2 according to whether the expression M was zero or not.
> The function shortened many programs and made them easier to
> understand, but it had to be used sparingly, because all three
> arguments had to be evaluated before XIF was entered, since XIF was
> called as an ordinary FORTRAN function though written in machine
> language.

And just one more step from there to lazy evaluation via

XIF(M, λ.N1, λ.N2)()

and Bob’s your uncle.

Interestingly, in PostScript, the control constructs (if, loop etc) are
all just built-in functions, which take lambdas as arguments.

Alan Bawden <alan@csail.mit.edu> writes:
> It's a common misconception that McCarthy was trying to turn Lambda
> Calculus into a programming language. ... He added LAMBDA (and LABEL)
> because he needed LAMBDA in order to define recursive functions, but
> as he himself often admitted, he didn't really understand Lambda
> Calculus, he just needed the notation.

I see, yes, and this is confirmed by his History of Lisp article. His
Wikipedia biography also surprised me a bit. For some reason I had
thought of him as an academic mathematical logician who later somehow
got involved with computers, but it was more like the other way around.
Thanks.

Paul Rubin <no.email@nospam.invalid> writes:

> Alan Bawden <alan@csail.mit.edu> writes:
>> It's a common misconception that McCarthy was trying to turn Lambda
>> Calculus into a programming language. ... He added LAMBDA (and LABEL)
>> because he needed LAMBDA in order to define recursive functions, but
>> as he himself often admitted, he didn't really understand Lambda
>> Calculus, he just needed the notation.
>
> I see, yes, and this is confirmed by his History of Lisp article. His
> Wikipedia biography also surprised me a bit. For some reason I had
> thought of him as an academic mathematical logician who later somehow
> got involved with computers, but it was more like the other way around.
> Thanks.

His PhD was in mathematics---differential equations. He would think up
things like a simple function that is continuous but nowhere
differentiable on the real line [1]. He was a mathematician by all
accounts. It's pretty hard to remove mathematics from computer science.
The culture seems to be that if a mathematician contributes more to the
field of computer science, he is called a computer scientist.

I also agree that he was a logician: he worked on a mathematical basis
for computer science. A mathematical basis for computer science must be
classified as logic. He was interested in proving programs were
correct. His idea of a conditional expression is precisely to write
mathematical functions in high precision. Mathematics in high
precision---that's a logician.

The creation of LISP by John McCarthy was surely not at first with
intention of a programming language. In fact, it was Steve Russell, his
student at the time, that first had the idea of implementing EVAL and
did it. I believe McCarthy was even somewhat surprised because, then,
he did not think of LISP having that kind of purpose.

[1] https://www-formal.stanford.edu/jmc/weierstrass.pdf

Julieta Shem <jshem@yaxenu.org> writes:

> Paul Rubin <no.email@nospam.invalid> writes:
>
>> Alan Bawden <alan@csail.mit.edu> writes:
>>> It's a common misconception that McCarthy was trying to turn Lambda
>>> Calculus into a programming language. ... He added LAMBDA (and LABEL)
>>> because he needed LAMBDA in order to define recursive functions, but
>>> as he himself often admitted, he didn't really understand Lambda
>>> Calculus, he just needed the notation.
>>
>> I see, yes, and this is confirmed by his History of Lisp article. His
>> Wikipedia biography also surprised me a bit. For some reason I had
>> thought of him as an academic mathematical logician who later somehow
>> got involved with computers, but it was more like the other way around.
>> Thanks.
>
> His PhD was in mathematics---differential equations. He would think up
> things like a simple function that is continuous but nowhere
> differentiable on the real line [1]. He was a mathematician by all
> accounts. It's pretty hard to remove mathematics from computer science.
> The culture seems to be that if a mathematician contributes more to the
> field of computer science, he is called a computer scientist.
>
> I also agree that he was a logician: he worked on a mathematical basis
> for computer science. A mathematical basis for computer science must be
> classified as logic. He was interested in proving programs were
> correct. His idea of a conditional expression is precisely to write
> mathematical functions in high precision. Mathematics in high
> precision---that's a logician.
>
> The creation of LISP by John McCarthy was surely not at first with
> intention of a programming language. In fact, it was Steve Russell, his
> student at the time, that first had the idea of implementing EVAL and
> did it. I believe McCarthy was even somewhat surprised because, then,
> he did not think of LISP having that kind of purpose.

--8<---------------cut here---------------start------------->8---
What happened next was that, some time in late 1958, Steve Russell, one
of McCarthy's grad students, looked at this definition of eval and
realized that if he translated it into machine language, the result
would be a Lisp interpreter.

This was a big surprise at the time. Here is what McCarthy said about it
later in an interview:

Steve Russell said, look, why don't I program this eval..., and I said
to him, ho, ho, you're confusing theory with practice, this eval is
intended for reading, not for computing. But he went ahead and did
it. That is, he compiled the eval in my paper into [IBM] 704 machine
code, fixing bugs, and then advertised this as a Lisp interpreter,
which it certainly was. So at that point Lisp had essentially the form
that it has today....

Suddenly, in a matter of weeks I think, McCarthy found his theoretical
exercise transformed into an actual programming language-- and a more
powerful one than he had intended.

Source: Paul Graham's ``Revenge of the Nerds'', May 2002.
https://www.paulgraham.com/icad.html
--8<---------------cut here---------------end--------------->8---

On Wed, 3 Apr 2024 20:57:48 -0000 (UTC)
Kaz Kylheku <643-408-1753@kylheku.com> wrote:
> However, conditional expressions ultimately come from math. E.g for
> specifying a discontinuous function:
>
> f(x) = { x, if x >= 0
> { 0, if x < 0

By the way , this is continuous on all the reals.

On Fri, 05 Apr 2024 17:56:31 -0300, Julieta Shem wrote:

> It's pretty hard to remove mathematics from computer science.

Of course different fields of scientific study are always going to abut
against each other. They are all indivisible parts of one reality, after
all.

What to me distinguishes mathematics from computer science is the
practicalities of programming. Mathematicians will construct theories
about the nature of information, what is computable and what is not,
orders of complexity, equivalence of computations and so on, and those all
have some relevance to computer science. But where the rubber meets the
road is when you write actual, working code that solves an actual problem
without consuming totally outrageous amounts of computing resources (space
and time).

In article <86cyr6pb2l.fsf@williamsburg.bawden.org>,
Alan Bawden <alan@csail.mit.edu> wrote:
>Lisp doesn't really have statements _because_ McCarthy invented the
>conditional expression. That's kind of the point. Other programming
>languages at the time (e.g. FORTRAN and ALGOL) only had conditional
>statements. McCarthy invented the conditional expression and thus
>created the first expression-only programming language.

It is a common mistake to refer to ALGOL simple.
Algol60 and algol68 are different beast altogether.

algol68 has conditional expressions:
a := 'if' summer 'then' 40 'else' -10 'fi' ;
and even a short hand:
a:= (summer|40|-10);

>- Alan

Groetjes Albert
--
Don't praise the day before the evening. One swallow doesn't make spring.
You must not say "hey" before you have crossed the bridge. Don't sell the
hide of the bear until you shot it. Better one bird in the hand than ten in
the air. First gain is a cat purring. - the Wise from Antrim -

albert@spenarnc.xs4all.nl writes:

In article <86cyr6pb2l.fsf@williamsburg.bawden.org>,
Alan Bawden <alan@csail.mit.edu> wrote:
>Lisp doesn't really have statements _because_ McCarthy invented the
>conditional expression. That's kind of the point. Other programming
>languages at the time (e.g. FORTRAN and ALGOL) only had conditional
>statements. McCarthy invented the conditional expression and thus
>created the first expression-only programming language.

It is a common mistake to refer to ALGOL simple.
Algol60 and algol68 are different beast altogether.

algol68 has conditional expressions:
a := 'if' summer 'then' 40 'else' -10 'fi' ;
and even a short hand:
a:= (summer|40|-10);

Actually Algol 60 _does_ have conditional expressions, it's Algol 58
that doesn't have them. As I wrote myself last week elsewhere in this
thread:

Ah yes, the history is slightly more complicated than I remembered.
Algol 58 did not have conditional expressions. But McCarthy then
joined the Algol committee and he suggested that they add
conditional expressions. And so they do appear in Algol 60.

And when I wrote "ALGOL" in the message you quoted, I had forgtten about
Algol 58 entirely...

- Alan

On Fri, 12 Apr 2024 14:53:46 -0400, Alan Bawden wrote:

> Algol 58 ...

A.k.a. the “International Algorithmic Language” or “IAL”.

Julieta Shem <jshem@yaxenu.org> writes:
> I also agree that he was a logician: he worked on a mathematical basis
> for computer science. A mathematical basis for computer science must be
> classified as logic.

Mathematical logic is an area that deals with topics like proof theory.
Not to diminish McCarthy in any way, but it sounds like he didn't work
in that particular area.

On 4/15/2024 2:01 PM, Paul Rubin wrote:
> Julieta Shem <jshem@yaxenu.org> writes:
>> I also agree that he was a logician: he worked on a mathematical basis
>> for computer science. A mathematical basis for computer science must be
>> classified as logic.
>
> Mathematical logic is an area that deals with topics like proof theory.
> Not to diminish McCarthy in any way, but it sounds like he didn't work
> in that particular area.

Well he and a PhD student (named not recalled) developed a compiler for
a Lisp that was of about the complexity of a mid 1960s Lisp. Then they
formally proved that the compiler was correct. This was NOT "proof
theory" as you probably meant it in the above paragraph. However in my
my mind the hairiest problems with the venture were setting up the
mechanisms and criteria for representing the code and expected behavior
plus enumerating the proof rules. A good deal of theory was developed
and buried in their effort.

I also remember McCarthy in the late 1960s being obsessed with logic and
philosophy and randomly spouting off discussions such as how processing of
Sir Walter Raleigh was the author of "The Lie"
Did the Queen know that Raleigh wrote "The Lie"?

might produce

Did the Queen know TRUE?

I heard him bring up such questions many times because he was hoping
that logical calculi could support natural language processing and
reasoning. The above was offered as an example of a problem at the
relatively simple surface level.
--
Jeff Barnett

On Mon, 15 Apr 2024 18:01:46 -0600, Jeff Barnett wrote:

> I also remember McCarthy in the late 1960s being obsessed with logic and
> philosophy and randomly spouting off discussions such as how processing
> of
> Sir Walter Raleigh was the author of "The Lie"
> Did the Queen know that Raleigh wrote "The Lie"?
>
> might produce
>
> Did the Queen know TRUE?

The word “know” has its own connotations which might be confusing things,
though. What if it were

Did the Queen believe that Raleigh wrote "The Lie"?

might produce

Did the Queen believe TRUE?

If you think that’s a meaningless statement, then how about

An ounce of prevention is worth a pound of cure
Do anti-vaxxers believe that an ounce of prevention is worth a pound
of cure?

and you realize that, trying to substitute “conspiracy theorists” for X
in

Do X believe TRUE?

is a process fraught with pitfalls. ;)

Jeff Barnett <jbb@notatt.com> writes:
> might produce
> Did the Queen know TRUE?

This is a topic in philosophy of language (idr what it is called).
Mathematical logic is completely different. By that, I mean you could
go to any university math library in the 1960s (when McCarthy was
active) or today, and find shelves full of textbooks with "mathematical
logic" in their titles. Those would all be about facets of the same
subject. Noted authors in it were people like Church (inventor of
lambda calculus), Curry (currying and the Haskell language are named
after him), Tarski, and so on. McCarthy's work was in tangentially
related areas.

McCarthy was super smart and probably could have read those textbooks
and gotten to understand the subject fairly easily, but not that many
mathematicians were into it back then. So I don't think he spent his
time that way. That's what I mean by saying he worked in different
areas.

I only met McCarthy once, and unfortunately, the only topic I remember
from the conversation had something to do with Chinese food.

On 4/15/2024 6:31 PM, Lawrence D'Oliveiro wrote:
> On Mon, 15 Apr 2024 18:01:46 -0600, Jeff Barnett wrote:
>
>> I also remember McCarthy in the late 1960s being obsessed with logic and
>> philosophy and randomly spouting off discussions such as how processing
>> of
>> Sir Walter Raleigh was the author of "The Lie"
>> Did the Queen know that Raleigh wrote "The Lie"?
>>
>> might produce
>>
>> Did the Queen know TRUE?
>
> The word “know” has its own connotations which might be confusing things,
> though. What if it were
>
> Did the Queen believe that Raleigh wrote "The Lie"?
>
> might produce
>
> Did the Queen believe TRUE?
>
> If you think that’s a meaningless statement, then how about
>
> An ounce of prevention is worth a pound of cure
> Do anti-vaxxers believe that an ounce of prevention is worth a pound
> of cure?
>
> and you realize that, trying to substitute “conspiracy theorists” for X
> in
>
> Do X believe TRUE?
>
> is a process fraught with pitfalls. ;)
The above was one of McCarthy's examples to show that blind application
of "logic techniques", e.g., substitution or unification, to other
representations, e.g., natural language was fraught with perils. In the
example, SWR = TL equiv TRUE and so TRUE was substituted. Most know
better today but at the time, a lot of smart people had too simplified,
i.e., ridiculous idea of how we could just slip formal logic in and
solve all of our AI problems without some vary necessary updates to
"formal logic" particularly preconditions of application rules.
--
Jeff Barnett

On 4/15/2024 9:48 PM, Paul Rubin wrote:
> Jeff Barnett <jbb@notatt.com> writes:
>> might produce
>> Did the Queen know TRUE?
>
> This is a topic in philosophy of language (idr what it is called).
> Mathematical logic is completely different. By that, I mean you could
> go to any university math library in the 1960s (when McCarthy was
> active) or today, and find shelves full of textbooks with "mathematical
> logic" in their titles. Those would all be about facets of the same
> subject. Noted authors in it were people like Church (inventor of
> lambda calculus), Curry (currying and the Haskell language are named
> after him), Tarski, and so on. McCarthy's work was in tangentially
> related areas.
>
> McCarthy was super smart and probably could have read those textbooks
> and gotten to understand the subject fairly easily, but not that many
> mathematicians were into it back then. So I don't think he spent his
> time that way. That's what I mean by saying he worked in different
> areas.
>
> I only met McCarthy once, and unfortunately, the only topic I remember
> from the conversation had something to do with Chinese food.

The Chinese food habit probably resulted from his time at MIT. It seems
the original hacker community plus Minsky and others were enamored of a
restaurant called Joyce Chen's in Fresh Pond close to BBN. Ms. Chen had
written a cook book. Unfortunately, the food was god awful but everyone
thought they should be one of the group and sing its praises.

I met him in the early/middle 1960s when DARPA gave us a contract to do
a thing called Lisp 2 - a Lisp system with extended language facilities
and borrows from Algol. McCarthy (now at Stanford) and Minsky were named
our Godfathers and we visited each several times a year to talk about
life and eat bad Chinese food - Danny Bobrow and Warren Teitelman would
usual join us in Cambridge. When we saw McCarthy, I often wondered why
he was in a CS department (and sat in the Stanford AI building). He
talked almost exclusively about logic and how that technology might help
formulate and solve many hard problems. I thought he would be happier in
a department of philosophy. I still have that impression.

OT tidbit: At the time talked about above, I worked near a fellow who
went to grade school with McCarthy. It seemed that he paid very little
attention to his teacher; rather he read through all volumes of the
Encyclopedia Britannica one year when he was in early grade school!
--
Jeff Barnett

On Mon, 15 Apr 2024 22:58:21 -0600, Jeff Barnett wrote:

> I met him in the early/middle 1960s when DARPA gave us a contract to do
> a thing called Lisp 2 - a Lisp system with extended language facilities
> and borrows from Algol.

That project was considered a “failure”, but I wonder why? Did it turn out
that getting rid of the (ahem) quirky Lisp syntax in fact got rid of some
of its expressive power, too?

Lawrence D'Oliveiro <ldo@nz.invalid> writes:
> [Lisp 2] That project was considered a “failure”, but I wonder why?
> Did it turn out that getting rid of the (ahem) quirky Lisp syntax in
> fact got rid of some of its expressive power, too?

This retrospective (8 page PDF) gives the impression that Lisp 2 bogged
down due to the implementation outstripping the limited computers
available at the time. Plus, Lisp 1.5 had gotten entrenched enough that
Lisp 2's Algol-like syntax didn't excite people any more:

https://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=8267589

Lisp 2 had an interesting GC scheme that migrated into SPITBOL which is
where I learned about it. It was a mark-sweep GC but had a
"generational" aspect that relocated data that had been around for a
while into a "sediment" that usually didn't get rescanned. I remember
thinking that it might be worth trying this in smaller GC'd language
interpreters like MicroPython. I don't remember much about it now, but
I spent a while studying it and thinking about documenting and/or
reimplementing it.

SPITBOL (Speedy Implementation of SNOBOL, where SNOBOL was StriNg
Oriented symBOLic language) was a quite amazing 1970s(?) implementation
of a language that could be seen as an antecedent of something like Perl:

https://github.com/spitbol

On 4/16/2024 1:22 AM, Lawrence D'Oliveiro wrote:
> On Mon, 15 Apr 2024 22:58:21 -0600, Jeff Barnett wrote:
>
>> I met him in the early/middle 1960s when DARPA gave us a contract to do
>> a thing called Lisp 2 - a Lisp system with extended language facilities
>> and borrows from Algol.
>
> That project was considered a “failure”, but I wonder why? Did it turn out
> that getting rid of the (ahem) quirky Lisp syntax in fact got rid of some
> of its expressive power, too?
Paul Rubin discusses this in another reply to your question. But there
where many issues. In the first place, there was a full normal prefix
Lisp interface to the system - compiler, assembler, debugger, reader,
etc. In the second place, there was a full meta-compiler setting in the
Lisp2 system. This meta-compiler was good enough to generate some of the
early Jovial compilers developed and used at SDC and could do
sophisticate things, e.g., remove left recursion from a grammar. In
other words, you could use prefix, a complimentary infix, or roll most
(but) not all interface languages that made you giddy.
The problem in my mind was simply lack of computer resources. The
implementation on the ANFS-Q32 had something like 48K 36+ bit words.
That simply wasn't enough so some of the fellows devised a swapping
scheme: the function linkage cliche - the common code invoked by the
function call sequence -- noted what was called and frequency. It also
noted whether the routine was in memory; if not it tried to move it to
memory from external storage; if there wasn't enough room, current
memory resident routines were moved or excised (and written out if
necessary) being selected using the frequency information; pieces of the
GC may have been used to do such tasks as compacting program storage to
make a hole big enough to do the swap in. In other words, we were doing
swapping a binary program at a time. This, as you can imagine, was a
Royal Pain In The Ass (RPITA).
So DARPA (or was it still ARPA?) says they wanted SDC to do something or
other with massive databases on IBM 360 machines so they are going to
get us a better machine. The machine turns out to be about the same size
as the Q32. Further, the next goodie a 360/370 with virtual memory could
be significantly better. However user virtual address space was to be
limited to about a megabyte - not enough to consider a copy-collect GC.
I, and several others had enough of this sort of development in limited
resources. We were motivated by experimenting with language forms and
ways to implement them, not research in how to scrounge memory while
losing sleep and forsaking a social life. Not every one agreed with the
decision to shut it down but most did. So RPITA->RIP.
--
Jeff Barnett

On Tue, 16 Apr 2024 11:23:42 -0700, Paul Rubin wrote:

> SPITBOL (Speedy Implementation of SNOBOL, where SNOBOL was StriNg
> Oriented symBOLic language) was a quite amazing 1970s(?) implementation
> of a language that could be seen as an antecedent of something like
> Perl:
>
> https://github.com/spitbol

Had a quick look at that. I would say the whole SNOBOL family has been
left in the dust by Perl. And by languages that were able to take
advantage of PCRE libraries.

Lawrence D'Oliveiro <ldo@nz.invalid> writes:
> Had a quick look at that. I would say the whole SNOBOL family has been
> left in the dust by Perl.

SNOBOL/SPITBOL in the 1970s were sort of like Perl in the 1990s, I
think. But, they are mostly of historical interest now. I think by the
time Spitbol ran on anything resembling a personal computer or
workstation, it was already history. It ran on old mainframe OS's and
there wasn't much overlap.

On 4/16/2024 8:04 PM, Paul Rubin wrote:
> Lawrence D'Oliveiro <ldo@nz.invalid> writes:
>> Had a quick look at that. I would say the whole SNOBOL family has been
>> left in the dust by Perl.
>
> SNOBOL/SPITBOL in the 1970s were sort of like Perl in the 1990s, I
> think. But, they are mostly of historical interest now. I think by the
> time Spitbol ran on anything resembling a personal computer or
> workstation, it was already history. It ran on old mainframe OS's and
> there wasn't much overlap.

FYI Lisp 2 (discussed in this thread) included a copy of Warren
Teitelman's dissertation project - a data match and manipulate engine.
It was called Flip or something simple but I don't remember. He spent a
summer in Santa Monica converting it to Lisp2. Fred Blair from IBM
Yorktown Heights was there the same summer and worked on importing
Scratchpad to our Lisp too. There was a development, Formula Algol, that
did a similar embedding into Algol so there was a lot of interest in the
1960s of including some sort of pattern match and reconstruction
primitives into programming languages.

This stuff simply exacerbated our limited memory problems on old
machines not matter how interesting they/it might be.
--
Jeff Barnett

On Tue, 16 Apr 2024 20:50:45 -0600, Jeff Barnett wrote:

> ... so there was a lot of interest in the
> 1960s of including some sort of pattern match and reconstruction
> primitives into programming languages.
>
> This stuff simply exacerbated our limited memory problems on old
> machines not matter how interesting they/it might be.

Was it a matter of timing, then? Perl came along at just the point where
the hardware was powerful enough to take the complexities of regular
expressions in its stride, so that’s when the whole idea really took off.

Lawrence D'Oliveiro <ldo@nz.invalid> writes:
> Was it a matter of timing, then? Perl came along at just the point where
> the hardware was powerful enough to take the complexities of regular
> expressions in its stride, so that’s when the whole idea really took off.

Unix had regular expressions because Thompson's QED editor on some weird
old GE(?) minicomputer had had them. It compiled the regexex into
machine code, iirc. Perl was sort of Awk on steroids and Awk also had
regexes. I think regexes per se were never very cpu or memory hungry.

Snobol and Spitbol didn't have regexes. They did pattern matching by
brute force backtracking. By that era though, computers had much more
memory than they did when Lisp 2 was happening.