Wilkes to become involved. Wilkes put
a soldering iron in his hand and Wheeler was hooked. In October 1948, he became Wilkes’s research student.
Like computer groups everywhere,
the laboratory had a copy of the
Planning and Coding reports produced in
1947–1948 by Herman Goldstine and
John von Neumann at the Institute for
Advanced Study, Princeton University.
These seminal reports contained many
key ideas, including that of a subroutine library. Most programs, it was observed, made use of common operations (such as computing a square root
or integrating a differential equation).
Using library subroutines not only reduced the amount of original code in
a program but also cut down on the
number of errors.
Goldstine and von Neumann did
not come up with a particularly effective way of incorporating subroutines
in a program, however. This enabled
Wheeler to make his mark by devising
a brilliant, practical solution known as
the “initial orders.” The initial orders
were something of a cross between a
bootstrap loader and an assembly routine. Programs, which were punched
on paper tape, consisted of a main program and a sequence of subroutines
copied from the subroutine library.
The library was kept in a small steel
cabinet containing master copies of
the different subroutines (there were
eventually over 100 different subroutines.) Subroutines helped, but there
were still plenty of errors in programs.
the eDsaC subroutine library was kept in the steel cabinet on the left in the image.
Library tapes were copied mechanically onto the user’s program tape and then returned
to the cabinet.
between experiences, people,
and technology, showcasing
emerging innovations and industry
In order to debug a program, a user
would sit at the EDSAC’s control desk
and obey the program manually one instruction at a time, observing the state
of the memory on a monitor display.
This process—known at Cambridge as
“peeping”—was time consuming and
prohibitively wasteful for such a scarce
resource. Wheeler’s solution, which was
evocatively called a “post-mortem routine,” was later known more prosaically
as a memory dump. The post-mortem
routine consisted of a small program
that could be loaded into the top end of
memory in the event that a program did
not run as expected, which printed out a
region of memory so it could be studied
at leisure away from the machine.
A different debugging idea was invented by Stanley Gill, another of Wilkes’ research students. This was the so-called
interpretive checking routine. If a program was difficult to debug, then the
program would be executed, not by the
hardware circuits of the EDSAC, but by
Gill’s interpretive routine. This behaved
exactly like the real machine except that
it printed diagnostic information while
doing so. This idea was adopted, or reinvented, at many places and became
known as a program trace. It earned Gill
his place as one of the triumvirate of authors of The Preparation of Programs.
With these programming aids it was
no longer necessary for programmers to
run their own programs; a machine operator took over and greatly increased