On the Shoulders of Giants

One of the major differences between when I learned to program (in FORTRAN) and now is that there are more APIs (Application Programming Interfaces) to learn and use. Back in the day – ahem – when we were programming on punch cards or, at the height of technical bliss, a line terminal, we were using some system calls to do I/O (input/output) and a few other things, but that was basically it. There were some niches like graphics terminals that required libraries of functions to place dots of specific colors at a specific location on the screen, or pen plotters that required similar libraries to select the appropriate pen and then move it in one axis as the paper moved in the perpendicular axis.

It seems that the libraries of long ago were the harbingers of the APIs and function calls of today. And those today are not limited to the local machine – there are web APIs and cloud functions that can be used if there is an Internet connection available.

Another difference between then and now is the existence, quality, and availability of tools. Back in the Dark Ages (well, early 1980s) I finally moved from card readers to line terminals (the venerable DEC VT-100, to be exact) connected to a minicomputer somewhere in the bowels of the basement or some other out-of-the-way space. Using an editor called EDT on a VT-100 terminal was absolute bliss (for the time), and I got to the point that I could almost do minor edits in my sleep. By the late 1980s I had an IBM PC/AT in my office, but I was still using the VAX via a VT-100 emulation program for the PC. On the PC itself I was using MicroEmacs as my editor and either Microsoft’s or Borland’s C/C++ compilers, dBase III, Lotus 1-2-3, WordPerfect, and other esoteric programs.

As the years went by, Borland’s Turbo C/C++ faded into obscurity, and Microsoft’s compiler morphed (slowly) into the Visual Studio of today. Microsoft’s Word, Excel, and Access (their desktop database program) also eclipsed the competitors, and eventually became the basis (as far as I can tell) of Microsoft Office. The number and quality of applications available for the PC increased pretty quickly, while the quality and availability of development tools seemed to languish. It’s not that they weren’t improving, it’s just that progress paled in comparison to the explosion of other software. I remember reading articles written by computer journalists at the time who compared the situation to the “Cobbler’s Children’s Syndrome” (no Wikipedia article that I could find for this). Apparently, most professional developers were spending most of their time developing business software instead of creating software for themselves, much like the cobblers of the nineteenth century spent their time making shoes for others to buy and somewhat neglecting their own families’ needs.

My responsibilities expanded and changed over those years as well, so that by the beginning of the 1990s I was doing little coding. I did occasionally get an opportunity to do some lite programming, but I used the editors and compilers I already had available and with which I was already familiar, so I generally missed the gradual improvement in the development tools situation. I had heard about “context sensitive editors,” and I was familiar with tools like Revision Control System (RCS, an early source code control system), “make” (an early build automation tool), and various pre-processors (which I think were inspired by the preprocessor that was part of the C language), but I largely missed out on the revolution in tools that came with widespread availability of the so-called WIMP (Windows, Icons, Menus, Pointers) interface that is ubiquitous today.

I did get a taste of the future of development tools around 2005 when I did a project in Java using the NetBeans IDE. While a bit primitive by today’s standards, I was amazed by how easy it was to use and how much it streamlined the process of writing code.

Still, when I began the srcCraft project, I was overwhelmed (I hesitate to use the word “shocked,” but it’s not too far off) by the selection and quality of the available development tools. So much so that I searched for and read/watched a few blog posts/YouTube videos comparing some of the frameworks that looked interesting. This is not the post to get into the details of what I finally settled on using; the purpose of this post is to acknowledge the insight and effort of the visionaries who created the amazing variety of high-quality development tools available today.

I am reminded of the “standing on the shoulders of giants” quote that is often attributed to Sir Isaac Newton, but evidently predates him. The only reason I can do this project (srcCraft) is because of the giants on whose shoulders I now stand.