Re: [TUHS] Happy birthday, John Backus!

Re: [TUHS] Happy birthday, John Backus!

[Noel Chiappa]

    > From: Toby Thain

    > He made amends by being early to recognise that problem, and propose
    > solutions, in his 1977 ACM Turing Award lecture

Actually, I'd consider a far bigger amend to be his work on Algol 60 (he was
one of the main contributors), which Hoare so memorably described as "a
language so far ahead of its time that it was not only an improvement on its
predecessors but also on nearly all its successors".

AFAICT, although Algol 60 itself is no longer used, basically _every_ modern
programming language (other than wierd, parallel ones, etc) is heavily
descended from Algol 60 (e.g. C, via CPL).


As for FORTRAN, it's worth recalling that it was originally for the IBM 704,
which was their very _first_ commercial computer with core memory! And not a
lot of it - early 704's came with a massive 4KW of main memory! So the
compiler had to be squeezed into _very_ small space - and it reportedly did an
excellent job of emitting efficient code (at a time when a lot of people
thought that couldn't be done, and so were hostile to the concept of writing
program in HLL). And the compiler had to be written entirely in assembler, to
boot...

Which brings up an interesting query - I wonder when/what the last compiler
written in assembler was? I gather these days compilers for new machines are
always bootstrapped as cross-compilers (an X compiler for the Y machine is
written in X, run through the X compiler for the [existing] Z machine, and
then run though itself, on the Z machine, to produce binary of itself for the
Y machine).

       Noel

Re: [TUHS] Happy birthday, John Backus!

[Clem Cole]

[-- Attachment #1: Type: text/plain, Size: 282 bytes --]

On Tue, Dec 4, 2018 at 9:43 AM Noel Chiappa <jnc@mercury.lcs.mit.edu> wrote:

>  Which brings up an interesting query - I wonder when/what the last
> compiler written in assembler was?
>
Excellent question -- IBM's Fortran-H maybe?   circa mid 1970's would be my
guess.
ᐧ

[-- Attachment #2: Type: text/html, Size: 1167 bytes --]

Re: [TUHS] Happy birthday, John Backus!

[Toby Thain]

On 2018-12-04 9:43 AM, Noel Chiappa wrote:
>     > From: Toby Thain
> 
>     > He made amends by being early to recognise that problem, and propose
>     > solutions, in his 1977 ACM Turing Award lecture
> 
> Actually, I'd consider a far bigger amend to be his work on Algol 60 (he was

Possibly, but it's far harder to unpack thesis and reasoning from a
codebase.

> one of the main contributors), which Hoare so memorably described as "a
> language so far ahead of its time that it was not only an improvement on its
> predecessors but also on nearly all its successors".
> ...
> 
>        Noel
> 

Re: [TUHS] Happy birthday, John Backus!

[Tim Rylance]

[-- Attachment #1: Type: text/plain, Size: 1054 bytes --]


> On 4 Dec 2018, at 14:53, Clem Cole <clemc@ccc.com> wrote:
> On Tue, Dec 4, 2018 at 9:43 AM Noel Chiappa <jnc@mercury.lcs.mit.edu <mailto:jnc@mercury.lcs.mit.edu>> wrote:
>  Which brings up an interesting query - I wonder when/what the last compiler written in assembler was? 
> Excellent question -- IBM's Fortran-H maybe?   circa mid 1970's would be my guess.
> ᐧ

The Fortran H compiler was mostly written in Fortran: 27,415 lines of Fortran and 16,721 lines of assembler according to slide 12 of [1].

There were some language extensions (structures and pointers) to support this, enabled by the secret compiler option XL.  They are described in Appendix J of the Program Logic Manual for the compiler [2].

The early-1980s Fortran 77 compiler for the GEC 4090 was written in Babbage, a thin PL/360-like veneer over the raw 4090 instruction set.

[1] http://booksite.elsevier.com/9780120884780/Graduate_Lecture_Slides/Core_Lectures/02FortranH.ppt

[2] http://www.bitsavers.org/pdf/ibm/360/fortran/Y28-6642-3_FortH_PLM_Nov68.pdf


[-- Attachment #2: Type: text/html, Size: 2766 bytes --]

Re: [TUHS] Happy birthday, John Backus!

[Clem Cole]

[-- Attachment #1: Type: text/plain, Size: 1033 bytes --]

On Tue, Dec 4, 2018 at 11:34 AM Tim Rylance <tuhs@tkr.bondplaza.com> wrote:

> The Fortran H compiler was mostly written in Fortran: 27,415 lines of
> Fortran and 16,721 lines of assembler according to slide 12 of [1].
>
Thanks for the pointer.      As Doug points out, Burrough's ESPOL started
the transition in the early 60s, but it took awhile for it to be something
that was done 100% of time by everyone.  The mid-70s is clearly the
transistion time - as you point out [2/3 self hosting, 1/3 assembler].    I
wonder what part was which?

Wirth wrote PL/360 to create Algol-W in the late 60s.   But York/APL (and I
believe APL/360) which were the same timeframe, were assembler [I hacked on
the former on TSS in the early/mid 70s].

The first DEC compilers for the 360 bit and 12 bit lines were written in
assembler, but they switched to BLISS (and some other languages for
different front-ends) by the 70s for the newer generations of compilers.
 Paul can give that history as he was part of it.

Clem
ᐧ

[-- Attachment #2: Type: text/html, Size: 2855 bytes --]

Re: [TUHS] Happy birthday, John Backus!

[Paul Winalski]

On 12/4/18, Clem Cole <clemc@ccc.com> wrote:
>
> The first DEC compilers for the 360 bit and 12 bit lines were written in
> assembler, but they switched to BLISS (and some other languages for
> different front-ends) by the 70s for the newer generations of compilers.
>  Paul can give that history as he was part of it.

Unfortunately I can't give much of DEC's compiler history as I was a
member of the software development tools team at the time.  I didn't
pay too much attention to what was going on with the VAX compilers.  I
moved to the compiler world in 1985 as part of the GEM compiler back
end team, which was tasked with developing a new, common back end to
replace the various VAX code generators going forward.  The compiler
guys wanted to concentrate on optimization and code generation, so
they hired me--a software development tools guy--to design and
implement the non-compiler parts of the back end such as command line
parsing, heap memory management, file I/O, and object file generation.
Over the years GEM was targeted to MIPS, PRISM, Alpha, and Itanium
machine architectures, and VMS, Unix, Linux, and Windows NT operating
systems.  We were working on x86 when Compaq sold the Alpha
architecture and its engineering team (including GEM) to Intel.  Intel
never did anything with the GEM technology.

BLISS was DEC engineering's official implementation language.
BLISS-32 was used for the VAX.  I'm pretty sure VAX Fortran, VAX
COBOL, VAX BASIC, and VAX Pascal were all written in BLISS.  They all
had their own independently developed code generators.  VAX C and VAX
PL/I were written by Dave Cutler's compiler group in the late
70s/early 80s.  They shared a common back end called the VAX Code
Generator (VCG).  I don't know what the implementation language for
VCG was; I think it was C (Dave Cutler was not a BLISS fan).  VAX PL/I
used the Frieburghouse PL/I front end, which I think was written in C.
VAX Ada was also VCG-based; the front end was written in BLISS.
VAXeln Pascal might have been written in Pascal.

All of DEC's Alpha compilers used GEM as the back end.  There was also
a VAX MACRO GEM-based compiler that took VAX assembler as its input
language and generated native Alpha code.  GEM was originally
completely written in BLISS, but in the mid-1980s I started rewriting
the modules under my control in the common subset of C/C++ to take
advantage of strong typing (BLISS has no data typing whatsoever).  DEC
C/C++ for Alpha used the Edison Design Group C/C++ front end.  DEC
acquired COMPASS's compiler technology and DEC Fortran used the
COMPASS Fortran front end to support Fortran 90.  That code is written
in C.

-Paul W.

Re: [TUHS] Happy birthday, John Backus!

[Paul Winalski]

On 12/4/18, Paul Winalski <paul.winalski@gmail.com> wrote:
>
> Over the years GEM was targeted to MIPS, PRISM, Alpha, and Itanium
> machine architectures, and VMS, Unix, Linux, and Windows NT operating
> systems.  We were working on x86 when Compaq sold the Alpha
> architecture and its engineering team (including GEM) to Intel.

I forgot one:  Tandem NonStop OS on Alpha, which was under development
at Compaq at the time that Compaq decided to sell off the Alpha
technology to Intel.  The Tandem stuff was retargeted to Itanium.  We
GEM folks lost track of Tandem at that time, so I don't know what back
end HP is using for the NonStop on Itanium product.

-Paul W.

[TUHS] Tandem NSK implementation language (was: Happy birthday, John Backus!)

[Greg 'groggy' Lehey]

[-- Attachment #1: Type: text/plain, Size: 1524 bytes --]

On Tuesday,  4 December 2018 at 15:59:46 -0500, Paul Winalski wrote:
> On 12/4/18, Paul Winalski <paul.winalski@gmail.com> wrote:
>>
>> Over the years GEM was targeted to MIPS, PRISM, Alpha, and Itanium
>> machine architectures, and VMS, Unix, Linux, and Windows NT operating
>> systems.  We were working on x86 when Compaq sold the Alpha
>> architecture and its engineering team (including GEM) to Intel.
>
> I forgot one:  Tandem NonStop OS on Alpha, which was under development
> at Compaq at the time that Compaq decided to sell off the Alpha
> technology to Intel.

Was this a start-from-scratch operation?  The original Tandem OS
(called Guardian at the time) was written in Tandem's TAL (Transaction
Application Language, amongst other productions), a vague evolution of
HP's SPL that looked more like Algol, starting in about 1974.  That is
also the earliest I know of an operating system being implemented
entirely in a high level language.

When Tandem started using other architectures (MIPS) in the late 1980s
we discussed translating the whole thing to C.  I was asked to write a
99% translator (maintaining comments and such), and failed.

I lost track of the system after that, but it seems surprising that
they would have started again from scratch.

Greg
--
Sent from my desktop computer.
Finger grog@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

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 163 bytes --]

Re: [TUHS] Tandem NSK implementation language (was: Happy birthday, John Backus!)

[Paul Winalski]

On 12/4/18, Greg 'groggy' Lehey <grog@lemis.com> wrote:
> On Tuesday,  4 December 2018 at 15:59:46 -0500, Paul Winalski wrote:
>>
>> I forgot one:  Tandem NonStop OS on Alpha, which was under development
>> at Compaq at the time that Compaq decided to sell off the Alpha
>> technology to Intel.
>
> Was this a start-from-scratch operation?  The original Tandem OS
> (called Guardian at the time) was written in Tandem's TAL (Transaction
> Application Language, amongst other productions), a vague evolution of
> HP's SPL that looked more like Algol, starting in about 1974.  That is
> also the earliest I know of an operating system being implemented
> entirely in a high level language.

No, not start-from-scratch.  They modified the existing MIPS TAL front
end to generate GEM intermediate language.  I don't know if the TAL
front end generated GEM IL directly or if they wrote some sort of
IL-to-IL translator wedge.  IIRC we didn't need to do any object file
work in GEM to support Tandem because they were already using an
object file format we supported (ELF or COFF).

> When Tandem started using other architectures (MIPS) in the late 1980s
> we discussed translating the whole thing to C.  I was asked to write a
> 99% translator (maintaining comments and such), and failed.

IIRC some of the Tandem code was in C at this point (1999) but a TAL
for Alpha was also needed.

-Paul W.

Re: [TUHS] Happy birthday, John Backus!

[Paul Winalski]

On 12/4/18, Paul Winalski <paul.winalski@gmail.com> wrote:
>
> GEM was originally
> completely written in BLISS, but in the mid-1980s I started rewriting
> the modules under my control in the common subset of C/C++ to take
> advantage of strong typing (BLISS has no data typing whatsoever).

Typo.  I meant to say "mid-1990s".

-Paul W.

Re: [TUHS] Happy birthday, John Backus!

[Clem Cole]

[-- Attachment #1: Type: text/plain, Size: 1686 bytes --]

As I said, I'm an OS type, I just sit near a number of compiler folks and
have been known to eat lunch with them - so I'm not aware of any that.
Unfortunately, about a month ago we lost the guy to ask about it (the late
Stan Whitlock), who was secretary of the Fortran standards committee for
about 30 years.   I'll try to ask Eklund and Grove (who are both retired
but I still see socially on occasion) what they remember about F and if I
learn anything I'll pass it back here.

Clem


ᐧ

On Tue, Dec 4, 2018 at 6:53 AM Tony Finch <dot@dotat.at> wrote:

> Clem Cole <clemc@ccc.com> wrote:
>
> > Fortran2018 (which was release just last week BTW) is hardly the
> language I
> > learned in the early 1970s (Fortran-IV) or my father a dozen or so years
> > previous to me.
>
> One of the more obscure books I have is about "the F programming language"
> http://www.fortran.com/F/ which is the modern subset of Fortran 95. A
> curious thing about F is that it doesn't include DO WHILE; my
> understanding is that there was a faction of the Fortran standardization
> committee which was firmly against WHILE, and that was the faction that
> defined the F subset.
>
> I can't now find any information about this argument / controversy, but my
> link archive includes https://dl.acm.org/citation.cfm?doid=800168.811545
> Brenda Baker's paper on converting Fortran IV programs to ratfor.
>
> Tony.
> --
> f.anthony.n.finch  <dot@dotat.at>  http://dotat.at/
> Irish Sea: Southwest 5, backing east, then becoming cyclonic later, 5 to 7,
> perhaps gale 8 later. Slight or moderate, occasionally rough later. Rain or
> showers. Good, occasionally poor.
>

[-- Attachment #2: Type: text/html, Size: 3057 bytes --]

Re: [TUHS] Happy birthday, John Backus!

[Tony Finch]

Clem Cole <clemc@ccc.com> wrote:

> Fortran2018 (which was release just last week BTW) is hardly the language I
> learned in the early 1970s (Fortran-IV) or my father a dozen or so years
> previous to me.

One of the more obscure books I have is about "the F programming language"
http://www.fortran.com/F/ which is the modern subset of Fortran 95. A
curious thing about F is that it doesn't include DO WHILE; my
understanding is that there was a faction of the Fortran standardization
committee which was firmly against WHILE, and that was the faction that
defined the F subset.

I can't now find any information about this argument / controversy, but my
link archive includes https://dl.acm.org/citation.cfm?doid=800168.811545
Brenda Baker's paper on converting Fortran IV programs to ratfor.

Tony.
-- 
f.anthony.n.finch  <dot@dotat.at>  http://dotat.at/
Irish Sea: Southwest 5, backing east, then becoming cyclonic later, 5 to 7,
perhaps gale 8 later. Slight or moderate, occasionally rough later. Rain or
showers. Good, occasionally poor.

Re: [TUHS] Happy birthday, John Backus!

[Lawrence Stewart]

I’ve told this story before, but not here, I think.

Brian Reid talked me into teaching a programming language survey course at Stanford around 1983.  There were programming assignments in Pascal, LISP, APL, and Snobol.

Being young and too clever, I rewrote the Snobol assignment to be matching lists of crossword puzzle solution words for across and down into a grid representing the board (X’s and O’s).

I seriously underestimated how hard this would be for new programmers, so my own solution turned out to be the second fastest.

The fastest Snobol solution was a thing that if you held it out at arms length, you would swear it was FORTRAN.

-L

> On 2018, Dec 3, at 5:24 PM, Paul Winalski <paul.winalski@gmail.com> wrote:
> 
> On 12/3/18, Clem Cole <clemc@ccc.com> wrote:
>> 
>> Hrrumft.    You can write bad code is *any* language.   See the annual
>> obscure C prize.
> 
> Someone once said that a good Fortran programmer can write Fortran in
> any programming language.
> 
> -Paul W.

Re: [TUHS] Happy birthday, John Backus!

[ron]

[-- Attachment #1: Type: text/plain, Size: 259 bytes --]

You also had a unique insight into LISP (what CAR and CDR really mean).

 

 

If you understood the architecture and instruction set of the IBM 709/7090/7094 series (I cut my programming teeth on the 7094), you understood the "quirks" of Fortan




[-- Attachment #2: Type: text/html, Size: 2703 bytes --]

Re: [TUHS] Happy birthday, John Backus!

[Paul Winalski]

On 12/3/18, Clem Cole <clemc@ccc.com> wrote:
>
> Hrrumft.    You can write bad code is *any* language.   See the annual
> obscure C prize.

Someone once said that a good Fortran programmer can write Fortran in
any programming language.

-Paul W.

Re: [TUHS] Happy birthday, John Backus!

[Hellwig Geisse]

On Mo, 2018-12-03 at 15:20 -0500, Paul Winalski wrote:
> Of course one can write a grammar for Fortran using a formal system
> such as BNF.  It's just not going to be a well-behaved context-free
> grammar such as one can do for C or Pascal, and you won't be able to
> feed the grammar to lex and yacc, press a button, and have a compiler
> pop out. 

This in fact also isn't possible for C because of the "typedef problem".
See for example here:

http://eli.thegreenplace.net/2007/11/24/the-context-sensitivity-of-cs-grammar

Hellwig

Re: [TUHS] Happy birthday, John Backus!

[Clem Cole]

[-- Attachment #1: Type: text/plain, Size: 1685 bytes --]

On Mon, Dec 3, 2018 at 3:21 PM Paul Winalski <paul.winalski@gmail.com>
wrote:

> Fortran was being devised at the same time that Chomsky, et.
> al. were doing the research on formal languages.  Essentially, Fortran
> syntax was devised before computer scientists knew better.  I suspect
> COBOL has similar issues.
>
I agree.  I think you nailed about "not knowing any better.'   And it
really is amazing how well it has endured.  Like a lot of things, the first
guys do make errors because they really have not yet eccounter the longer
term issues - they are just trying to solve the problem they had in front
of them.  On another fron, just think the issues in networking that were
made in the 70s.  Same thing.   But IP/TCP works and works really well and
has endured.

You folks in the compiler team and in particular the Fortran crew, did a
great job over the years.   I used to kid your boss asking of there were
Fortran developers than customers in our DEC days; but all kidding aside. And
he knew I knew.  I have always respected those folks.   As I said, they
paid my salary for so many years.

I think it's sad we don't teach Fortran to 'modern' programmers in a
comparitive languages class.   The students should know what is good, why
it has lasted and marvel at what a wonder system people devised in the late
1950s and how well Computer Scientists have over the next 60 years kept it
strong and relevant.  Then you can teach them, Rust, Go or whatever the
cool kids think are hot and important.    Ask them all, why do we think
this languages will or will not last (and the end, it will be economics but
that's another thread).

Clem
ᐧ

[-- Attachment #2: Type: text/html, Size: 3568 bytes --]

Re: [TUHS] Happy birthday, John Backus!

[Paul Winalski]

I replied in detail to the child thread on it being impossible to
devise a formal grammar for Fortran before I saw this one (its
parent).

Of course one can write a grammar for Fortran using a formal system
such as BNF.  It's just not going to be a well-behaved context-free
grammar such as one can do for C or Pascal, and you won't be able to
feed the grammar to lex and yacc, press a button, and have a compiler
pop out.  Fortran was being devised at the same time that Chomsky, et.
al. were doing the research on formal languages.  Essentially, Fortran
syntax was devised before computer scientists knew better.  I suspect
COBOL has similar issues.

-Paul W.

Re: [TUHS] Happy birthday, John Backus!

[Clem Cole]

[-- Attachment #1: Type: text/plain, Size: 5923 bytes --]

On Sun, Dec 2, 2018 at 5:18 PM Dave Horsfall <dave@horsfall.org> wrote:

> Yeah, it was a nice language at the time; the engineers loved it,

Dave at this risk of piling-on, I feel like to I need to comment because
while I personally to not use it, my customers do.  It's still an excellent
tool, and the reality is that Fortran has pretty much paid my salary for
almost every computer firm I have worked since I left grad school.   That's
5 start-ups and too many large firms to count.
Fortran2018 (which was release just last week BTW) is hardly the language I
learned in the early 1970s (Fortran-IV) or my father a dozen or so years
previous to me.  Knocking modern Fortran is sort of like saying, "Any
vehicle that is made by Ford sucks because the Model T was not as good as
what we can do today."  I fear your are making statements about Fortran-2 -
maybe 77 or even 90.   But the language is niether dead nor useless.
 Check out an answer I did for quora last summer:  Clem Cole's answer to Is
the future of Fortran Programming Dead
<https://www.quora.com/Is-the-future-of-Fortran-programming-dead/answer/Clem-Cole>

I also point out, if you watch the nightly news on TV, you are using
Fortran.  Pretty much, all the weather data internationally is crunched on
Fortran codes.  The same is true for most 'large science.'   As for why we
will still use it is that *the work (the math) has not changed (If it ain’t
broke, don’t fix it). And most importantly, history has shown that it has
never been economically interesting to bother (or at least so far).*   Please
read my Quora answers to see a much more detailed analysis of that
statement.


> but tthe computer scientists hated it

I get it.   But ... at least we were taught it.  I'm saddened to say my
fairly recent CS major daughter was never shown it in her days in college.
In a funny twist of fate, her grandfather (my Dad) was taught Fortran in
1958 at a course at her college (Carleton) via an NSF grant.

As I have said elsewhere, in the 70's the CMU CS Dept, was arguing with the
Engineering school.   In those days, the CS Dept said, "Fortran was dead."
 But like the Phoenix, it is seems to get be getting more beautiful and
stronger with each reincarnation.



> (have you ever tried to debug a FORTRAN program that somebody else wrote?).

Hrrumft.    You can write bad code is *any* language.   See the annual
obscure C prize.   FWIW:  This little gem is legal Fortran-IV.   The last
time I compiled it on my Mac, a Fortran2013 draft comforming compiler, Intel
Fortran's  ifort, will accept thios deck also with no special switches
BTW.  That said, the last time I checked it on my Mac, ifort generated
incorrect code (it was reported as a bug, I'm not sure of the status of the
fix and I have not updated the compiler since last summer):

C    This FORTRAN program 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:
C
      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



The output should be something like this:
                           1
                         1   1
                       1   2   1
                     1   3   3   1
                   1   4   6   4   1
                 1   5  10  10   5   1
               1   6  15  20  15   6   1
             1   7  21  35  35  21   7   1
           1   8  28  56  70  56  28   8   1
         1   9  36  84 126 126  84  36   9   1
       1  10  45 120 210 252 210 120  45  10   1
     1  11  55 165 330 462 462 330 165  55  11   1
   1  12  66 220 495 792 924 792 495 220  66  12   1




I admit, I'm glad I'm not a compiler writer.   But they do have an amazing
product that is very useful to a lot of people and still quite popular.
BTW:  Here is the same program, in a bit more readable form:

      PROGRAM BLOCK
      INTEGER I1,I2,I3,I4,I5
      DIMENSION I1(13),I2(13)
      I4=1
      I5=2
      I3=13
      CALL PASCAL(I1,I2,I3,I4,I5)
      END

      SUBROUTINE PASCAL(IP1,IP2,IP3,IP4,IP5)
      INTEGER IP3,IP1(IP3),IP2(IP3),IP4,IP5
      INTEGER IP6,IP7
      DO IP6=IP4,IP3
         DO IP7=IP5,IP6-IP4
            IP1(IP7)=IP2(IP7)+IP2(IP7-IP4)
         ENDDO
         IP1(IP4)=IP4
         IP1(IP6)=IP4
         DO IP7=IP4,IP3-IP6
            WRITE(*,'("  "$)')
         ENDDO
         DO IP7=IP4,IP6
            WRITE(*,'(I4$)') IP1(IP7)
         ENDDO
         WRITE(*,*)
         DO IP7=IP4,IP3
            IP2(IP7)=IP1(IP7)
         ENDDO
      ENDDO
      END



ᐧ

[-- Attachment #2: Type: text/html, Size: 16442 bytes --]

Re: [TUHS] Happy birthday, John Backus!

[John P. Linderman]

[-- Attachment #1: Type: text/plain, Size: 2089 bytes --]

If you understood the architecture and instruction set of the IBM
709/7090/7094 series (I cut my programming teeth on the 7094), you
understood the "quirks" of Fortan: three way branches, indexing arrays in
reverse order, always executing a loop at least once, etc. Fortran
"tricked" the writer into producing code that worked well on those
machines, but was much easier to understand and modify than assembler. Not
all that different from C and DEC boxes, but the IBM machines were less
coherent.

On Sun, Dec 2, 2018 at 11:29 PM Rob Pike <robpike@gmail.com> wrote:

> To the author of the first message, the one who called Fortran an
> "obscenity".
>
> -rob
>
>
> On Mon, Dec 3, 2018 at 3:11 PM Toby Thain <toby@telegraphics.com.au>
> wrote:
>
>> On 2018-12-02 8:32 PM, Rob Pike wrote:
>> > Fortran was a marvel. Don't judge it by today's ideas about language
>> design.
>>
>> The 1977 lecture was by John Backus, not me, so I'm confused who that's
>> directed at.
>>
>> >
>> > -rob
>> >
>> >
>> > On Mon, Dec 3, 2018 at 9:34 AM Toby Thain <toby@telegraphics.com.au
>> > <mailto:toby@telegraphics.com.au>> wrote:
>> >
>> >     On 2018-12-02 5:17 PM, Dave Horsfall wrote:
>> >     > As every computer programmer should know, John Backus was emitted
>> in
>> >     > 1924; he gave us the BNF syntax (he is the "B"), but he also gave
>> us
>> >     > that FORTRAN obscenity...  Yeah, it was a nice language at the
>> >     time; the
>> >     > engineers loved it, but tthe computer scientists hated it (have
>> >     you ever
>> >     > tried to debug a FORTRAN program that somebody else wrote?).
>> >
>> >     He made amends by being early to recognise that problem, and propose
>> >     solutions, in his 1977 ACM Turing Award lecture (still perfectly
>> >     relevant today):
>> >
>> >
>> https://www.thocp.net/biographies/papers/backus_turingaward_lecture.pdf
>> >
>> >     --Toby
>> >
>> >
>> >
>> >     >
>> >     > Trivia: there is no way that FORTRAN can be described in any
>> >     syntax; it
>> >     > is completely ad-hoc.
>> >     >
>> >     > -- Dave
>> >     >
>> >
>>
>>

[-- Attachment #2: Type: text/html, Size: 3266 bytes --]

Re: [TUHS] Happy birthday, John Backus!

[Rob Pike]

[-- Attachment #1: Type: text/plain, Size: 1461 bytes --]

To the author of the first message, the one who called Fortran an
"obscenity".

-rob


On Mon, Dec 3, 2018 at 3:11 PM Toby Thain <toby@telegraphics.com.au> wrote:

> On 2018-12-02 8:32 PM, Rob Pike wrote:
> > Fortran was a marvel. Don't judge it by today's ideas about language
> design.
>
> The 1977 lecture was by John Backus, not me, so I'm confused who that's
> directed at.
>
> >
> > -rob
> >
> >
> > On Mon, Dec 3, 2018 at 9:34 AM Toby Thain <toby@telegraphics.com.au
> > <mailto:toby@telegraphics.com.au>> wrote:
> >
> >     On 2018-12-02 5:17 PM, Dave Horsfall wrote:
> >     > As every computer programmer should know, John Backus was emitted
> in
> >     > 1924; he gave us the BNF syntax (he is the "B"), but he also gave
> us
> >     > that FORTRAN obscenity...  Yeah, it was a nice language at the
> >     time; the
> >     > engineers loved it, but tthe computer scientists hated it (have
> >     you ever
> >     > tried to debug a FORTRAN program that somebody else wrote?).
> >
> >     He made amends by being early to recognise that problem, and propose
> >     solutions, in his 1977 ACM Turing Award lecture (still perfectly
> >     relevant today):
> >
> >
> https://www.thocp.net/biographies/papers/backus_turingaward_lecture.pdf
> >
> >     --Toby
> >
> >
> >
> >     >
> >     > Trivia: there is no way that FORTRAN can be described in any
> >     syntax; it
> >     > is completely ad-hoc.
> >     >
> >     > -- Dave
> >     >
> >
>
>

[-- Attachment #2: Type: text/html, Size: 2366 bytes --]

Re: [TUHS] Happy birthday, John Backus!

[Toby Thain]

On 2018-12-02 8:32 PM, Rob Pike wrote:
> Fortran was a marvel. Don't judge it by today's ideas about language design.

The 1977 lecture was by John Backus, not me, so I'm confused who that's
directed at.

> 
> -rob
> 
> 
> On Mon, Dec 3, 2018 at 9:34 AM Toby Thain <toby@telegraphics.com.au
> <mailto:toby@telegraphics.com.au>> wrote:
> 
>     On 2018-12-02 5:17 PM, Dave Horsfall wrote:
>     > As every computer programmer should know, John Backus was emitted in
>     > 1924; he gave us the BNF syntax (he is the "B"), but he also gave us
>     > that FORTRAN obscenity...  Yeah, it was a nice language at the
>     time; the
>     > engineers loved it, but tthe computer scientists hated it (have
>     you ever
>     > tried to debug a FORTRAN program that somebody else wrote?).
> 
>     He made amends by being early to recognise that problem, and propose
>     solutions, in his 1977 ACM Turing Award lecture (still perfectly
>     relevant today):
> 
>     https://www.thocp.net/biographies/papers/backus_turingaward_lecture.pdf
> 
>     --Toby
> 
> 
> 
>     >
>     > Trivia: there is no way that FORTRAN can be described in any
>     syntax; it
>     > is completely ad-hoc.
>     >
>     > -- Dave
>     >
> 

Re: [TUHS] Happy birthday, John Backus!

[Rob Pike]

[-- Attachment #1: Type: text/plain, Size: 955 bytes --]

Fortran was a marvel. Don't judge it by today's ideas about language design.

-rob


On Mon, Dec 3, 2018 at 9:34 AM Toby Thain <toby@telegraphics.com.au> wrote:

> On 2018-12-02 5:17 PM, Dave Horsfall wrote:
> > As every computer programmer should know, John Backus was emitted in
> > 1924; he gave us the BNF syntax (he is the "B"), but he also gave us
> > that FORTRAN obscenity...  Yeah, it was a nice language at the time; the
> > engineers loved it, but tthe computer scientists hated it (have you ever
> > tried to debug a FORTRAN program that somebody else wrote?).
>
> He made amends by being early to recognise that problem, and propose
> solutions, in his 1977 ACM Turing Award lecture (still perfectly
> relevant today):
>
> https://www.thocp.net/biographies/papers/backus_turingaward_lecture.pdf
>
> --Toby
>
>
>
> >
> > Trivia: there is no way that FORTRAN can be described in any syntax; it
> > is completely ad-hoc.
> >
> > -- Dave
> >
>
>

[-- Attachment #2: Type: text/html, Size: 1490 bytes --]

Re: [TUHS] Happy birthday, John Backus!

[Toby Thain]

On 2018-12-02 5:17 PM, Dave Horsfall wrote:
> As every computer programmer should know, John Backus was emitted in
> 1924; he gave us the BNF syntax (he is the "B"), but he also gave us
> that FORTRAN obscenity...  Yeah, it was a nice language at the time; the
> engineers loved it, but tthe computer scientists hated it (have you ever
> tried to debug a FORTRAN program that somebody else wrote?).

He made amends by being early to recognise that problem, and propose
solutions, in his 1977 ACM Turing Award lecture (still perfectly
relevant today):

https://www.thocp.net/biographies/papers/backus_turingaward_lecture.pdf

--Toby



> 
> Trivia: there is no way that FORTRAN can be described in any syntax; it
> is completely ad-hoc.
> 
> -- Dave
> 

[TUHS] Happy birthday, John Backus!

[Dave Horsfall]

As every computer programmer should know, John Backus was emitted in 1924; 
he gave us the BNF syntax (he is the "B"), but he also gave us that 
FORTRAN obscenity...  Yeah, it was a nice language at the time; the 
engineers loved it, but tthe computer scientists hated it (have you ever 
tried to debug a FORTRAN program that somebody else wrote?).

Trivia: there is no way that FORTRAN can be described in any syntax; it is 
completely ad-hoc.

-- Dave