SOFTWARE - THE EARLY DAYS
A little over twenty years ago, there was a growing concern on the
part of the American Department of Defence, about the number and
variety of programming languages that were being used in the various
projects they were funding. A study conducted at that time, revealed
more than 450 languages and dialects in use. It was felt that
considerable cost savings could be made by reducing this number, and
standardising on a single language for all future work. In the decade
that followed, a considerable amount of work went on to produce such a
language. The outcome of it all was ADA, about which we hear so much
nowadays (although not all of it, is quite as enthusiastic as it used
Today, the abundance of computer languages and software tools that led
to the development of ADA, has become a superabundance. By contrast,
the situation just 40 years ago, couldn't be more marked.
In 1955 there were no software tools whatsoever; no assemblers,
compilers, linkage editors, program generators, editors, interpreters,
operating systems, etc. There wasn't even an assembler level language,
and all programming was done via machine 'orders' or 'instructions',
effectively what we would nowadays consider to be machine code. The
very term 'software' was itself still a very new thing.
Primitive as this may sound, it's worth remembering that there were
still very few computers in use worldwide, and in Britain no more than
a dozen or so, and these were usually specially built 'one of'
designs. At the beginning of the '50s there were less than a handful
in operation in Britain. The age of the computer had begun just over
10 years previously, but so far there were very few signs of it. The
revolution in hardware and software, and the widespread use of
computers in business, industry, and science, was yet to come.
In order to appreciate just how much had already been achieved, it's
worth reviewing the considerable amount of progress that had been made
since the introduction of the first programmable machine some 200
Lady Ada lovelace is usually credited with being the world's first
programmer for her work on Babbage's Analytical Engine, although a
more appropriate title would be that of world's first systems analyst.
The credit for being the first programmer, must go to someone who
preceded her by more than a 100 years, for in the early 18th century,
Falcon introduced the novel idea of a chain of punched cards to
control the operation of weaving looms. This idea was improved on by
Jacquard who introduced his own version of the programmable loom in
1804. It quickly caught on, and by 1824 was in widespread use in both
France and Great Britain. When Babbage proposed the use of a similar
arrangement for his Analytical Engine in the mid 1800's, the idea of a
control program was already well over a century old. Programmable
process control equipment is thus not a new thing, being over two and
a quarter centuries old.
Although Babbage's Analytical Engine was never built, a considerable
amount of 'documentation' was produced, (including the extensive notes
written by Lady Lovelace) and a part of the mill (arithmetic unit) was
eventually constructed by Babbage's son in 1906.
Over the centuries there had been various attempts at producing
calculating machines, some more successful than others. Perhaps the
earliest of them being Pascal's adding machine, the Pascaline. Built
between 1642 and 1644, it was crude by present day standards, but it
was the first reliable device to perform an arithmetic operation
But apart from Babbage's, none of the several machines proposed or
built, were designed to be programmable. It wasn't until 1937 that
Babbage's idea of an automatic programmable calculating machine was
taken up again. This time by IBM, following an approach by Howard
Aiken of Harvard. At that time IBM were one of the biggest
manufacturers of what were known as 'book keeping machines'. These
were basically mechanical calculators using punched cards, widely used
for business and scientific purposes. IBM's expertise in this field,
made them ideal for the project, and seven years later in 1944, the
world's first programmable digital computer was finished.
It was called the Automatic Sequence Controlled Calculator (ASCC).
Upon completion it was presented to Harvard University, and was
subsequently known as the Harvard Mark I. Like Babbage's proposed
Analytical Engine, it was a mechanical computer. Unlike his, it was
powered by electric motors.
Like many of the early computers it made use of a decimal rather than
a binary number representation, and stored numbers in genuine hardware
registers - sets of wheels driven by rotating shafts. It had a massive
memory of 72 such registers which could be set up and controlled by
means of an external program, and each one capable of holding a 23
digit decimal number. There was no provision for a stored program,
although constants could be set up by banks of hand switches.
Input and output of data was by punched cards, and program control via
24 hole punched tape. Programming was of a most elementary kind, with
each tape frame being split up into 3 groups of 8 holes, consisting of
numerical codes for input register, output register, and operation.
The ability to evaluate functions, a necessary attribute of any
scientific calculator, was implemented by special program tapes, which
were loaded as required during the course of a program. In order to do
this the programmer had to include a command to stop the calculation
to enable the required function tape to be placed in the tape reader.
Some idea of the speed of the machine can be got from the fact that it
took about 6 seconds to perform a multiplication, and about 11 seconds
to perform a division, both being done in a part of the machine's
hardware dedicated for this purpose. There was also, special purpose
hardware for calculating such things as sines, logs, and exponentials
although these took a bit longer (a minute being the minimum time
Even as IBM's ASCC was being completed, construction of the world's
first electronic machine was under way. It was being used as early as
1945, although it wasn't finally completed until 1946. It was known as
ENIAC (Electronic Numerical Integrator And Calculator). It was big,
occupying some 1,500 square feet of floor space, weighed 30 tons, and
required 150 kw of power. The sheer number of components, which
included some 18,000 valves and 1,500 relays made maintenance a full
Despite it's size and complexity, the programming facilities provided
were of the most primitive kind. Like the ASCC it was a decimal
machine and made use of punched cards for input and output of data.
However, to make good use of ENIAC's considerably greater speed, the
use of an external control program (as in the ASCC) was dispensed
with. Instead, it used a stored program, set up by hand on plug and
socket patch panels, and banks of switches.
This 'hardware programming' literally set up data and control routes
from one part of the machine to another, the operations to be
performed, the registers to be used, the number of iterations of an
operation and so on. To give an example; if the sign of a number was
to be tested, a 'programmer' would have to set up an electrical
connection from the appropriate part of the accumulator holding the
number, to the part of the machine where the sign was required.
Despite the tedious and time consuming process of setting up and
checking programs, ENIAC's use of stored program control was
considered a big advance because of the vastly increased operational
speeds it made possible. This use of a stored rather than external
program, is a feature of modern machines (albeit implemented in a
different way) most of us take for granted.
ENIAC's method of implementing a stored program was implicit. It
wasn't so much a case of holding it in the machine, as making it a
part of the machine. Programming consisted essentially of physically
reconfiguring the hardware by hand; a process which was extremely time
consuming and prone to error.
The concept of actually holding in a machine the program to be
executed, in the same way as numbers, was described by the now
legendary John von Neumann, in a report published as early as 1945.
Nowadays it's difficult to appreciate that this was once a new and
revolutionary idea. Even as late as the mid 1960's it was still being
considered by some, to be a difficult idea to grasp, and one which
required a considerable amount of explanation.
The original von Neumann report set out the requirements for a general
purpose stored program digital computer. This report was to lead to
the development of EDVAC (Electronic Discrete Variable Automatic
Calculator), the first computer to make use of a genuine stored
program as we understand it today. Like ENIAC this was also developed
by the University of Pennsylvania for the US Army, but it took a lot
longer to complete; work having started in 1946, it wasn't finished
until 1952. Not only was it the first stored program computer, it was
also the first to store numbers in binary form, another of John von
The ASCC could hold up to 72 numbers of 23 decimal digits, plus 60
'constants'. EDVAC by contrast, had a mercury delay line memory, that
could handle 1,024 numbers, each one 43 bits long. This was a
considerable increase in main memory, although some precision in
number representation was lost, and of course the memory was also
being used to hold the program to be executed.
The program or 'programme' as it was spelt in those days, was made up
of a series of 'orders' which were directly interpreted by fixed
hardware as they were fetched from store (microcode - now widely used
and essentially a level lower than machine code, that implements
processor instruction sets - was nowhere to be seen). Orders in the
EDVAC made use of a four address code system, of which the first two,
specified addresses from which numbers were to be taken, the third
where the result was to stored, and the fourth gave the address from
which the next order was to be fetched. The 'function' or operation to
be performed was given in a very abbreviated mnemonic form - A for
Add, S for Subtract etc. One such order might be:-
203 204 207 500 A
Roughly translated this meant - take the contents of locations 203 and
204, Add them together and place the result in 207, then fetch the
next instruction from location 500 and execute it. An interesting
point to note from this is that operations are performed between
locations in memory, and not using registers. Also, the lack of some
sort of automatic sequencing mechanism or control unit, meant that the
programmer had to explicitly define by means of the fourth address
field, the order in which instructions were to be obeyed.
This may sound a bit tedious, not to say inefficient. But two factors
are worth bearing in mind. Firstly, the order code (the only
programming language available) was an integral part of the machine,
with its form determined largely by the hardware design. Secondly,
there were severe time penalties involved in fetching instructions and
data from the mercury delay line store.
The delays caused by having to wait for addresses to become
accessible, meant that a lot of ingenuity had to be exercised in
writing programs, if execution times were to be kept down to a
reasonable level. By not laying down the orders in continuous
execution sequence, it was possible to arrange for the next order that
was required to be executed, to be almost immediately available when
the current one had completed. It meant of course that programmers had
to take into account the execution times of different orders when
writing the code, and suitably juggling the addresses at which numbers
and orders were stored (not things that many of us have to bother
about these days).
This technique, known as minimum access coding (the objective being to
reduce the overall time taken to access locations in store), was not
limited to EDVAC. Due to the use of delay line stores and relatively
slow speed magnetic drums, as main memory in the majority of early
digital computers, it was a subject of considerable importance to
programmers in general.
EDSAC (Electronic Delay Storage Electronic Calculator) was the first
large British machine to make use of the principles embodied in EDVAC.
However, it wasn't the first British machine to make use of a stored
program, for by the time EDSAC was completed in 1949, three
experimental machines had already been built at Manchester University.
From these, and later work done at Manchester, were to come the early
Ferranti machines, such as the Mark 1 and the Mercury.
Unlike its American counterpart EDVAC,
EDSAC made use of a control unit which determined the sequence in
which orders were executed. As a consequence, its order code didn't
use a 'next instruction address' field. EDSAC also had an accumulator
to store intermediate values, which meant that it didn't need a
resultant field, nor one of the operand address fields. This very much
pared down system was, for obvious reasons, known as a single address
order code. Although perhaps not seen that way at the time, this was a
necessary evolutionary step in the development of software; one that
freed the programmer from some of the more irksome aspects of program
The code in which they wrote was still determined by the machine, but
the programmer was no longer required to be involved with the finer
details of program implementation. However, as we know, that wasn't
the end of the story by any means. So far the majority of effort had
been expended in developing suitable hardware, with programming being
a necessary, though very much secondary activity. In fact, programming
methods, and generalised software as a major component of computer
systems had yet to be developed.