History of Terry's Involvement with Computers
Terry's first programming class was for the IBM 1620, a desk-size computer that used variable length 'words' made of decimal digits. The IBM 1620 had a memory capacity of 20,000 decimal digits, 12 of which were used for each instruction and variable length for each of the numeric variables. Your car keyfob has considerably more power than the IBM 1620.
Terry's first extensive experience was with the Control Data Corporation 1604, of the very first 'modern' computers. The CDC 1604 had 32,748 48 bit words of magnetic core memory. That is the equivalent of 196,488 bytes of memory in modern terms. The list price for a 2000 pound CDC 1604 in 1960 was $1,030,000. Today a typical 3 pound $800 laptop has 8,000,000,000 bytes of memory and a memory access and processing speed 1,000,000 times faster. A $60 Raspberry Pi 4 single board computer has 4,000,000,000 bytes of memory. Moore's Law in action.
Terry's next experience was with his all time favorite computer, for its elegance of architecture, operation and functional capability, the Burroughs B5500. Unlike virtually any other computer of the time, the B5500 was built for time-sharing. It could provide up to 32 users remote access to the computer and each user believed they had the entire machine to themselves. A second aspect was its hardware support for recursion, a programming whereby a routine is called repeatedly to resolve and process complex data by drilling down to the simplest and lowest level. This capability was ideal for artificial intelligence applications such as the large-scale project that Terry worked on at the University of Wisconsin - Madison in the 1968-71 period. See AutoLing Project.
A token of its sublime elegance is the operator's console, visible toward the left of the picture above. Rather square feet of flashing lights and a myriad of button, the operator sat a a table with a electric typewriter for system messages and on the edge a low panel with a few buttons and lights. The picture below has parts from a disassembled B5500 and a disassembled larger version, a B6700. The panels are mounted on the edge of the console. After pressing the Power On button, the operator pressed the Load button and the computer was operating.
While the last of the 50 or so B5500s made were scrapped decades ago, unlike virtually any other computer, there is still a world-wide fascination and frankly respect and love for the elegance of its design. This can be seen in a recently completed project to develop a B5500 hardware-level simulator program to emulate the entire B5500 system. An international team of programmers, developed an application that emulated every element of the B5500 System from the Central Processing System to the Tape Drives and Card Reader. The emulation was at the instruction execution and memory cycle-level based on many Burroughs technical manuals.
The emulation is so perfect that the simulation that is can execute the B5500 operating system, called the MCP (Master Control Program). A team of people took the ESPOL (the programming language for the MCP) source code listings, numbering hundreds of pages, keyed it in, and generated machine readable text. They did the same with the ESPOL compiler source code as well as source code the Extended Algol compiler. Using a cross-compiler on a different computer, they generated a machine language version of the MCP and ESPOL/ALGOL compilers which the B5500 emulator executes exactly as though on a real B5500. This permits the ESPOL and ALGOL compilers to be used for modifications and execution of application programs.
It is as though the B5500, lost for more than 30 years- lives again.
The emulator and all the software is freely available and its can run on pretty much any current desktop or laptop computer. All of this was done by a world-wide team of volunteers who loved and respected the most elegant computer ever built. Download and run it yourself. See B5500 Emulator
Here is a screen shot of the emulated B5500 console. The buttons and lights actually work. The computer will boot up and you can run programs just like a real B5500.
The Burroughs B5500 architecture is unique among computers of the 1960's and 1970's. Rather than an 'accumulator register that most instructions interacted with, the B5500 was a 'stack computer'. Each executing program had an area of memory that functioned as a LIFO push-down stack where all operands were stored during use. Here is an example of the addition operation between traditional and stack computers
LDA A - Load accumulator with the contents of variable A Push A - Push contents of variable A onto stack
ADD B - Add variable B to the contents of the accumulator Push B - Push contents of variable B into the stack
STA C - Store contents of the accumulator in variable C Add - Add the top to operands on the stack
leaving the sum on the stack
POP C - Pop the top operand on stack and store
in variable C
While these process look similar, there is a key difference. When the stack computer wants to call a subroutine, a separate block of code to perform a specific function, a special block of information is pushed onto the stack. This special stack segment will contain the parameters that a supplied to the called routine, space for all the local variable defined in the called routine, and the return address for when the routine ends. This allows each invocation of the routine to have a private set of variables that are private to that invocation. This means that a routine can call itself, recursion, repeatedly such as for parsing an arithmetic expression or analyzing the grammar in a sentence. This functionality is critical to an language parser such as was developed in the Autoling Project Terry worked at the University of Wisconsin.
Non-stack computers in the 1960's and 1970's could not allow for recursive use of a routine since the local variables were in defined memory locations and would be overwritten by a subsequent routine call. In modern times, recursion is possible not by hardware support as with the B5500 but rather in software using instantiation of a routine in a class which would allow for second and subsequent instantiations of that same class that have separate data structures.
Terry also worked on a wide variety of other early and modern computers including the Univac 1108, IBM 360 and 370, Prime 400s, and 750s, and the IBM 1410 which he used to develop and operate the software used by a company he started in graduate school called Insurance Computing Corporation which did data processing as a service bureau for small insurance companies in Wisconsin.
Most recent has been with Windows and Mac PCs and most recently with micro-computers such as the amazing Raspberry Pi
The Raspberry Pi has more memory and computing power than mainframe computers of 10-15 years ago that cost millions of dollars. The Raspberry Pi 3+ costs $35.00.