The software is in the holes - The Computing Universe: A Journey through a Revolution - page 46

a graduate student in Cambridge, therefore introduced a program he called
“Initial Orders” that read these more intuitive shorthand terms for the basic
machine instructions, translated them into binary, and loaded them into mem-
ory ready for execution. Using these abbreviations made programs much more
understandable and made it possible for users who were not computer special-
ists to begin to develop programs for the machine.
Wheeler's Initial Orders program was really the first practical realization
of von Neumann's hardware-software interface. It was also the first example of
an assembly language , a programming language that used names instead of num-
bers. Assembly languages constituted the next significant step up the hierarchy
of software abstractions. They were easier to use than machine code but still
much harder than later high-level languages. Writing an assembly language
instruction such as “MOV R1 R2,” meaning “Move contents of register 1 to reg-
ister 2,” allowed the user to avoid having to think about the explicit switches
that needed to open to direct the flow of charge from register 1 to register
2. Similarly, memory addresses , the binary numbers that the computer used to
track where data and instructions are stored in its memory, were replaced with
more intuitive names like “sum” or “total.” Although assembly languages made
the writing of programs easier, computers still ran with machine code, the
low-level language composed of binary numbers. To run an assembly language
program, the assembly language first has to be translated into machine code.
The need for such translation required the development of programs called
assemblers that could perform the translation and produce machine code as out-
put. On the EDSAC, this translation was originally done with Wheeler's Initial
Orders program, which we might now call the first assembler.
Despite the great simplification introduced by using assembly language
to write programs, the Cambridge team quickly found that a large amount of
time was being taken up in finding errors in programs. They therefore intro-
duced the idea of a “library” of tested, debugged portions of programs that
could be reused in other programs. These blocks of trusted code are now called
subroutines . For these blocks of code to be used in different programs, we need
to use the Wheeler jump . As we have seen in our file clerk discussion, the com-
puter takes its next instruction from the memory location specified in the
special memory register called the program counter . After each instruction is
read, the contents of the program counter are increased by one to point to the
next instruction in memory. With a jump instruction, the computer can copy
the memory address corresponding to the beginning of the subroutine code
into the program counter. The computer is no longer restricted to the next
instruction but can jump to the starting address of the subroutine code. The
program will then follow the instructions in the subroutine code incrementing
the program counter from that entry point. Of course, to know where in the
program the subroutine should return after it has completed its execution,
the computer also needs to have saved the previous contents of the program
counter in another memory location, which was an essential feature of the
Wheeler jump.
If we want to call a subroutine from within another subroutine, we will
clearly need to save the multiple return addresses. We cannot use just one spe-
cial memory location because the return address of the first subroutine will be

B.3.2. David John Wheeler
(1927-2004) was a British computing
pioneer who made a major
contribution to the construction
and programming of the EDSAC
computer. With his colleagues
Maurice Wilkes and Stanley Gill,
Wheeler invented subroutines , the
creation of reusable blocks of
code. Wheeler also helped develop
methods of encryption , which puts a
message into a form that can be read
only by the sender and the intended
recipient. Wheeler, Wilkes, and
Gill wrote the first programming
textbook in 1951, The Preparation
of Programs for an Electronic Digital
Computer.