By Luigi Logrippo
Elea 9003 was the first industrial electronic computer made in
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:
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.
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.
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.
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
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 . A manager asked for explanations when she discovered that ‘the machine’ had been shut off between 00:00 and 8:00 a nice Christmas day.
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.
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: