By
Luigi Logrippo
January
2007
The Olivetti
Elea 9003 was the first industrial electronic computer made in
The
Although
it has been claimed that this was the first fully transistorized industrial
computer in the world, a quick search on the web will show that in fact it was
only among the first. IBM had announced a fully transistorized system
The
computer memory was organized in characters of six bits each. So there were
sixty-four possible characters. One ‘peculiar’ characteristic was that the binary
encoding of numeric characters was not the usual one: e.g. 2 was 000011, 3 was
000111 (see programmer’s reference card).
Of
course, neither multiprogramming, nor dynamic memory allocation or paging had
been invented so each program would be loaded contiguously always at the same
memory location, and would be the only program in memory during its execution.
Memory
size could go from 20K to 160K characters, with typical sizes around 40K. The
CPU had an accumulator register of the capacity of 100 characters, which was
the main operating register of the programming logic, as well as up to 40
additional registers, called T registers, each of the capacity of 5 characters.
These were mostly used as base registers, see below, although they could be
used to store and operate on any small values.
All the
instructions were of eight characters. Most instructions were of the form:
LL IIII T O
Where: LL
was the length, the number of memory characters affected by the instruction,
IIII were four characters of address in memory (I stands for Indirizzo in
Italian), T was the address of a base register whose contents was to be added
to the address IIII, O was the op code.
For example,
the instruction:
12 3456
would
take 12 characters starting from the address (3456 + contents of register 7)
and move (copy) them to the accumulator register. So if the current content of the
register 7 was 50, the characters in the memory positions 3506, 3505… to 3495
would be moved.
Many
instructions were based on the use of the accumulator register. There were
instructions to add, subtract, compare the content of the accumulator register
to or with the content of memory positions. There were of course jump
instructions and some instructions that operated directly between memory
locations. There were instructions to modify the contents of the registers. The
list of all instructions is given in the programmer’s
reference card.
There
were no floating point instructions and no floating point representation, this
computer being designed for commercial applications.
Although
addresses were only four characters, letters were also used, thus allowing to
address the maximum 160K.
All files
were kept on tape. Ampex tapes were
used. Typically, there would be from four to ten, up to twenty tape units. Many
tape units were useful to reduce tape sorting time, allowing to divide the
sequence to be sorted into a number of subsequences equal to the number of
tapes available. Sorting of files on tape was a very common task.
In the
first years, the program would be read initially from a punched tape, later
Bull card readers became standard. There was a line printer, made by Sheppard,
which could be programmed by a patchboard. The console had a typewriter, an
Olivetti telex machine. The console also had a keyboard from which instructions
could be entered for direct execution, one at a time.
There
were sophisticated I/O instructions. For example, there was a tape search
instruction that could find on a tape archive a block containing a given word (instruction
PRN). Another instruction could read a tape block, scatter it in memory
according to an address vector provided, and then recompose it for writing
(instruction NDN).
From the
programmer’s point of view, the organization in characters was a considerable
advantage with respect to the more usual organization in binary words of other
contemporary computers. A character on the coding sheet became a character to
punch on tape or card, and in turn that became a character in the computer
memory. No need to deal with octals or hexadecimals, as with many computers of
the time.
The fixed
length of instructions was also an asset, because it made it easy to determine
the address in memory of each instruction.
The base
registers enabled relative programming: for example, in a loop to fill a block
of records to be written on tape, the instructions in the loop would all point
to the first record, while on each execution of the loop the contents of the
registers would be updated to successively point to the second, third, … record.
The
computer had also the concept of interruption, as well as the concept of second
and third program. So superposition of I/O and CPU times was possible. However
these possibilities were not well documented and thus were very seldom used. It
was later understood that the direct utilization of these features cannot be
left to the programmer, they must be managed by layers of software known
nowadays as the operating system.
When it
comes to software, a painfully familiar picture appears. ‘Basic software’
R&D started at Olivetti only around 1959, as the 9003 started to be
marketed, and with a very small staff (at peak some years later, it reached a
level of less than 40 people for both Elea 9003 and 6001!). Furthermore, the
mandate of this group was innovation, to develop concepts in programming
languages and compilers. There was no integrated planning between this group
and the marketing group.
So,
Still,
some basic software was developed slowly, mostly by a handful of people in the
marketing division.
Clearly, at
that point in time it had not yet been understood that in order to justify the
cost of software production, companies had to develop long-lasting and
wide-ranging lines of compatible computers. The IBM 360 was the first family of
computers that was based on this idea. In the Olivetti labs at that time the
same problem was addressed by trying to devise high-level languages that would
became common to all the computers of the company, an idea that became
practical several years later with the language C.
Programming
style was most primitive. ‘Jump’ (or ‘go to’) instructions were used wholesale.
When a program had to be modified, programmers did not dare to touch the code
that had already started to work, they would rather make a ‘patch’ in the form
of a ‘jump’ instruction that would go to the end of the program to the new
code, and then jump back in. Later availability of an assembler (called PSICO)
did not change the picture much, because the assembler was slow (the source
program was stored on tape and each compilation would take several tape passes)
and so programmers did not want to reassemble a program every time a correction
was needed.
Some
people today might wonder how anything useful could be done with computers
having such small memories. Well, some time ago I saw (Comm. ACM 48 (2),
99-101) a ‘Hello World’ program, written, according to the author, in ‘proper’
object-oriented style. It had over 20
lines of Java-like code. Its execution
(let alone compilation) would involve the execution of untold numbers of
machine instructions, including Operating System code. Granted, the same work
could be done by a much shorter program however apparently it would not be
proper OO style.
On the
11
0016 # ø Prints the memory
contents from address 16 for length 11
0X
XXXX # 0 Stops the program
HELLO
WORLD The constant at address 16
(assuming that the program was loaded at address 0)
And how
to execute this program? Since it is short, we’ll type it directly in memory at
address 0, so we enter from the console:
27
0000 # %
Then we type the 27 characters. Finally we branch to position 7, entering the
following instruction from the console:
)#
0007 # O
Simpler
times…
In the
first years, the Olivetti Elea 9003 was plagued by maintenance problems.
Computers were maintained every morning by a team of technicians. However by
early afternoon things started to fall apart, especially in the peripherals.
A
programmer of those times recollected that a janitor thought she had an
identical sister, one going home at dawn and the other arriving to work at
Because
of the absence of debugging systems, program debugging could be done only by
programmers themselves when the whole machine was available. This was usually
at night, because in the daytime computers were used for production purposes,
to execute working programs. The problems just mentioned, unavailability of
software and maintenance issues, caused many frustrations.
For example,
here is how programs were initially loaded for the first many months. They
would be punched on paper tape, and then read by the paper tape reader.
Unfortunately, this one would usually break the tape, over and over. However
before the tape was broken, a portion of the program had been read in memory…
so programmers read the paper tape in memory a bit at the time, by repeatedly
patching it, and then assembled the program in memory by operations entered
from the console. The assembled program would then be copied to magnetic tape
(itself fraught with errors). When card input became available, the Bull card
readers were also slow and unreliable.
Initially,
the main method of debugging was step-by step execution controlled from the
console, looking at the contents of the CPU registers that were shown in binary
on arrays of lights. One would also use small memory dumps on the console
typewriter, and larger ones on the line printer.
Not much
was known about programming at that time. Programmers were mostly graduates
from technical schools who were given a five-week course on machine language
and flowcharting, without exposure to computers.
My
account of the 6001 will be shorter, because I used it much less. Also several
of the observations already made for the 9003 hold for the 6001.
The
Production
started in 1961. About 170 were sold.
The Elea
6001 was also fully transistorized, with ferrite core memory. Memory sizes were
from 10,000 to 100,000 4-bit characters, small sizes being the most common. It
had a floating point representation for reals. It had a microprogramming
memory, which was used to microprogram mathematical functions such as
multiplication, division and square root.
The Elea
6001 memory was organized in characters of 4 bits. As for the 9003, the binary coding of the
numerals was peculiar (see programmer’s
reference card). Of course, only sixteen characters could be represented in
4 bits, which means that letters had to be represented as combinations of two
characters. An interesting consequence of this is that fields containing
variable numbers of alphabetic and numeral characters were of unknown length
between a minimum and a maximum (more on this below). Each character had an
extra bit, the ‘wordmark bit’ that delimited the length of the variables in
memory (more on this below).
Instructions
were of varying (and variable) lengths. A typical instruction could be as
follows:
OO T IIIII
Where OO
was the op code, T was the name of a register (registers were used in the same
way as for the 9003), and IIIII were five characters of address. The full list
of instructions is given in the programmer’s
reference card.
Several
of the characteristics of the 6001 were difficult to manage for the machine
code programmer, although they could have been used to advantage by optimizing
compilers:
In
addition, variable-length instructions made it difficult to calculate addresses
in the program, another problem for the machine-language programmer.
It should
be noted that such memory-saving tricks were not unusual in the small computers
of the time (among others, in IBM computers).
As in the
case of the
At some
point the decision was taken in Olivetti that the Elea 6001 would be marketed
for business applications, and a number of them were sold for this purpose.
Given the memory structure used by the computer, I can only feel sympathy for
the programmers that had to program these applications. Consider that in
business applications fields are often alphanumeric, e.g. an address field
punched in a card typically contains variable numbers of numerals and
alphabetic characters. So a card consisting of 80 alphanumeric characters could
take anywhere between 80 and 160 characters in memory (the extremes being the
cases where it contained only numbers or only letters). This quantity was not
known until after completion of the read instruction. Now, how to find the different fields in the
card? Field lengths and memory addresses had to be determined in some way for
each card read, at execution time (looking for spaces, looking for certain
characters?). Similar problems had to be solved for lines to be printed, recall
that the length of a numeric quantity in memory would vary in time. Things that
are straightforward in most computers were headaches in this one.
Surely
these problems could have been helped by a high-level business-oriented language,
however I doubt that one was ever made available. Would you like to write a
COBOL compiler for this computer?
The Elea
4001 was introduced in 1963, and when the following year Olivetti sold its
computer division to General Electric it was adopted by General Electric and
became the GE-115. It was also sold by Bull under the name Gamma 115. It was a
successful computer: apparently about 5,000 machines of the series GE-100 were
sold worldwide. I never programmed the Elea 4001, but I understand that it was
a well-designed computer, with solid hardware and software. I am mentioning it only because I have its programmer’s reference card, which I am
making available in case it interests someone.
These are
recollections from my working experience at Olivetti, Marketing division, from
1961 to 1964. They were written mostly
from memory and corrections are welcome.
Additional
information, such as pictures of the machines, can be found on the web.
The early computers of Italy
De Marco, G.; Mainetto, G.; Pisani, S.; Savino, P.
Annals of the History of Computing, IEEE
Volume 21, Issue 4, Oct-Dec 1999 Page(s):28 – 36
Answer to
quiz above: According to Wikipedia and other web sources, the word software first appeared in print in a
paper by statistician John W. Tukey in 1958 in the American Mathematical
Monthly. Tukey is also credited with the invention of the word bit. However Paul Niquette claims having
invented the term software in 1953:
http://www.niquette.com/books/softword/part6.htm