Original publication date: March 1992 Heurikon Historical Highlights A series of articles for The Horizon How Programs Were Made in the Old Days We wrote our first lengthy microcomputer programs using the computer at the University of Wisconsin’s Computer Science Department. We purchased the computer time, paying by the minute of CPU usage. We started by reprogramming their mainframe’s macro assembler so it would understand Intel 8080 instructions. When we had an 8080 program to assemble, we punched a deck of about 2,000 cards, fed the cards in via a card reader, and went to a Teletype machine where we punched a long paper tape of the resultant 8080 object code. To be more accurate, we “submitted” the deck at the computer room window, waited overnight while the job was run (the night-time rates were cheaper), and then we made the object tape. If one of the cards had a typo, it took us another day to fix it and rerun the job. That type of interaction with a computer was called “batch” mode, and it was frustratingly slow. We brought the paper tape back to our office and read it in on our ASR-33 Teletype machine. The data went into RAM, and then we made a ROM copy. Sometimes the tape would break or the teletypewriter would skip a sprocket and the program wouldn’t work — it was a very unreliable system. Patchwork Quilts After we tested the program, if we needed to change even a single line of the source code, we had to edit the card deck and repeat the whole process. To avoid doing that for simple changes, we would frequently just “patch” the ROM version of the program by manually changing certain memory locations in a RAM copy of the program. Manual changes to 8080 and Zilog Z80 programs were easy to do because the eight-bit machine-code formats used by those chips were simple to memorize. After making many patches, however, our programs would become impossible to maintain, so we ultimately had to go back to the punch cards and clean things up. Since we were writing machine-language programs (not BASIC, FORTRAN or C) and had only a limited amount of space in the small ROMs, we’d frequently hand-assemble the source code modifications we were planning and figure out on paper if the total number of bytes we were adding (less those we were removing) would overflow the ROMs. If we had too many bytes, we went on a search-and-destroy mission, looking for parts of the program that could be streamlined or eliminated. This resulted in some very interesting, but highly convoluted and hard-to-maintain code. The Teletype machine ran at only 10 characters per second, so a lengthy dump was very time-consuming. The first thing we wrote was a monitor program for the 8080 that allowed us to type commands to the Teletype so we could read and write memory locations. We called it “RAID” for Real-time Assembler and Interactive Debugger — it was supposed to kill-bugs-dead. Later, when we modified the monitor to work with Zilog’s Z80 chip, we renamed the program “ZRAID.” (That monitor served us until the 68000 came along — then we wrote Hbug.) Instead of having an RS232 voltage-level interface, teletypewriters used a 20-milliampere current loop, so our early microcomputer boards had a current loop I/O circuit. Most microcomputer manuals explained how to rewire and connect a Teletype machine, and many early CRT terminals had a current loop option. Teletype Mechanics If the Teletype would act up, we would have to stop our work, get out our tools, and try to fix it. Pete Berbee and I once spent a whole day just trying to adjust a greasy camshaft in the damn machine so it wouldn’t print gobbledegook — and we never did get around to doing any useful work that day. Through the surplus market, we came across an old seven-track magnetic tape machine. Using trial and error on a I/O connector, we figured out how to start and stop the tape motion. We wrote a short bootstrap program to control the tape machine. (The bootstrap had to be read into memory from paper tape). This allowed us to save large programs and quickly reload them a day or two later. The tape machine roared like an industrial vacuum cleaner when it was running. By the end of the 1970s, Digital Research had produced the CP/M operating system, which we quickly ported to our MLZ-80 board. CP/M gave us our first in-house capability to edit and assemble programs for our hardware. The glory days of the Teletype were ending, and we cautiously invested in our first CRT terminal. Our MLZ-80 had 4,096 bytes of RAM, which was just enough to load the operating system, and was the first Multibus I card in our market to include a floppy disk controller. A separate 32-kilobyte RAM card was needed, however, to run any programs! NEXT MONTH: Toaster-master General. |
|||
