Monday, April 28, 2014

Another gray-haired programmer ...

Another gray-haired programmer ... describing what his early days as a programmer were like.  Most programmers my age seem to have similar experiences. 

My own programming beginnings were much different, primarily because I had no access to programming tools (compilers, assemblers, linkers, debuggers, etc.).  In the early '70s I began programming on Univac “mainframe” computers owned by the U.S. Navy.  These were in a lab used for training repair technicians.  The only way (initially) to load a program was by using the switches and lights on the front panel to load the program's machine code, one 30-bit word at a time.  I wrote that code on lined paper, assembly mnemonics on the left, octal machine code (hand-assembled!) on the right.  When I modified code, to avoid re-assembling all that by hand, I'd put a jump instruction at the first modified line of code, to jump to a patch that implemented the change, and then jumped back.  After a few rounds of debugging, my code could be quite a mess :)

Later, out of sheer desperation, I developed my own software engineering tools.  At the time, I had no idea that better tools existed elsewhere; I was just trying to save myself from the tedium of manual machine code entry.  I developed tools that were the rough equivalents of monitors, loaders, assemblers, debuggers, and linkers, though I didn't know them by those names.

I went through the same sequence when I first started programming microcomputers, in 1975 – though by then I knew of the existence of commercial tools.  However, those tools generally ran on minicomputers (like the PDP-11) that I had no access to and couldn't possibly afford to buy.  Even the software tools were out of reach financially.  So once again I wrote my own tools, for several microcomputers (especially the Motorola 6800, RCA 1802, Intel 8080, and Zilog Z80). 

Today very few people would consider writing their own software development tools.  For one thing, excellent tools are readily available on the Internet for free, thus removing all the things that might force one into writing one's own tools.  It's also true, though, that the tools have become far more complex as the CPUs have become more and more powerful.  In 1975, one could write a functional assembler in a few hundred lines of code over a week or two.  A really nice compiler might be three or four times that effort.  A nice assembler for today's Intel chips would probably take several years of work.

I've often noted that having had the experience of writing my own tools gives me a much different perspective on programming than many younger programmers have.  Mostly this manifests in having a reasonably good understanding of how those tools work, whereas for many perfectly competent programmers, the mechanism by which their (say) Java source code actually gets executed is a complete mystery – and one which seldom needs to be explored...

No comments:

Post a Comment