back to home page
[copied from]

My first two computers: Elea 9003 and Elea 6001

By Luigi Logrippo       


January 2007

Olivetti Elea 9003

The Olivetti Elea 9003 was the first industrial electronic computer made in Italy. It was announced in 1959 and the first specimens were installed in 1960, the last in 1964 when the company was sold to General Electric, becoming Olivetti-General Electric. About 40 were produced.


The Elea 9003 CPU was entirely transistorized. The memory was ferrite cores. The memory cycle (access to one character of 6 bits) was 10 microseconds, thus the machine’s speed was 100KHz, a reasonable speed for the time.


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 608 in mid-1955 and Siemens had announced a fully transistorized System 2002 some months before the 9003.

Memory structure

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 and CPU registers

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.

Instruction structure

All the instructions were of eight characters. Most instructions were of the form:




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 7 F


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.

Input-Output units

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.

Input-Output instructions

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

A programmer-friendly machine…

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.

Software (Quiz: had the word software been invented by then? See below the answer)

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, Alice asks, pray tell, who will develop input-output macros, mathematical macros, an assembler, a sort and merge program generator, a linker and a loader, testing tools, FORTRAN and COBOL? Very simple, answered the Queen, the machine is so pleasant to program that programmers won’t mind to develop all the necessary programs by themselves, in machine code, over and over again for every application.


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

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 Elea 9003, we would program this in 27 characters; the rest of the memory would be empty.


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.

Working conditions

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 8:30. 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.


Olivetti Elea 6001

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 Elea 6001 was designed as a smaller brother of the 9003, and as a scientific computer (it would have been very nice if it had been just a scaled down 9003… )


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.

Memory structure

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

Instruction structure

Instructions were of varying (and variable) lengths. A typical instruction could be as follows:


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.

Difficulties of the Elea 6001

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:


  1. There was a scheme to save addressing bits in instructions. While a regular address was of 5 characters, the programmer could supply less if the initial ones were the same as the ones of the previously encountered instruction. So, for example, in an instruction to address 12345, the address could be written simply 345 if the previous instruction executed was at address 12678. While indeed this scheme could save memory space, the attention needed by the machine language programmer was considerable. At a time when jump instructions were used wholesale, one could not be sure what the previous instructions were, and the addresses of the previous instructions could change as the program was debugged and modified.
  2. The end of a data item was given by a ‘wordmark bit’ that was associated with the last character of the data item. So, contrary to the Elea 9003, the number of characters affected by an instruction was not given in the instruction. Characters would be moved by a move instruction from the address specified in the instruction to the nearest wordmark bit. Again, this had been thought as a clever method to save moving useless characters, while also saving in instruction length, but had several negative consequences for the machine language programmer:
    • In most cases, the programmer did know exactly how many characters would be affected by an instruction (although an instruction to determine the distance between an address and the nearest wordmark bit was available). The length of a data item was determined by the previous move to that address, and so on recursively. E.g. if X had 4 characters initially, then as a result of X= X+X, its size could become 5, while as a result of X = X x X, its size could become 8 characters. The wordmark bit of X would move accordingly. When moving data from an address X, one could in fact move the last few characters of the data stored at a nearby address Y, if the data moved to Y had overflowed to cover part of the area of X. Such errors were difficult to detect and would propagate easily, in different ways with the different data and execution paths through a program.
    • Because of the variable length of data, it was difficult to interpret memory dumps (for some years, the most commonly used debugging method). There were many ‘dead’ characters in memory that resulted every time a value was overwritten by a new, shorter value. Data overflows were difficult to detect in memory dumps.


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 Elea 9003, software was late arriving. The software R&D division produced a compiler for Palgo, a dialect of Algol. However the scientific programming world at that time (and for a long time thereafter) was dominated by FORTRAN. So a compiler for FORTRAN had to be produced quickly by the marketing division, a fact that caused embarrassing rifts in the company. It is interesting to note that the R&D division was historically correct, since many modern programming languages have been influenced by Algol through Pascal, Ada,  C, and Java, while FORTRAN has remained almost without descendants.

A computer for business applications?

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?

Olivetti ELEA 4001

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.


A historical paper is also available:


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: