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!

[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!

[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] Tandem NSK implementation language (was: Happy birthday, John Backus!)

[Paul McJones]

> On Dec 4, 2018, Greg 'groggy' Lehey <grog@lemis.com> wrote:
> 
> 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.

Most likely the earliest operating system written in a high-level language was the one for the Burroughs B5000 (early 1960s), written in a dialect of Algol 60. Others: Multics, written in PL/1 (starting in mid 1960s), the  operating system for the Berkeley Computer Corporation’s BCC-500, written in BCC SPL (system programming language) (late 1960s), OS6 by Stoy and Strachey, written in BCPL (early 1970s), Xerox Alto OS, written in BCPL (about 1974).

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

[Dr Iain Maoileoin]

> On 5 Dec 2018, at 04:48, Paul McJones <paul@mcjones.org> wrote:
> 
>> On Dec 4, 2018, Greg 'groggy' Lehey <grog@lemis.com> wrote:
>> 
>> 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.
> 
> Most likely the earliest operating system written in a high-level language was the one for the Burroughs B5000 (early 1960s), written in a dialect of Algol 60. Others: Multics, written in PL/1 (starting in mid 1960s), the  operating system for the Berkeley Computer Corporation’s BCC-500, written in BCC SPL (system programming language) (late 1960s), OS6 by Stoy and Strachey, written in BCPL (early 1970s), Xerox Alto OS, written in BCPL (about 1974).
> 

About 1972 the Department of Computer Science at Strathclyde University in Scotland had an operating system implemented on a front-end-processor (Icant remember the make)  that allowed the submission and control of jobs to a “mainframe” - an ICL 1904s.
The operating system was written in STAB - a language initially designed and developed by Professor Andrew Colin - and loosely modelled on BCPL.

My memory is that the FEP was about 12 19” racks, it supported about 15-20 users and did not lose your files terribly often ;-)

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

[Clem Cole]

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

Paul beat me to it.. HP's SPL and Tandem's TAL were old news by then ...
In fact the HP's 3000's and HP 9000's stack architecture was model from the
B5000, see below...

On Wed, Dec 5, 2018 at 12:35 AM Paul McJones <paul@mcjones.org> wrote:

> > On Dec 4, 2018, Greg 'groggy' Lehey <grog@lemis.com> wrote:
> >
> > 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.
>
> Most likely the earliest operating system written in a high-level language
> was the one for the Burroughs B5000 (early 1960s), written in a dialect of
> Algol 60.

Called Executive Systems Problem Oriented Language or ESPOL
<https://en.wikipedia.org/wiki/Executive_Systems_Problem_Oriented_Language>.
 A later edition (66/67 time frame) of the reference manual for the 5500
can be found on bitsavers as: ESPOL B5500 Reference Manual 1967
<http://bitsavers.org/pdf/burroughs/B5000_5500_5700/1032638_B5500_ESPOL_RefManOct67.pdf>
ᐧ

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