Unlike most software engineers, I started my career as a field engineer responsible for maintaining those large mainframe computers like the ones you see in movies. You know the type with the line of tape drives whose reels keep spinning back and forth. I got that job by attending the last full time field engineering class taught entirely by live instructors at the Arlington campus of Control Data Institute in 1976. It was a 6 month full time program which taught electronics repair, debugging, and machine language programming. They delved into topics such as optimizing Boolean logic which we then implemented by wiring together small boards each of which contained a single Boolean gate made up of discrete components such as transistors. You haven't lived until you've built an adder circuit this way. One of the big attractions was Control Data consistently managed to find jobs for more than 90% of their graduates from each class. For the class which followed mine, they started using an early version of a computerized training system called PLATO for part of the training and eventually switched entirely to computer-based instruction.
In 1977, I completed my course and got hired as a field engineer by Honeywell Information Systems with the responsibility for maintaining their Level 6000 and 6600 series mainframes. Much of the time I worked on peripheral equipment such as disk drives, tape drives, and line printers. It's a sad fact of life that machinery with moving parts breaks down a lot more often than purely electronic equipment does. Fixing mechanical problems is a necessary part of the job for field engineers but it's not always interesting and it often means getting covered in printer ink or grease.
My favorite part of the job was the more difficult debugging required when a computer fails to boot or when one crashes. When the computer itself had problems, I occasionally had to troubleshoot the CPU the way the field engineer in the picture below is doing.
The CPU for Honeywell's 6000 series of mainframes contained about 80 logic boards,
each of which measured about 12" square and contained over 100
integrated circuits. For the most difficult problems, we sometimes had to
put the boards on board extenders similar to the one in the picture above which provided access for easier debugging
using an oscilloscope to trace signals from board to board within the CPU. For me, the best part of those mainframe computers was
the large maintenance panels they had. From that panel I could stop the CPU to examine the contents of registers, single step the CPU to see how it behaved while executing a section of software, and insert breakpoints to automatically stop on certain conditions. That was when I was infected by the love of programming. I'd get 2+ hour windows for preventive maintenance and if I rushed through running the system diagnostics, I'd have time left over to enter machine language programs on those maintenance panels. Seeing the lights on the panel blink in ways I expected was a thrill. I spent 5 years working at Honeywell but ultimately left because I was frustrated by the obstacles they presented to employees who want to make the switch from hardware to software.
My second job was with a small company called Atex which used DEC PDP-11 minicomputers to run publishing software used by magazines and newspapers. For a while I was the onsite field engineer at USA Today and helped install the 12 PDP-11 minicomputers they used when they launched. Most of my work was maintaining the 200+ terminals used by newspaper staff. The terminals were simple but company policies declared the ORU (optimal repairable unit) to be the logic board which time consuming to replace. So I started saving the chips which commonly caused failures from all of the defective boards I sent back to be repaired and I learned which chip to replace for various symptoms. A vertical line across the screen meant the horizontal deflection chip was likely bad. That allowed me to reduce my time to repair 45 minutes equired to replace the logic board to about 5 minutes to pop a new chip into a socket. The time savings left me ample time to write machine language programs I could try during preventive maintenance windows.
Since the PDP was a smaller computer, its maintenance panel was much simpler (see below) than the one used by mainframes. The CPU's instruction set was much simpler as well. Maintaining minicomputers
proved much less challenging than working on mainframes was. Their CPUs only had a couple boards and instead of doing chip level repairs, we just replaced the bad board. Frankly, I found the job a bit
boring. After a mishap where a minicomputer fell on top of me (which is a story for another time), I
decided to make the switch from computer hardware to software.
What I discovered at my first software job was thanks to my unorthodox introduction to programming, I had a much better understanding of low level programming than most of my colleagues did. I also appreciated that as a software engineer, I was able to write assembly language programs rather then entering instructions as machine language which is just a group of numbers. Writing assembly language was much less labor intensive. The instruction "LDA" (load the accumulator register) was easier to remember than the fact that a 235 was the CPU's "op code" for a LDA instruction. I also didn't have to manually calculate the jump offsets between instructions. Yes sir, assembly language programming was much easier than what I was used to doing.
At GE, which was my 4th job, I wrote code for Honeywell 4500 series computers. These were process control systems with a 24 bit CPU which had been modified for use in GE's packet switched network. The 4500 was yet another another machine with a front maintenance panel. Most of the code we wrote was in assembly language but the assembler wasn't very sophisticated and it wouldn't give a proper warning when a jump location was too far away. What could happen was the jump offset might get large enough that it would set the top bit of the offset field, changing the jump direction from forward in memory to backward which caused unpredictable behavior. I could catch these errors pretty quickly because the assembly listings from our programs also showed the machine language instructions one one side. In the machine language column the direction of the jump offset was obvious to people who understood the instruction set. Eventually I was put on a project to upgrade the network nodes to more modern hardware. I was sent off to be trained on the new machines where I discovered that my management had completely ignored the class prerequisites of knowledge of the C programming language, much to the instructor's chagrin. So I was forced to learn C during a several week course where I was expected to already have expertise in C and was also learning about the equipment's API. It was hard until I finally realized that C is really just a portable assembly language. After that, C became my favorite programming language and remains a favorite to this day.
Eventually I joined Sprint International where I was responsible for developing software for the equipment used in their packet switched network. It was at Spring that I became obsessed with Unix because I had a Sun 3/80 workstation on my desk. To this day, the Sun remains my idea of the ideal development environment. It was also there where I first used a Motorola 680x0 CPU which features my favorite instruction set of any CPU. One thing I found frustrating was Sun's version of vi (a visual editor) had restrictions on the width of a window and the overall size of the files which could be edited. My machine language skills allowed me to patch my workstation's copy of vi to expand those restrictions to values I found easier to live with.
The vast majority of my career has been spent writing system software (operating system, device drivers, bootloaders, etc) or firmware. The line between system software and firmware is sometimes hard to detect. It can range from simple control loops which monitor and control hardware to what it has become today, hardware specific drivers on any one of multiple embedded operating systems, up to and including Linux. Regardless of the platform I'm working on, the ability to decode machine language remains a valuable tool for me. Since my firmware jobs often involve custom hardware, knowing how to read schematics has proved an essential skill as well.
