HomeRamblings  ⁄  GeneralProgrammingSystems

A Reflection of the Technologies I Built Things With

Published: February 12, 2017 (5 months ago)
Updated: 4 months ago

Sometimes, a random event triggers a walk back down memory lane. That moment came for me the other day when I came across a CDR containing the code I ever wrote the first 15 years of my programming career. For just over 30 years, I’ve been building software professionally and I have kept backups of nearly everything I’ve ever written. What somewhat surprised me as I looked through all this old code is the breadth of machines, operating systems, and languages I touched along the way. As I thought on this list, I wondered what all I made use of during my career and wondered what that list might look like, so I set out to compile just such a list. If I used the language, operating system, or platform and built a complete application that was deployed and used in production, I included it below. All others were left off the list (or were outright forgotten!). Believe me, there’s plenty to forget about in three decade’s time!

Languages

When it comes to computer languages, it’s sometimes hard for me to fanthom just how many I’ve utilized over the years. But one thing is definitely clear: I’ve gotten my hands dirty at every imaginable level from high-level languages most common with developers today all the way down to Assembler, Machine Code, and even microprocessor programming where I was writing my own instruction sets. When I was programming in Turbo Pascal, I was skilled enough to be able to drop down to embedded Assembler to micro-optimize various routines. Today, I consider it an accomplishment when I drop down to mere C to accomplish something with Ruby.

Some of the following languages, I truly mastered, such as Borland’s Delphi, and the open sourced Ruby language, which I’m still heavily using today. Others, I got really good with, but have abandoned. BASIC, Visual Basic, C, REXX, DOS BATCH. I’d be hard-pressed to write or debug in these languages today. There were even some languages that I produced a lot of code for, but never truly understood the language constructs for what I was writing – I was simply copying/pasting working code from an existing application, and making small changes to do my bidding.

Those included SEDL++, Smalltalk, COBOL, FORTRAN and a few others I don’t even list below. This was something I very commonly accomplished back before the rise of the Internet and true open source (anyone else remember those Walnut Creek CD’s jam packed with freeware code?). I could write a whole chapter on the art of taking entire libraries and code bases from somewhere and turning it into custom application code to solve a client’s specific need without ever actually knowing the full syntax of the language. To this day, I still learn new languages fastest by simply deep diving into a working application and begin changing it in some small way.

The languages I know, roughly in the order encountered and used:

  • GW-BASIC (MS-DOS) & Applesoft BASIC (Apple)
  • Pascal (Unix)
  • Turbo Pascal (MS-DOS)
  • C (Unix)
  • Lisp (Unix)
  • DOS BATCH
  • FORTRAN
  • COBOL
  • REXX (OS/2)
  • SEDL++
  • Intel Assembler (8088 ~ 80386)
  • SmallTalk
  • VAX Assembler
  • RISC Assembler
  • C++ (Unix)
  • Java
  • Microsoft Visual Basic (Windows 3.x)
  • Delphi
  • Visual Basic Script
  • PHP
  • Perl
  • Tcl/Tk
  • Python
  • Ruby
  • JavaScript
  • CoffeeScript

And for good measure, I have invented my own languages over the years that can be compiled or interpreted. These days, I am a very happy Ruby coder and satisified to simply build DSL’s to extend Ruby. The first language I invented was back during my college days at Georgia Tech and as part of learning how to build compilers, so it doesn’t really count. However, the second one made its way into a COTS product I built for Windows and many users learned the script’s syntaxes in order to automate building reports in Excel, MS-Word, etc.

Syntaxes

Syntaxes are not quite languages in their own right, but nevertheless heavily prominent in my path and here are some I have utiliized and mastered:

  • SGML
  • HTML
  • XML
  • Documan
  • nroff
  • CSS
  • SASS
  • Markdown

Structured Query Languages get their own list:

  • ANSI SQL
  • PL/SQL (Oracle)
  • T-SQL (Sybase and Microsoft)

Databases

Databases have long been prominent in my career. From the very first time I wrote SQL in college in the early 90’s for an Oracle 4 database on UNIX, to next using Btrieve, dBase, and Paradox on PC’s, and back to full-fledged SQL databases by the early 2000’s when MySQL and Linux started to gain momentum and made formerly expensive SQL servers affordable for any project. Oracle was truly a first-love experience for me as far as being powerful, fast, and extensible. There were so many ways to tune performance on Oracle, it took years to master them all and by the time I did, clients stopped buying into Oracle and that paved the way for me to both leave Windows, join the open source movement, and begin almost exclusively building web applications that leveraged open source MySQL and PostgreSQL databases.

As with the languages, here are the databases more or less in the order of encounter:

  • Oracle
  • Btrieve (Pervasive)
  • Informix
  • DB/2
  • dBase
  • Paradox
  • MS-Access
  • Interbase
  • Sybase
  • MySQL
  • Microsoft SQL Server
  • Sqlite
  • PostgresSQL

Network Protocols

Network Protocols are another area I’ve taken a deep dive into and have even done some micro-optimization to faster push data down the pipelines back in the day. Especially before cheap broadband became the norm. I probably learned much more about these protocols than the typical developer ever learns today since I was hacking at the packet level and using tools like SNORT to analyze network traffic to either reverse engineer an API or flush out virus-infected machines on the local network (back before anti-virus tools came of age to make this job simpler) or to identify a faulty port or switch backplane.

In the case of TCP/IP, I’ve built libraries that could perform socket-level connections and implemented some common ones like FTP, Telnet, and Gopher. It’s hard to believe I even built my own protocol to send compressed data using the smallest packet sizes across a WAN that spanned the nation, thus giving satellite offices in the days before Internet near LAN-like performance.

  • Novell
  • Token Ring
  • TCP/IP

Platforms

Platforms are a hard one for me to fully recall because I encountered so many of them over the years and I’ve frankly forgotten enough that it blurs the line between what was the OS and what was the hardware platform. Suffice to say, I’ve built things on everything from PCs and Macs to mini-frames and mainframes and that necessarily spans everything from DOS and Windows, to Unix and its many derivatives. I have simply forgotten just how many different versions of UNIX systems I’ve worked with, but I do know I got my widest exposure to UNIX in college the many, many hours spent in the campus labs in front of a terminal. Because I was both a student and employee at Tech in the Business Office, I built various tools for my boss to automate tasks ranging from simple commandline lookup tools to complete inventory/purchasing systems. The wild thing was because my boss built much the campus-wide network, he had me building tools on every imaginable platform and I didn’t even think it odd that I built something in UNIX C one day, another on AS/400 the next, followed by another tool that ran on the RISC 6000 to push data across campus to a Novell NetWare server, where I then built a Microsoft Visual Basic app to show/manipulate that data on Windows Desktops. It is only years later, and with the homogenization of today’s computing environment, that I truly realize what I accomplished in my youth and it paved the way for me to rapidly adopt and master the platforms that were to come.

When I left college, I sadly left UNIX. But fortunately, everybody was buying PC’s, so I was building MS-DOS and soon shifted to purely Windows, often building some of the very first Windows versions of “now badly aging” DOS productivity apps that never got ported to Windows. Like the dying breed of COBOL developers, DOS developers were never quite making the transition to a “more modern” approach to software development and the tools that came with Windows.

I never quite understood it but most of the DOS developers of the day almost always turned to ColdFusion instead of, say Borland Delphi, Visual C++, Visual Basic, etc. As a result, their Windows versions of their highly-successful DOS applications were near complete busts more often than not.

So what’s my platform list? Say no more:

  • MS-DOS & PC DOS
  • Mac OS
  • UNIX 5
  • OS/2 (IBM)
  • TS04 (IBM)
  • OS/VS2 (IBM)
  • MVS (IBM)
  • OASIS
  • SunOS
  • VM/370
  • AS/400
  • AIX
  • Linux
  • FreeBSD
  • Novell NetWare
  • Microsoft Windows 1.x => Present
  • Microsoft Windows NT
  • Solaris
  • OS X

Reflecting back on the platform shifts in my career and seeing whole groups of developers fall on the wayside, I definitely consider myself blessed to have started with UNIX, then transition to the forefront of Windows development and then shift again after Y2K to Linux and open source to build web applications. When you think about it, there’s not a whole lot of similarity between terminal-based systems that draw their entire screens with escape sequences and DOS applications that you could directly draw on the screen to Windows based systems that are API/event driven to web applications that are browser/presentation driven. It’s ironic that with the rise of the smart phone, we’re now shifting back to a richer client experience with powerful Javascript-based front-ends that make browser-based apps feel like native rich client apps.

comments powered by Disqus