[TUHS] RIP John Backus

[TUHS] RIP John Backus

[Paul McJones]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1268 bytes --]

Dave Horsfall <dave at horsfall.org> wrote:

> We lost computer pioneer John Backus on this day in 2007; amongst other 
> things he gave us FORTRAN (yuck!) and BNF, which is ironic, really, 
> because FORTRAN has no syntax to speak of.

I think of FORTRAN as having established the very idea of high-level programming languages. For example, John McCarthy’s first idea for what became LISP was to extend FORTRAN with function subroutines written in assembly language for list-manipulation. (He had to give up on this idea when he realized a conditional expression operator wouldn’t work correctly since both the then-expression and the else-expression would be evaluated before the condition was tested.) The original FORTRAN compiler pioneered code optimization, generating code good enough for the users at the physics labs and aerospace companies. For more on this compiler, see:

http://www.softwarepreservation.org/projects/FORTRAN/

Disclosure: I worked with John in the 1970s (on functional programming) — see:

http://www.mcjones.org/dustydecks/archives/2007/04/01/60/ .


Paul McJones

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180317/66768234/attachment.html>

[TUHS] RIP John Backus

[Dave Horsfall]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1921 bytes --]

On Sat, 17 Mar 2018, Paul McJones wrote:

>       [...] because FORTRAN has no syntax to speak of.
> 
> I think of FORTRAN as having established the very idea of high-level 
> programming languages. [...]

Thanks; that's the sort of discussion that I was hoping to promote 
("stirring" is a long-established tradition here in Oz).  And I happen to 
agree, oddly enough...  Was it the 704, or the 709?  I recall that the 
array indexing order mapped directly into its index register or something 
(like C's "do { ... } while (--i)" maps straight into "SOB" (although I 
don't know whether the former was influenced by the latter).

I have an article somewhere in AUUGN (I don't know which) describing our 
visit to a DECUS conference.  One of the presentations was a slide that 
compared high- and low-level languages.  I don't remember what definition 
they used, and I can't recall whether BLISS was high or low (I think it 
was "low with a pointer towards the right"), but they showed FORTRAN on 
the right, and me being me I piped up with "FORTRAN a high-level 
language?"

I don't recall the exact wording in my subsequent AUUGN report, but it 
went something like "Half the room broke up into fits of the giggles, and 
the other half were stonily wondering what was so funny."

I never did get that job with DEC some years afterwards, mostly because
got borged by Compact (?) with an ensuing management broom (and I've long 
since lost track of who bought out whom since).

> Disclosure: I worked with John in the 1970s (on functional programming) 
> — see:
> 
> http://www.mcjones.org/dustydecks/archives/2007/04/01/60/ .

Neat story!

The bookshelf: I had most of those books once; what's the one on the 
bottom right?  It has a "paperback" look about it, but I can't quite make 
it out because of the reflection on the spine.

-- 
Dave Horsfall DTM (VK2KFU)  "Those who don't understand security will suffer."

[TUHS] RIP John Backus

[Arthur Krewat]

On 3/19/2018 2:40 PM, Tom Ivar Helbekkmo via TUHS wrote:
>
> VAX C was still pretty awful in the late 90s, while their FORTRAN was
> really excellent, not least because of the high quality optimizer.
>

I had a chance to try compiling a heavily-pthread'd queuing system I 
wrote, using VAX C on VMS 6.0+, actually running it on a VAXSTATION-3200.

I originally developed it on Sun Solaris, but with minimal compatibility 
issues, also ran on HP/UX, Linux, FreeBSD, etc.

It compiled on the VAX cleanly, needed some FIONBIO ioctl's (like 
FreeBSD) and ran suprisingly well for what it was. A 10Mbps NIC could 
only get so much data forced through it.

It could handle a few thousand threads before it became unusable, IIRC.

Good times.

ak

[TUHS] RIP John Backus

[Tom Ivar Helbekkmo]

Jon Forrest <nobozo at gmail.com> writes:

> It took a while before the VAX C compiler was good enough, and
> even then, it wasn't cheap. I was in the VMS development group
> at Sybase in the early 1990s and we often hit issues in VAX C,
> and in the VAX Debug support for it.

VAX C was still pretty awful in the late 90s, while their FORTRAN was
really excellent, not least because of the high quality optimizer.

> Back to Unix ...

Agreed.  :)

...but first: being Norwegian, I have to plug another really good
FORTRAN compiler; the one in SINTRAN, the operating system for the
Norwegian built mini computers from Norsk Data.  They took FORTRAN-77,
and added even more bling to it, resulting in a compiler that could
accept the following program:

C    This FORTRAN progam may be compiled and run on a Norsk Data
C    computer running SINTRAN and the FTN compiler.  It uses only
C    FORTRAN reserved words, and contains just one numerical
C    constant, in a character string (a format specifier).  When
C    you run it, it prints a well known mathematical construct...
C
C    Even FORTRAN is a block structured programming language:

      PROGRAM
     ;PROGRAM;INTEGERIF,INTEGER,GOTO,IMPLICIT;REALREAL,DIMENSION,EXTERNA
     AL,FORMAT,END;INTEGERLOGICAL;REALCOMPLEX,DATA,CALL,ASSIGN,CHARACTER
     R;DOFORIF=INTEGER,INTEGER;ENDDO;INTEGER=IF+IF;GOTO=INTEGER*INTEGER*
     *INTEGER*INTEGER-INTEGER-IF;CALLFUNCTION(IMPLICIT,REAL,DIMENSION,EX
     XTERNAL,FORMAT,END,LOGICAL,COMPLEX,DATA,CALL,ASSIGN,CHARACTER);CALL
     LSUBROUTINE(IMPLICIT,LOGICAL,GOTO,IF,INTEGER);END;SUBROUTINEFUNCTIO
     ON(IMPLICIT,REAL,DIMENSION,EXTERNAL,FORMAT,END,LOGICAL,COMPLEX,DATA
     A,CALL,ASSIGN,CHARACTER);RETURN;END;SUBROUTINESUBROUTINE(IMPLICIT,L
     LOGICAL,GOTO,IF,INTEGER);INTEGERGOTO,IMPLICIT(GOTO),LOGICAL(GOTO),I
     IF,INTEGER,EXTERNAL,RETURN;DOFOREXTERNAL=IF,GOTO;DOFORRETURN=INTEGE
     ER,EXTERNAL-IF;IMPLICIT(RETURN)=LOGICAL(RETURN)+LOGICAL(RETURN-IF);
     ;ENDDO;IMPLICIT(IF)=IF;IMPLICIT(EXTERNAL)=IF;DOFORRETURN=IF,GOTO-EX
     XTERNAL;WRITE(IF,'(''$  '')');ENDDO;DOFORRETURN=IF,EXTERNAL;WRITE(I
     IF,'(''$''I4)')IMPLICIT(RETURN);ENDDO;WRITE(IF,'( /)');DOFORRETURN=
     =IF,GOTO;LOGICAL(RETURN)=IMPLICIT(RETURN);ENDDO;ENDDO;END

Anyone care to guess what the output looks like?

-tih
-- 
Most people who graduate with CS degrees don't understand the significance
of Lisp.  Lisp is the most important idea in computer science.  --Alan Kay
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 487 bytes
Desc: not available
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180319/cbfb2413/attachment.sig>

[TUHS] RIP John Backus

[Steve Nickolas]

On Mon, 19 Mar 2018, George Michaelson wrote:

> Once f2c could compile "zork" I stopped caring. Maybe that says it all.

XD

That's the only Fortran program that matters to me. ;)

-uso.

[TUHS] RIP John Backus

[Jon Forrest]

One reason VAX Fortran was so popular is because DEC often
included it in quotes for Vaxes. If you were writing software
in a high-level language on VMS back then, writing it in Fortran
was a good bet since almost all Vaxes running VMS had Vax Fortran.

It took a while before the VAX C compiler was good enough, and
even then, it wasn't cheap. I was in the VMS development group
at Sybase in the early 1990s and we often hit issues in VAX C,
and in the VAX Debug support for it.

Back to Unix ...

Jon Forrest

[TUHS] RIP John Backus

[Clem Cole]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1990 bytes --]

6th edition had fc <http://man.cat-v.org/unix-6th/1/fc> but it would not
take a standard F4 (or F2) deck to my knowledge. It may have been in 5th
also.   It was pretty limited.  As I said, I remember one of the arguments
for why not UNIX in the EE Dept was the lack of a 'proper' Fortran
implementation.

I remember an an early attempt at f2c in those days [which I think came
from UMich], but it did not work much better than fc itself as it was a
subset language. FYI: f2c was much later (I want to say 82-83ish and post
f77).  But it was what Ted and I used to start to convert advent to C for
the UNIX, so that was pre V7 and must have been 76ish.

Clem
ᐧ

On Mon, Mar 19, 2018 at 1:39 PM, Paul Winalski <paul.winalski at gmail.com>
wrote:

> On 3/19/18, Clem Cole <clemc at ccc.com> wrote:
> > arrgh -- dyslexia -- VT-100's are NOT  full ansi [they use the ANSI
> > sequences, but do not implement all of the features/behaviors in the
> > spec].  VMS Fortran started the same way, although it did conform in time
> > because it had to pass the Fortran validation tests.
> >
> VAX/VMS Fortran was under development at the same time as the
> Fortran-77 standard.  For the VMS Fortran development team, the new
> F77 features weren't a particularly high priority at the time because
> there wasn't any existing code that used them, whereas there was a ton
> of dusty-deck IBM FORTRAN II and FORTRAN IV code out there, especially
> in the educational market DEC was keenest to sell the VAX into.  F77
> features were implemented over time in VAX/VMS Fortran, and after a
> couple of releases it was fully Fortran-77 compliant.  But at first
> release in 1978 it was an extended subset of F77.
>
> Was f77 the first Fortran for UNIX, or were there other compilers for
> Fortran before f77 came along?
>
> -Paul W.
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180319/42064f3d/attachment-0001.html>

[TUHS] RIP John Backus

[George Michaelson]

Once f2c could compile "zork" I stopped caring. Maybe that says it all.

[TUHS] RIP John Backus

[Paul Winalski]

On 3/19/18, Clem Cole <clemc at ccc.com> wrote:
> arrgh -- dyslexia -- VT-100's are NOT  full ansi [they use the ANSI
> sequences, but do not implement all of the features/behaviors in the
> spec].  VMS Fortran started the same way, although it did conform in time
> because it had to pass the Fortran validation tests.
>
VAX/VMS Fortran was under development at the same time as the
Fortran-77 standard.  For the VMS Fortran development team, the new
F77 features weren't a particularly high priority at the time because
there wasn't any existing code that used them, whereas there was a ton
of dusty-deck IBM FORTRAN II and FORTRAN IV code out there, especially
in the educational market DEC was keenest to sell the VAX into.  F77
features were implemented over time in VAX/VMS Fortran, and after a
couple of releases it was fully Fortran-77 compliant.  But at first
release in 1978 it was an extended subset of F77.

Was f77 the first Fortran for UNIX, or were there other compilers for
Fortran before f77 came along?

-Paul W.

[TUHS] RIP John Backus

[Clem Cole]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1022 bytes --]

On Mon, Mar 19, 2018 at 10:50 AM, Dan Cross <crossd at gmail.com> wrote:

> "This is believed to be the first complete Fortran 77 system to be
> implemented." (https://s3.amazonaws.com/plan9-bell-labs/7thEdMan/vol2/f77.
> txt)
>

​Question to Steve or aps -- certainly V7's version could not pass the
validation test as distributed from AT&T and UCB (at Masscomp we actually
ran the validation suite through it in the our 4.1 Vax -- we decided it was
going to be too much work and we had started over with new front and back
ends  when we created a compiler group with ex-DECies - C and Fortran being
the primary).  But I assume at some time folks in Summit did the work on
making the AT&T version pass at least by the timer PCC2.  Assuming it did,
do you have any idea when it was running through and got an official seal
as being validated?

ᐧ
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180319/0b38cfe8/attachment-0001.html>

[TUHS] RIP John Backus

[Clem Cole]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 2758 bytes --]

arrgh -- dyslexia -- VT-100's are NOT  full ansi [they use the ANSI
sequences, but do not implement all of the features/behaviors in the
spec].  VMS Fortran started the same way, although it did conform in time
because it had to pass the Fortran validation tests.
ᐧ

On Mon, Mar 19, 2018 at 11:43 AM, Clem Cole <clemc at ccc.com> wrote:

>
>
> On Mon, Mar 19, 2018 at 10:50 AM, Dan Cross <crossd at gmail.com> wrote:
>
>> I'm curious at the FORTRAN effort: what was that about, where did it come
>> from, and why was it abandoned?
>>
> ​I'll let Ken, Steve or Doug answer definitively that​ but I would suspect
> - it is a lot of work and at time t0, it was less valuable than some of the
> other efforts going at the time.
>
>
>
>>
>> Second, 7th Edition came with the "f77" command implementing
>> (unsurprisingly) Fortran 77. A paper by Stu Feldman and Peter Weinberger in
>> Volume 2 describes the compiler and includes this line: "This is believed
>> to be the first complete Fortran 77 system to be implemented." (
>> https://s3.amazonaws.com/plan9-bell-labs/7thEdMan/vol2/f77.txt)
>>
> ​Mumble, although probably true in absolute fact.  The DEC VAX/VMS Fortran
> compiler was contemporary.   I have always said that the best piece of work
> DEC Marketing ever did was convince the world that VMS Fortran was F77 (it
> was not).   It ended up being a super-set, although it did not start out
> that way (similar to people believing VT-100's are ANSI - they are and in
> that case never did fully conform).
>
>
>
>
>>
>> Was that true? Notable in this paper is mention that the Fortran compiler
>> can drive the backend of either Ritchie's PDP-11 C compiler *or* Johnson's
>> portable C compiler. What was the local story? Did this see local use?
>>
> ​I used the PCC/VAX version extensively (as well as ratfor) for the 'users
> space' part of my thesis work.   My housemate, Tom Quarles, had developed
> SPICE3 (in C) and Ellis Cohen had written SPICE2 in FORTRAN.   FPS had done
> a great deal of development on the array processor that was the basis for
> my work, all in Ratfor but assuming VMS under the coveres (they wrote an
> optimizing parallel Fortran compiler in same -- those guys are now the
> Portland Compiler Group).​
>
>
> ​I worked, although moving stuff from VMS to BSD was huge because F77 !=
> VMS Fortran.  Much of the 'grunt' work I had was making all that work.​   In
> fact, it was this work that I found a bug in the C compiler runtimes, that
> I have written about elsewhere.  The ratfor code called F77, which shared
> C's runtime.
>
> ᐧ
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180319/df2c2825/attachment.html>

[TUHS] RIP John Backus

[Clem Cole]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 2340 bytes --]

On Mon, Mar 19, 2018 at 10:50 AM, Dan Cross <crossd at gmail.com> wrote:

> I'm curious at the FORTRAN effort: what was that about, where did it come
> from, and why was it abandoned?
>
​I'll let Ken, Steve or Doug answer definitively that​ but I would suspect
- it is a lot of work and at time t0, it was less valuable than some of the
other efforts going at the time.



>
> Second, 7th Edition came with the "f77" command implementing
> (unsurprisingly) Fortran 77. A paper by Stu Feldman and Peter Weinberger in
> Volume 2 describes the compiler and includes this line: "This is believed
> to be the first complete Fortran 77 system to be implemented." (
> https://s3.amazonaws.com/plan9-bell-labs/7thEdMan/vol2/f77.txt)
>
​Mumble, although probably true in absolute fact.  The DEC VAX/VMS Fortran
compiler was contemporary.   I have always said that the best piece of work
DEC Marketing ever did was convince the world that VMS Fortran was F77 (it
was not).   It ended up being a super-set, although it did not start out
that way (similar to people believing VT-100's are ANSI - they are and in
that case never did fully conform).




>
> Was that true? Notable in this paper is mention that the Fortran compiler
> can drive the backend of either Ritchie's PDP-11 C compiler *or* Johnson's
> portable C compiler. What was the local story? Did this see local use?
>
​I used the PCC/VAX version extensively (as well as ratfor) for the 'users
space' part of my thesis work.   My housemate, Tom Quarles, had developed
SPICE3 (in C) and Ellis Cohen had written SPICE2 in FORTRAN.   FPS had done
a great deal of development on the array processor that was the basis for
my work, all in Ratfor but assuming VMS under the coveres (they wrote an
optimizing parallel Fortran compiler in same -- those guys are now the
Portland Compiler Group).​


​I worked, although moving stuff from VMS to BSD was huge because F77 !=
VMS Fortran.  Much of the 'grunt' work I had was making all that work.​   In
fact, it was this work that I found a bug in the C compiler runtimes, that
I have written about elsewhere.  The ratfor code called F77, which shared
C's runtime.

ᐧ
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180319/d3990c8f/attachment.html>

[TUHS] RIP John Backus

[Dan Cross]

On Sun, Mar 18, 2018 at 5:07 PM, Clem Cole <clemc at ccc.com> wrote:
>
> [...]
> I do remember, one of the big issues with UNIX being picked up into the EE
> department was the lack of a 'proper Fortran.'    As much as modern
> languages like C and Pascal were clearly the direction, a lot of professors
> had a lot of code in FORTRAN they wanted to run.
>
> So now I live in a world were the best FORTRAN compilers are UNIX based
> and I don't write with FORTRAN anymore.   I still have a ton of respect for
> those that do and even more for the wizards like Paul and co that have
> spent their careers creating compilers for FORTRAN that have spanned such
> changes in the underlying system hardware, as well as the language itself
> and keep those same user codes getting correct answers and using the
> hardware as well as can be.
>

And to bring this back around to Unix, here are a couple of random
questions....

First, in Dennis Ritchie's paper, "The Development of the C Language" (
https://www.bell-labs.com/usr/dmr/www/chist.html) he mentions the early
days of Unix, Ken taking Doug McIlroy's implementation of "TMG" on the
PDP-7 as a challenge and deciding to produce a "systems programming
language." The first effort was, apparently, "a rapidly scuttled attempt at
Fortran", followed by B.

I'm curious at the FORTRAN effort: what was that about, where did it come
from, and why was it abandoned?

Second, 7th Edition came with the "f77" command implementing
(unsurprisingly) Fortran 77. A paper by Stu Feldman and Peter Weinberger in
Volume 2 describes the compiler and includes this line: "This is believed
to be the first complete Fortran 77 system to be implemented." (
https://s3.amazonaws.com/plan9-bell-labs/7thEdMan/vol2/f77.txt)

Was that true? Notable in this paper is mention that the Fortran compiler
can drive the backend of either Ritchie's PDP-11 C compiler *or* Johnson's
portable C compiler. What was the local story? Did this see local use?

        - Dan C.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180319/5452fa3e/attachment.html>

[TUHS] RIP John Backus

[Warner Losh]

On Sun, Mar 18, 2018 at 6:26 PM, Steve Johnson <scj at yaccman.com> wrote:

> PS:  For years afterwards, when I punched in FORTRAN programs I left out
> all the blanks.  It wasn't until  I worked on a large program with several
> other people that I was forced to change this habit, my coworkers having
> threatened me with death or dismemberment if I didn't...
>

No boiling oil? I'd say they were going light on you :)

Warner
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180319/937a8920/attachment.html>

[TUHS] RIP John Backus

[Steve Johnson]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 2642 bytes --]

I had an interesting run-in with FORTRAN's blank treatment very early
in my career.   A couple of weeks after I graduated from college I
had a summer job at Bell Labs.  I was given a job to program a state
minimization algorithm -- they expected it to take me the whole
summer.  A couple of days after arriving, i heard about a new
language, SNOBOL, developed at another location at Bell Labs.  This
sounded like the perfect language to write my program in, so I got a
copy to use (I think I was the first user at Murray Hill).

Now, in those days, there were rooms full of "keypunch girls" (sic)
whose job was to punch up our programs (written on coding sheets) and
verify them and give us the deck back.  The vast majority of jobs
they encountered were FORTRAN, and to avoid ambiguity they simply
skipped all blanks.   (it wasn't quite that easy -- they knew about
column 7 and hollerith strings).  But any blanks that we wanted on
the cards had to be explicitly indicated on the coding sheet.

Of course, SNOBOL had what we would consider now a more modern syntax
with blanks significant and nothing magic about columns 6 or 7...   
So when I gave them my first 2-page SNOBOL program, they typed
everything on each line starting in column 7 and with all blanks
removed.    For some reason, the first couple of cards looked OK to
me, so I submitted the deck, and proceeded to get a thick printout
that I think enumerated every error message the compiler could
produce.

I started indicating my blanks carefully but their habit persisted,
and almost any nontrivial job  I gave them had errors, either because
I hadn't inidicated a blank or they hadn't typed it when I indicated
it.

Since I had been punching cards myself for a couple of years at
college, and when working 2nd shift (when turnaround was much better)
there were no keypunchers available, after a couple of weeks I got
them to agree to let me keypunch my own programs.  A few years later,
the keypunchers were gone, having been rendered obsolete by time
sharing and online editing...

Oh, and I got the job done in 3 weeks once I got SNOBOL to work...  
It really was the right language for the job...

Steve

PS:  For years afterwards, when I punched in FORTRAN programs I left
out all the blanks.  It wasn't until  I worked on a large program
with several other people that I was forced to change this habit, my
coworkers having threatened me with death or dismemberment if I
didn't... 


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180318/2a26a542/attachment.html>

[TUHS] RIP John Backus

[Tim Bradshaw]

On 18 Mar 2018, at 18:51, Paul Winalski <paul.winalski at gmail.com> wrote:
> 
> I suspect that FORTRAN's syntax was designed before its creators had
> read any of the formal language work of Chomsky et. al., hence its
> poorly-behaved grammar.

They probably could not have read it: if I'm right, the draft specification for FORTRAN was 1954, with the manual and an implementation following in October 1956 & April 1957.  The Chomsky hierarchy was described by Chomsky in 1956.  So they got FORTRAN 'wrong' because no-one knew what 'right' was, or how it differed from 'wrong' at the point they had to decide what the syntax was going to be.

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180318/23beeec0/attachment.html>

[TUHS] RIP John Backus

[Clem Cole]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 5584 bytes --]

On Sun, Mar 18, 2018 at 2:51 PM, Paul Winalski <paul.winalski at gmail.com>
wrote:

> On 3/16/18, Dave Horsfall <dave at horsfall.org> wrote:
> > We lost computer pioneer John Backus on this day in 2007; amongst other
> > things he gave us FORTRAN (yuck!) and BNF, which is ironic, really,
> > because FORTRAN has no syntax to speak of.
> >
> (Mis-)features such as the insignificance of white space made some
> sense when the target consumers for the language (numerical analysts)
> were accustomed to writing numbers with commas or spaces separating
> groups of digits (e.g., 1 234 567 and 1,234,567).  Of course, that
> does lead to grammatical nasties such as the need for
> context-sensitive lexical analysis.
>
> I suspect that FORTRAN's syntax was designed before its creators had
> read any of the formal language work of Chomsky et. al., hence its
> poorly-behaved grammar.
>
> -Paul W.
>
Right .. my point was it is easy to trash talk something that was
remarkably successful such as FORTRAN when it was created (60 years) later​

​when we get to look back on the design with a great deal more knowledge
that original designers had creating it​.   To be honest, I have a hard
time imagining writing some of the programs my late father did when he was
a 'computer' in the later 50s and early 60s and he and his peeps started to
convert their work from manual equation grinding to computer simulation (
*i.e.* the movie Hidden Figures).

As importantly, it was just those old codes that made the market to allowed
computers to become valuable.  Remember that the original estimates in the
1940-50s was a tens of systems world wide.   FORTRAN was really the key
enabler that made market and created the need for more computers.

Again, we can not judge with today's lens if for no other reason than
because so much of what we have in computing (just the space and speed of
the systems alone) were unimaginable in the 50s & 60s.    Computer time was
much more expensive/too precious.  I'm not sure my adult aged children or
most of their friends have ever used systems were 'accounting' was done and
'charge back' was performed, number of seconds of CPU time was calculated.
 [IIRC: The student WatFIV compiler at CMU on TSS/360 gave you no more than
10 seconds of compile time and 2.5 seconds of run time for your batch
job].  Today we have IDE's, and interactive debuggers etc...    such were
just not cost effective.   The key point being that computers cost more
than people.

To bring this back to UNIX.   That was one of the really remarkable things
about Ken and Dennis work.   Interactive systems like UNIX were not the
norm.   Yes, DEC sold them and they were are hit for only a small group,
but even TOPS-10 systems were out of reach for many (remember K&D had their
PDP-10 proposal tossed out by their management].   Unix ran on 'modest'
hardware and that changed a lot of things.  And I think that is one of the
reasons why Fortran was 'knocked' out of its position with many
programmers.   Interactive computing changed who was using computers.


But as Paul mentioned, Fortran had already become the linga-franc of the
scientific community before we were able to use computers as we do today.
As I said, the math they used has not changed and it is remarkable that
that old 1960's code still works.   Steve put it well and I'll add a
challenge to any hot shot programmer (which at one time I guess I
considered myself to be) to have done much better (I'm sure I could not
have).   I am humbled by how good a job they did with creating both the
language itself, the codes that used it, and how long/well those codes have
stood the test of time.

I was introduced at FORTRAN-IV, after learning Assembler and BASIC and
learned Algol-W at the same time.  At the time, I was pretty impressed,
with F4, some of its strangeness like white space, or column orientation
were not that strange given we all were on cards.    But I was lucky to be
at a place were interactive computing was also blossoming and was given all
the computer I wanted on PDP-10s and PDP-11s.   I stopped writing FORTRAN
because we had SAIL, BLISS and eventually C and Pascal.  Although thinking
back, the last large Fortran program I wrote for CMU was an accounting
program for the PDP-20's in '76 that computer center had.   I'm not sure
why they wanted it in Fortran, but I do remember that was a requirement,
probably because it had to run TSS also.

I do remember, one of the big issues with UNIX being picked up into the EE
department was the lack of a 'proper Fortran.'    As much as modern
languages like C and Pascal were clearly the direction, a lot of professors
had a lot of code in FORTRAN they wanted to run.

So now I live in a world were the best FORTRAN compilers are UNIX based and
I don't write with FORTRAN anymore.   I still have a ton of respect for
those that do and even more for the wizards like Paul and co that have
spent their careers creating compilers for FORTRAN that have spanned such
changes in the underlying system hardware, as well as the language itself
and keep those same user codes getting correct answers and using the
hardware as well as can be.

So I never knock FORTRAN or FORTRAN programmers.   While we may not chose
to use it because it is the wrong tool for our job, they have done and
continue to do much for all of us and we all should really remember that.

Clem



ᐧ
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180318/5a4702a8/attachment-0001.html>

[TUHS] RIP John Backus

[Paul Winalski]

On 3/16/18, Dave Horsfall <dave at horsfall.org> wrote:
> We lost computer pioneer John Backus on this day in 2007; amongst other
> things he gave us FORTRAN (yuck!) and BNF, which is ironic, really,
> because FORTRAN has no syntax to speak of.
>
(Mis-)features such as the insignificance of white space made some
sense when the target consumers for the language (numerical analysts)
were accustomed to writing numbers with commas or spaces separating
groups of digits (e.g., 1 234 567 and 1,234,567).  Of course, that
does lead to grammatical nasties such as the need for
context-sensitive lexical analysis.

I suspect that FORTRAN's syntax was designed before its creators had
read any of the formal language work of Chomsky et. al., hence its
poorly-behaved grammar.

-Paul W.

[TUHS] RIP John Backus

[Noel Chiappa]

    > From: Paul McJones <paul at mcjones.org>

    > I suspect the CPU architect (Gene Amdahl -- not exactly a dullard)
    > intended programmers store array elements at increasing memory
    > addresses, and reference an array element relative to the address of the
    > last element plus one. This would allow a single index register (and
    > there were only three) to be used as the index and the (decreasing)
    > count.

I suspect the younger members of the list, who've only ever lived in a world
in which one lights ones cigars with mega-gates, so to speak, may be missing
the implication here.

Back when the 704 (a _tube_ machine) was built, a register meant a whole row
of tubes. That's why early machines had few/one register(s).

So being able to double up on what a register did like this was _HYYUUGE_.

       Noel

[TUHS] RIP John Backus

[Steve Simon]

again, a personal view,

i think fortran 66 was not a great language but by the time 77 came around it was good enough (especially with rat4 in front)

the problem fortran had was its position in time, in the early days of computer programming the authors of some large systems tended to be experts in their fields, but not always good programmers.

in previous jobs i supported both Pafec FE and Flow3d. both of these started out as well structured systems but where amended by many hackers.

fortran gets the blame for this because fortran was what people used then, but its not the languages fault.

-Steve

[TUHS] RIP John Backus

[Otto Moerbeek]

On Sat, Mar 17, 2018 at 02:52:29PM -0400, Arthur Krewat wrote:

> On 3/17/2018 1:49 PM, Paul McJones wrote:
> > It first ran on the IBM 704, whose index registers subtracted (as did
> > the follow-on 709, 7090, etc), so array indexing went from higher memory
> > addresses to lower.
> 
> Leave it to IBM to do something backwards.
> 
> Of course, that was in 1954, so I can't complain, it was 11 years before I
> was born. But that's ... odd.
> 
> Was subtraction easier than addition with digital electronics back then? I
> would think that they were both the same level of effort (clock cycles) so
> why do something obviously backwards logically?
> 
> ak

Speculation:

If you only have a conditional jump on zero, a loop that ends at an
index becoming zero is more easy, it saves an extra subtraction to
test for the end condition. You load the size of the array into the
index register, and then loop until it becomes zero. If you then use
the end the array as the base, you still have a forward loops since the
effective address will be computed as end - index with index begin
decremented in the loop.

	-Otto

[TUHS] RIP John Backus

[Greg 'groggy' Lehey]

On Saturday, 17 March 2018 at 14:52:29 -0400, Arthur Krewat wrote:
> On 3/17/2018 1:49 PM, Paul McJones wrote:
>> It first ran on the IBM 704, whose index registers subtracted (as did
>> the follow-on 709, 7090, etc), so array indexing went from higher
>> memory addresses to lower.
>
> Leave it to IBM to do something backwards.
>
> Of course, that was in 1954, so I can't complain, it was 11 years before
> I was born. But that's ... odd.
>
> Was subtraction easier than addition with digital electronics back
> then?

Yes.  The basic arithmetic operation on ones-complement machines
(which meant just about every big computer of the day) was
subtraction.

> I would think that they were both the same level of effort (clock
> cycles) so why do something obviously backwards logically?

If I recall this correctly, the big issue was -0.  It was easier to
avoid this value with a subtractive adder than with an additive adder.
Possibly the adder itself was also marginally simpler as a result.

The other interesting thing about the 704 and 709 was that there was a
3 bit field for the decrement registers (as the index were called),
and each bit selected one register, so you could use any or all of the
registers in an operation.  I'd like to claim that this was the reason
for 3 array subscripts in early FORTRAN, but last time I made a claim
like that I was soundly trounced.

Later 70* machines expanded to 7 decrement registers, and this feature
was lost.

Greg
--
Sent from my desktop computer.
Finger grog at lemis.com for PGP public key.
See complete headers for address and phone numbers.
This message is digitally signed.  If your Microsoft mail program
reports problems, please read http://lemis.com/broken-MUA
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 163 bytes
Desc: not available
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180318/8373455f/attachment.sig>

[TUHS] RIP John Backus

[Steve Johnson]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1224 bytes --]


Let me offer a somewhat different perspective on FORTRAN.  When an
airplane is designed, the design undergoes a number of engineering
tests under simulation at the design stage.  Many countries require
that these simulation runs be archived for the lifetime of the
airplane so that, in the event of a crash, they can be run again with
the conditions experienced by the aircraft to see whether the problem
was in the design.  Airplanes commonly take 10 years from first
design to first shipment.  And then are sold for 10 years or so. 
And the planes can fly for up to 30 years after that.   So these
tests need to be written in a computer language that can be run 50
years in the future -- that is a stipulation of the archive
requirement.  There really aren't any alternative languages that I'm
aware of that could meet this criterion -- that's particularly true
today, when there is a sea change from serial to parallel programming
and it's hard to pick a winner with five decades of life ahead of
it...

Does anyone have any candidates?

Steve


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180317/632600a7/attachment.html>

[TUHS] RIP John Backus

[Paul McJones]

On 3/17/2018 12:22 PM, Arthur Krewat <krewat at kilonet.net> wrote:
> Leave it to IBM to do something backwards.
>
> Of course, that was in 1954, so I can't complain, it was 11 years before
> I was born. But that's ... odd.
>
> Was subtraction easier than addition with digital electronics back then?
> I would think that they were both the same level of effort (clock
> cycles) so why do something obviously backwards logically?

Subtraction was done by taking the two's complement and adding. I 
suspect the CPU architect (Gene Amdahl -- not exactly a dullard) 
intended programmers store array elements at increasing memory 
addresses, and reference an array element relative to the address of the 
last element plus one. This would allow a single index register (and 
there were only three) to be used as the index and the (decreasing) 
count. See the example on page 97 of:

James A. Saxon
Programming the IBM 7090: A Self-Instructional Programmed Manual
Prentice-Hall, 1963
http://www.bitsavers.org/pdf/ibm/7090/books/Saxon_Programming_the_IBM_7090_1963.pdf

The Fortran compiler writers decided to reverse the layout of array 
elements so a Fortran subscript could be used directly in an index register.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180317/4da38e01/attachment.html>

[TUHS] RIP John Backus

[Paul McJones]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 783 bytes --]

On 3/17/2018 12:22 PM, Steve Simon <steve at quintile.net> wrote:

> on the subject of fortran’s language, i remember hearing tell of a French version. anyone ever meet any?

Yes: here is the French version of the original Fortran manual, with 
keywords in French (via 
http://www.softwarepreservation.org/projects/FORTRAN/):

Anonymous. FORTRAN Programmation Automatique de L'Ordinateur IBM 704 : 
Manuel du Programmeur. IBM France, Institut de Calcul Scientifique, 
Paris. No date, 51 pages. Given to Paul McJones by John Backus.
http://archive.computerhistory.org/resources/text/Fortran/102663111.05.01.acc.pdf
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180317/896481de/attachment.html>

[TUHS] RIP John Backus

[Charles Anthony]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1006 bytes --]

On Sat, Mar 17, 2018 at 12:15 PM, Pierre DAVID <pdagog at gmail.com> wrote:

> On Sat, Mar 17, 2018 at 05:06:51PM +0000, Steve Simon wrote:
>
>>
>> on the subject of fortran’s language, i remember hearing tell of a French
>> version. anyone ever meet any?
>>
>>
> Never heard of a French version of Fortran, but you may have been confused
> with LSE (Langage Symbolique d'Enseignement, aka Symbolic Language for
> Education), which was a BASIC variant with French keywords.
>
>
The Multics Pascal compiler has a "-french" option which maps all of the
keywords to French.

Some examples from "pascal_french_keywords.gi.info":

English             French
-------             ------
$export             $exporte
array               tableau
file                fichier
otherwise           autrement
unpack              detasser


-- Charles
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180317/746702c0/attachment.html>

[TUHS] RIP John Backus

[Mike Markowski]

On 03/17/2018 09:43 AM, Clem Cole wrote:>
> [...]  But Fortran has a place and it still pays my and
> many of our salaries (and I happen to know it paid the salary if a 
> number of folks on this list and I think, like me still does).
> [...]
As something sorta, kinda like a proof by contradiction, I work in an RF 
lab.  A fair amount of effort is put into writing code to control lab 
gear to automate data collection, reach confidence level, etc.

For one project the customer required that it be written in Java.  Most 
RF lab gear and radios use I/Q (in-phase/quadrature) signals and the 
associated math is complex.  Try doing complex DSP in Java and you will 
soon sing the praises of Fortran where it's a snap.  :-)

Mike Markowski

[TUHS] RIP John Backus

[Tim Bradshaw]

On 17 Mar 2018, at 13:43, Clem Cole <clemc at ccc.com> wrote:
> 
> Simply out (and for those) that don't want to reads the more details arguments - please don't try to compare Fortran to C, Pascal, Java, Rust etc. or many other languages - please do not knock it because you don't need to use it or look down on those that do use because it helps them.  But, instead remember that is in your toolbox, has been and is an appropriate solution for many problems, and is likely to continue to be for many years.
> 
> [...]
> 
> Today's Fortran is not, the language Backus and team at IBM created in the late 1950s.   Like English (or 'American English' maybe), it has morphed a bit and taken ideas from other languages.

Also without wanting to start a war about this, I want to agree strongly with it.  I work somewhere where our main computational tool is a large Fortran program which does things critical to the security (both economic and defence) of the country I live in.  It's officially in Fortran 90 but I think older chunks of it are probably still in FORTRAN 77 and yet other chunks written to more recent standards.

It's a horrible thing, but it's a horrible thing because it has been written by scientists rather than people who have software backgrounds, and written & maintained over something like 30 years or more.  In particular it's not horrible because it's in Fortran: Fortran 90 is a reasonably pleasant language as far as I can see (I learnt FORTRAN 77 and since I don't work directly on this program I'm not really familiar enough with the later standards to make a strong statement), and later standards seem even more pleasant.

We're in the early stages of replacing this program by something which will scale bette (to, eventually, millions rather than thousands of cores).  That program is going to be written in Fortran (with fairly extensive preprocessing to isolate science code from details of the implementation), and that's *the right decision*.

--tim
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180317/949939f8/attachment-0001.html>

[TUHS] RIP John Backus

[Pierre DAVID]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 634 bytes --]

On Sat, Mar 17, 2018 at 05:06:51PM +0000, Steve Simon wrote:
>
>on the subject of fortran’s language, i remember hearing tell of a French version. anyone ever meet any?
>

Never heard of a French version of Fortran, but you may have been confused
with LSE (Langage Symbolique d'Enseignement, aka Symbolic Language for
Education), which was a BASIC variant with French keywords.

Kind of weird, never used it, but it was popular in the 1970s in France.

English Wikipeda page:
    https://en.wikipedia.org/wiki/LSE_(programming_language)

More complete French Wikipedia page:
    https://fr.wikipedia.org/wiki/LSE_(langage)

Pierre

[TUHS] RIP John Backus

[Arthur Krewat]

On 3/17/2018 1:49 PM, Paul McJones wrote:
> It first ran on the IBM 704, whose index registers subtracted (as did 
> the follow-on 709, 7090, etc), so array indexing went from higher 
> memory addresses to lower.

Leave it to IBM to do something backwards.

Of course, that was in 1954, so I can't complain, it was 11 years before 
I was born. But that's ... odd.

Was subtraction easier than addition with digital electronics back then? 
I would think that they were both the same level of effort (clock 
cycles) so why do something obviously backwards logically?

ak

[TUHS] RIP John Backus

[Paul McJones]

On 3/17/2018 8:54 AM, Dave Horsfall <dave at horsfall.org> wrote:

> ...  Was it the 704, or the 709?  I recall that the
> array indexing order mapped directly into its index register or something
> ...

It first ran on the IBM 704, whose index registers subtracted (as did 
the follow-on 709, 7090, etc), so array indexing went from higher memory 
addresses to lower.

> The bookshelf: I had most of those books once; what's the one on the
> bottom right?  It has a "paperback" look about it, but I can't quite make
> it out because of the reflection on the spine.

I'm not sure, and things have shifted since then on the shelves, but I 
sent the original photo to your email address.


-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180317/dbd356e5/attachment.html>

[TUHS] RIP John Backus

[Steve Simon]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 3474 bytes --]


personally, when i have add significant modules to fortran projects i have written new code in rat4 which i find an excellent solution - others may disagree.

on the subject of fortran’s language, i remember hearing tell of a French version. anyone ever meet any? 

-Steve


> On 17 Mar 2018, at 13:43, Clem Cole <clemc at ccc.com> wrote:
> 
> 
> 
>> On Fri, Mar 16, 2018 at 5:52 PM, Dave Horsfall <dave at horsfall.org> wrote:
>> We lost computer pioneer John Backus on this day in 2007; amongst other things he gave us FORTRAN (yuck!) and BNF, which is ironic, really, because FORTRAN has no syntax to speak of​.
>  
> ​Dave -- please be careful about the disparaging comments.
> 
> As a system's person, I don't need to write in it, (although I can understand it when I need too) and neither do I believe many of our colleagues in the system business; since it is not the right thing for my or their needs.  But Fortran has a place and it still pays my and many of our salaries (and I happen to know it paid the salary if a number of folks on this list and I think, like me still does). 
> 
> ​I'll save people on the list from the full argument and try to keep a flame war from starting but I offer that you instead read:  Clem Cole's answer to Is Fortran Still Alive  and
> Clem Cole's answer to Why is the Fortran language still in use and (most importantly) relevant in HPC? Is it just because this language has tremendous numerical calculation capability which is an important part of HPC? 
> 
> Simply out (and for those) that don't want to reads the more details arguments - please don't try to compare Fortran to C, Pascal, Java, Rust etc. or many other languages - please do not knock it because you don't need to use it or look down on those that do use because it helps them.  But, instead remember that is in your toolbox, has been and is an appropriate solution for many problems, and is likely to continue to be for many years.
> 
> Are their 'better' tools, like the QUERTY keyboard? Sure but they not economically interesting.  I ask you to please be kind before you make disparaging comments.   As I point out in those answer, even if I could wave wand and have all those oce that we have today magically rewritten into a modern language from C to Rust or something else that strikes your fancy, there is no way it would be economical (much less wise) to try to revalidate the years and years of data that Fortran based codes have created.
> 
> As I close, I try to remember that many Frenchman have been historical annoyed  because French, which is said to be a 'pure and beautiful' did not become the universal world language, and the wretched and crass anglo saxon English did.  Yet many 'British' be moan that 'American' is not English either.   And many 'merkins' can hardly understand people in many parts of the world .  It does not make either anyone language better than the other.  Both are useful - communications is passing information between to parties and they all usually get the job done, some more easily than others.
> 
> Today's Fortran is not, the language Backus and team at IBM created in the late 1950s.   Like English (or 'American English' maybe), it has morphed a bit and taken ideas from other languages.
> 
> 'nuf said I hope.
> 
> Clem
> 
> 
> ᐧ
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180317/8b7dff12/attachment.html>

[TUHS] RIP John Backus

[Clem Cole]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 3386 bytes --]

On Fri, Mar 16, 2018 at 5:52 PM, Dave Horsfall <dave at horsfall.org> wrote:

> We lost computer pioneer John Backus on this day in 2007; amongst other
> things he gave us FORTRAN (yuck!) and BNF, which is ironic, really, because
> FORTRAN has no syntax to speak of
> ​.
>

​Dave -- please be careful about the disparaging comments.

As a system's person, I don't need to write in it, (although I can
understand it when I need too) and neither do I believe many of our
colleagues in the system business; since it is not the right thing for my
or their needs.  But Fortran has a place and it still pays my and many of
our salaries (and I happen to know it paid the salary if a number of folks
on this list and I think, like me still does).


​I'll save people on the list from the full argument and try to keep a
flame war from starting but I offer that you instead read:  Clem Cole's
answer to Is Fortran Still Alive
<https://www.quora.com/Is-Fortran-still-alive/answer/Clem-Cole>  and
Clem Cole's answer to Why is the Fortran language still in use and (most
importantly) relevant in HPC? Is it just because this language has
tremendous numerical calculation capability which is an important part of
HPC?
<https://www.quora.com/Why-is-the-Fortran-language-still-in-use-and-most-importantly-relevant-in-HPC-Is-it-just-because-this-language-has-tremendous-numerical-calculation-capability-which-is-an-important-part-of-HPC/answer/Clem-Cole>


Simply out (and for those) that don't want to reads the more details
arguments - please don't try to compare Fortran to C, Pascal, Java, Rust *etc.
*or many other languages - please do not knock it because you don't need to
use it or look down on those that do use because it helps them.  But,
instead remember that is in your toolbox, has been and is *an appropriate
solution for many problems*, and is likely to continue to be for many years.

Are their 'better' tools, like the QUERTY keyboard? Sure but they not
economically interesting.  I ask you to please be kind before you make
disparaging comments.   As I point out in those answer, even if I could
wave wand and have all those oce that we have today magically rewritten
into a modern language from C to Rust or something else that strikes your
fancy, there is no way it would be economical (much less wise) to try to
revalidate the years and years of data that Fortran based codes have
created.

As I close, I try to remember that many Frenchman have been
historical annoyed  because French, which is said to be a 'pure and
beautiful' did not become the universal world language, and the wretched
and crass anglo saxon English did.  Yet many 'British' be moan that
'American' is not English either.   And many 'merkins' can hardly
understand people in many parts of the world .  It does not make either
anyone language better than the other.  Both are useful - communications is
passing information between to parties and they all usually get the job
done, some more easily than others.

Today's Fortran is not, the language Backus and team at IBM created in the
late 1950s.   Like English (or 'American English' maybe), it has morphed a
bit and taken ideas from other languages.

'nuf said I hope.

Clem


ᐧ
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180317/7cdb735e/attachment.html>

[TUHS] RIP John Backus

[Bakul Shah]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1250 bytes --]

On Mar 16, 2018, at 2:52 PM, Dave Horsfall <dave at horsfall.org> wrote:
> 
> We lost computer pioneer John Backus on this day in 2007; amongst other things he gave us FORTRAN (yuck!) and BNF, which is ironic, really, because FORTRAN has no syntax to speak of.

He atoned for designing FORTRAN, so to speak, by coming up
with FP, one of the first functional programming languages
(though he called it FP system). See his 1977 Turing Award
lecture: 
  https://doi.org/10.1145%2F359576.359579

IIRC, someone had posted an interpreter for FP to
comp.sources.unix. Ah, here it is: Volume 20, Issue 50.
  https://groups.google.com/forum/#!msg/comp.sources.unix/O68WmHasQZ8/2v3_YuEbH6IJ

FP's clear inspiration was APL. It didn't succeed but it was
quite influential for the field of functional programming
languages. Though modern FPLs are lambda calculus based (Backus
thought lambda calculus was too powerful and may lead to chaos).

Backus was also involved in the design of Algol58 and Algol60,
which is where he came up with BNF. There is an ancient grammar
notation that is as least as powerful as BNF but it seems Backus
was unaware of it. [Pāṇinian rules can describe languages larger
than CFL but not as large as context sensitive languages]

[TUHS] RIP John Backus

[Nemo]

On 16/03/2018, Dave Horsfall <dave at horsfall.org> wrote:
> We lost computer pioneer John Backus on this day in 2007; amongst other
> things he gave us FORTRAN (yuck!) and BNF, which is ironic, really,
> because FORTRAN has no syntax to speak of.

Early on, I landed a job requiring VAX FORTRAN but I was not actually
conversant in it -- I told a white lie.  I saw "FORTRAN Tools for
VAX/VMS" at a local technical store and read it cover to cover.  (The
title was an intentional play on Kernighan & Plauger and built similar
tools using FORTRAN -- side topic but whatever happened to Plauger?)
Said implementation pleasantly surprised me:  nothing at all like the
primitive early versions.

N.

>
> --
> Dave Horsfall DTM (VK2KFU)  "Those who don't understand security will
> suffer."
>

[TUHS] RIP John Backus

[Charles H Sauer]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 706 bytes --]

On 3/16/2018 7:26 PM, Arthur Krewat wrote:
> On 3/16/2018 8:08 PM, Dave Horsfall wrote:
>> Dunno; I taught myself FORTRAN-II after winning a book at school 
>> (yes, really!)
>
> I taught myself Fortran after stealing a book from the library a few 
> towns over. Returned it a few years later by dropping it in the book 
> deposit.

Another book of note, /FORTRAN für Anfänger/ 
(https://link.springer.com/book/10.1007/978-3-642-96076-5), was popular 
among UT-Austin doctoral candidates in meeting the foreign language 
requirements...
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://minnie.tuhs.org/pipermail/tuhs/attachments/20180316/ddc71ce9/attachment.html>

[TUHS] RIP John Backus

[Dave Horsfall]

On Fri, 16 Mar 2018, Arthur Krewat wrote:

> I taught myself Fortran after stealing a book from the library a few 
> towns over. Returned it a few years later by dropping it in the book 
> deposit.

I forgot to mention that the other book I won (apparently I topped my 
school in Science or something, and could pick two books from a list) was 
"Business Data Processing", so I taught myself simple COBOL :-)

I lost both books in a house move, alas...

-- 
Dave Horsfall DTM (VK2KFU)  "Those who don't understand security will suffer."

[TUHS] RIP John Backus

[Arthur Krewat]

On 3/16/2018 8:08 PM, Dave Horsfall wrote:
> Dunno; I taught myself FORTRAN-II after winning a book at school (yes, 
> really!)

I taught myself Fortran after stealing a book from the library a few 
towns over. Returned it a few years later by dropping it in the book 
deposit.

[TUHS] RIP John Backus

[Dave Horsfall]

On Fri, 16 Mar 2018, Dan Stromberg wrote:

> FORTRAN isn't that bad.  F77 had too much and too little whitespace 
> significance, but from what I've heard, F90 is pretty decent.

Dunno; I taught myself FORTRAN-II after winning a book at school (yes, 
really!), and somehow ploughed through WATFOR (urk!) and WATFIV (a bit 
better) in my early CompSci classes, then was allowed to use FORTRAN-G in 
later on.

And if we promised to behave ourselves i.e. debug the program on FORTRAN-G 
first then we were allowed to use FORTRAN-H (which needed a special code 
on the JOB card, as I recall).

Never used the abomination since...

-- 
Dave Horsfall DTM (VK2KFU)  "Those who don't understand security will suffer."

[TUHS] RIP John Backus

[Dan Stromberg]

On Fri, Mar 16, 2018 at 2:52 PM, Dave Horsfall <dave at horsfall.org> wrote:
> We lost computer pioneer John Backus on this day in 2007; amongst other
> things he gave us FORTRAN (yuck!) and BNF, which is ironic, really, because
> FORTRAN has no syntax to speak of.

FORTRAN isn't that bad.  F77 had too much and too little whitespace
significance, but from what I've heard, F90 is pretty decent.

[TUHS] RIP John Backus

[Dave Horsfall]

We lost computer pioneer John Backus on this day in 2007; amongst other 
things he gave us FORTRAN (yuck!) and BNF, which is ironic, really, 
because FORTRAN has no syntax to speak of.

-- 
Dave Horsfall DTM (VK2KFU)  "Those who don't understand security will suffer."