Subject: Re: Elliott 503/803/903 - languages?
Date: 2000/06/04
Organization: Dragonhill Systems Ltd
Newsgroups: alt.folklore.computers

In article <8gv2qn$8q...@nnrp1.deja.com> e_erpeld...@hotmail.com  writes:

> The 803 had no operating system! It was a paper tape oriented
> computer, the operator had to setup the paper tape reader for
> each user program. The 503 might have had some sort of "Time
> Sharing" software available.

I don't think so: from the programmer's viewpoint, apart from different
peripherals, the 803 and 503 were identical.

Indeed, late in the life of the 803, Elliotts introduced the 803C, which
was an 803 that could use the 503's peripherals.  Not only that, but it
was "field upgradeable" to a 503.  The upgrade, for which the customer
paid a few tens of thousands of pounds, consisted of an engineer coming
along and snipping some link which had hitherto been slugging the clock
speed.  Talk about "the golden rivet" :-)

(To be fair, initially the 803C and the 503 were different computers;
later in the manufacturing cycle, it was easier for them to build a 503,
but ship it as an 803C.)

> The 503 and 903 each had their own "Symbolic Assembly" programme.

That for the 903 was called SIR --- Symbolic Input Routine.
  
Mind you, they never had mnemonic op-codes; one had to remember to write
4 in the opcode field to "load the A-reg from memory", or 11 to "store
the B-reg in memory", etc.  Address arithmetic was limited to +/- offsets
from a symbol: nothing fancy like multiplication!

The successor to this, which was much more of what people nowadays would
call an assembler did something extremely clever, which I cannot recall
ever hearing of being used elsewhere --- the assembled object code was to
be wound up *backwards* as it came out of the paper tape punch.  Thus all
forward references became backwards ones, and the symbol table could be
the first thing read in by the linker.  This gave a powerful one-pass
assembler.

> I don't know if the 803 had one. 

T22, of course :-)  Anyone else remember "the library"?

>                                  Elliott Algol seems to be the
> language most often associated with these computers, although
> other languages were available.

Elliott Algol was a realization of Randle & Russell's "Algol 60
Implementation", written for them by CAP (Computer Analysts and
Programmers, the software house[1] founded by Alex d'Agapeyeff).  As
such, it was a translator-interpreter system.  On an 803, there was
enough storage (except for large programs) for the translator and
interpreter to remain resident, along with the intercode.  But for large
programs, the latter was allowed to overwrite the translator.  Of course,
one could also load the interpreter alone, along with the translated
intercode form of the source.

On the 903, there wasn't sufficient space (the disadvantage of an 18-bit
machine compared to a 39-bit one), so the translator read the Algol60
source and punched out the intercode on tape, and then the latter was
read in by the interpreter after the latter had been loaded.

> > The sources to the compilers would always be nice. :)
> >
> 
> The source tapes for Elliott Algol are probably long gone, or
> else hidden in one of the original programmers files somewhere!

GEC released the entire sources of all 900-series programs to the ECUA; I
remember spending eighteen months cataloguing the contents of a few dozen
teachests.  They then went back to "safe storage", although for the life
of me I cannot remember where.  I *do* remember both Don Hunter and Terry
Froggatt asking for copies of the sources to various things.

> In the future, someone might disassemble the Elliott Algol
> binary tapes to see how it worked.

BTDT; wrote my own disassembler for the 903, and then spent a year or so
working out what was going on (this was about ten years before the
sources were released to the user association).

One amusing artefact of the code: there was some sort of look-up table at
(decimal) address 6317.  This was quite heavily[2] accessed at many parts
of the program, so the latter was spattered with the instruction:
    /4 6317  ; Pick up word indexed by B-reg from the table

Naturally, when I wrote my disassembler, it had to be able to interpret
the contents of each 18-bit words as either an instruction, or an
integer, or as characters (each word held three 6-bit characters), so it
output all three formats across the line for each location.  It just so
happens that the bit pattern for the above instruction is the same as for
the three characters "IBM", so when I first started reading the program I
was puzzled by these constant references to a competitor!

> Elliott Automation was absorbed into a company that latter became
> ICL, which I believe now is owned by Fujitsu. I think the 4100
> series of computers followed the 803, 503 and 903 computers.

Correct.  Lovely architecture, the 4120/4130.

[1] I don't believe the epithet "software house" had been invented in
those days :-)
[2] I cannot remember now what for, and have had to "reconstruct" this
story from what it was that I discovered.
-- 
Brian {Hamilton Kelly}                                          b...@dsl.co.uk
    "We have gone from a world of concentrated knowledge and wisdom to one of
    distributed ignorance.  And we know and understand less while being incr-
    easingly capable."                          Prof. Peter Cochrane, BT Labs

More detail: Elliott 803 ALGOL

Found in "Reurrection" - The Bulletin of the Computer Conservation Society

Volume 1 number 4, Summer 1992

            The design of the Algol compiler for the Elliott 803 presented 
            a  different set of problems, described by Jeff Hillmore. Late 
            in 1960 a  small group from Elliott went to an Algol 
            Conference run by  Dijkstra -- that man again. They returned 
            determined to make Algol 60 the   advanced  programming 
            language for the 803. A development team was formed, and  
            Hillmore joined it in November 1961.

            The team worked with some despatch. The first program was 
            compiled and  run just three months later, on 15 February 
            1962. Version 1 of the  compiler, using five-hole paper tape 
            input/output, was available by  November. The time taken to 
            reach that point, which included writing the  user manual, was 
            eight person-years.

            "The 803 sold to a lot of educational establishments and to 
            scientific users, and in both of these areas there was a need 
            to process a high  average number of programs in a given 
            period, and to reduce to a minimum  the time spent in changing 
            over from one program to another.

            "So the design decisions that were made were, first of all, 
            the system  should be a load-and-go system. You should, at the 
            start of a session,  load the compiler, load the dynamic 
            routines and the process, compile  and run program after 
            program.

            "The other decision that was made was that the user's program 
            should run  at the full speed of the machine. So we wanted a 
            compiler that would  generate an object program in binary 
            machine code which would then run,  and we didn't want to 
            interpret them. This was a very different decision  to that 
            made by the KDF9 people.

            "The other decision was that the source text should be read 
            once only.  So we ended up with a compiler which was designed 
            to operate in two  phases. The compiler converted the Algol 
            source to an intermediate  binary stream which we called Own 
            Code, and this was processed in the  second internal pass into 
            a binary object program, and that was then  executed at full 
            speed."

            Hillmore identified six activities in the compiler writing 
            process.  First there was the writing of a lexicon analyser to 
            tokenise the Algol  symbols, taking the hardware 
            representation and generating these tokens,  which made the 
            compiler independent of how the program was input.

            Next came the dictionary system for recording identifiers and 
            their properties. Then the team decided how the memory space 
            was going to be allocated. Fourth, they specified the own code 
            format. "Out of those  four parts of the initial activity came 
            the definition of the Algol 60  subset which would be 
            implemented".

            The final two activities were the specification of the I/O 
            definition  and the writing of a high level pseudo-Algol 
            definition of the compiler.