Elliott 803C - a model 503 in disguise

In a post to alt.folklore.computers it was claimed that the Elliott 803C (note the C designation) models could be upgraded in the field to a Model 503 with a simple change and a bill for several thousand dollars (or pounds?). Apparently, the model 803C was actually a model 503 suitably badged and operating at a lower speed.

From: b...@dsl.co.uk (Brian {Hamilton Kelly})

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.)

FORTRAN to ALGOL translator FEAT

AIUI, when the University of New South Wales (I think: it was certainly an Oz uni) bought anElliott 503, the contract stipulated that Elliott Brothers (London) Ltd should supply a compiler for Fortran. Now Elliotts had never bothered with Fortran; as to HLLs, the 803/503 series came with Elliott Autocode (NOT to be confused with another manufacturer's Autocoder) and Algol60.

I believe that CAP were contracted to provide a means of translating Fortran to Algol60, and this was acceptable to UNSW.

NW - No record found of UNSW receiving an Elliott 503, so this could be UTAS (University of Tasmania)

Who designed the 803 and the 503?

In Barron's court - IEE Review (1997),43(1):29

Iann Barron (IB), the inventor of the transputer, designed the Elliott 803 and 503.

"IB worked at Elliott Automation during his university vacations ...in his third year as an undergraduate he was asked to design the architecture of a new computer. Within six weeks he'd produced the design of what was subsequently marketed as the Elliott 803. -one of the most sucessful ...250 were sold ... and during the 1960s, dominated the UK university computing departments.

The article also mentions that Iann Barron also designed the 503 computer made by Elliott Automation.

Elliott ALGOL compiler internals and origin

NW - This next mesage from BHK is subsequently disputed with respect to the comment about the Algol compiler generating machine code or an intermediate code "interpreted" by the runtime (tape 2). Another poster suggests it could be in the form of threaded code (ala PDP-11), the generated code is a series of pointers into the runtime. Examination of the 503 Algol compiler may reveal what is actually happening. Also disputed is who wrote the compiler, since Tony Hoare and his team of two others are credited with developing one of the compilers - at this stage we do not know how many Algol compilers existed, the number stands at between one and three - one compiler developed for the 803, another developed for the 503, and possibly another developed for the 903 and back-ported for the 803.

From: b...@dsl.co.uk (Brian {Hamilton Kelly})

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.