Software Development at the Eckert-Mauchly Computer Company Between 1947 and 1955

Iterations – Norberg – Software Development at EMCC 

 13 

held the input data; number 3 contained the data called for by specific 

subroutines; and number 4 received the output data. Along with memory 

segments, say 000-059 for the initial read, for input, working storage, 

program, constants, and output blocks, the compiler had an area called the 

“neutral corner.” The neutral corner contained certain transfer instructions. 

The concept of the neutral corner arose because Hopper quickly 

encountered the problem that in some cases the program needed to jump 

back for something previously processed, and at other times the need was 

to jump forward to a section of the program still unknown, therefore 

whose location was unknown. That is, there were two types of jumps to be 

coped with. Jumping back was simple; jumping forward was impossible. 

The telling of her solution to this problem bears presenting completely in 

her own words.  

 

And here comes in the curious fact that sometimes something totally extraneous 

to what you are doing will lead you to an answer. It so happened that when I was 

an undergraduate at college I played basketball under the old women’s rules 

which divided the court into two halves, and there were six on a team; we had 

both a center and a side center, and I was the side center. Under the rules, you 

could dribble only once and you couldn’t take a step while you had the ball in 

your hands. Therefore, if you got the ball and you wanted to get down there 

under the basket, you used what we called a ‘forward pass.’ You looked for a 

member of your team, threw the ball over, ran like the dickens up ahead, and she 

threw the ball back to you. So it seemed to me that this was an appropriate way 

of solving the problem I was facing of the forward jumps! I tucked a little 

section down at the end of the memory which I called the ‘neutral corner.’ At 

the time I wanted to jump forward from the routine I was working on, I jumped 

to a spot in the ‘neutral corner.’ I then set up a flag for the [forward operation] 

which said, ‘I’ve got a message for you.’ This meant that each routine, as I 

processed it, had to look and see if it had a flag; if it did, it put a second jump 

from the neutral corner to the beginning of the routine, and it was possible to 

make a single-pass compiler and the concept did come from playing 

basketball.

40

 

 

A-0, however, was the only single-pass compiler built. Hopper believed 

A-0 should be a one-pass compiler. The information defining a problem 

came from one tape unit and the program was written on another because 

UNIVAC I had only 1,000 words of storage, leaving little room for 

anything but the basic steps of the compiling process.  

 

In the technical language of the instruction manual, the neutral corner was 

described thusly. 

  

When the compiler, processing operation a, is informed that one of the exits of 

operation a must transfer control to operation a+b (b >1), a ‘forward pass’ is 

required, [Figure 2]. The compiler inserts in the exit line of operation a, an 

instruction transferring control to memory location g in the neutral corner. The 

compiler then records the fact that, the neutral corner has in storage a forward 

pass destined for operation a+b. As each successive operation is treated, the 

compiler looks to see whether or not a forward pass has been tossed to that 

operation. Hence, it will find a pass to operation a+b. The instruction 

---

Iterations – Norberg – Software Development at EMCC 

 14 

transferring control to operation a+b is generated and delivered to position g in 

the neutral corner.

41

 

 

All of this was on the Running or Program Tape, tape #2.  

 

 

 

 

Figure 2. Use of the Neutral Corner concept in A-0. 

 

Similarly, for the Compiling Tape, tape number 1, it was assumed that 

four UNISERVOs were available. These tapes were for the compiler, 

information defining the problem, the subroutine library, and the running 

tape. The memory sections were broken down in the same way on this 

tape, though each section might contain different kinds of information 

than on the running tape. The information defining the problem consisted 

of a set of operations, each defined by three or more words (Figure 3). The 

information contained the call number of the operation and subroutine, 

one or more “argument words” identifying quantities entering the 

operation, “control words” if the normal exit to the next operation was to 

be altered or if the subroutine had more than one exit, and, lastly, one or 

more “result words” identifying the results produced by the operation. The 

subroutines in the library were in alphabetical order. As each subroutine 

was entered in the running program, a record was kept by the computer, 

including its call number, the number of the operation, and the memory 

location in running memory at which the subroutine began.  

 

The compiling tape was constructed in blocks from 1 to 13, where blocks 1 to 4 

contained the data and instructions for the compilation and blocks 5 through 13 

contained the compiling program. The A-1 compiler was more extensive than A-

0, and provided for longer programs, a larger number of transfers of control to the 

neutral corner, and more working storage. 

---