TL;DR

This is the first of a series of posts on various programming languages, including where I believe each fits into the scheme of things. To provide context for all the posts which follow, it starts with my personal, academic, and professional background regarding programming languages.

A programming language is any set of rules that converts strings, or graphical program elements in the case of visual programming languages, to various kinds of machine code output. Programming languages are one kind of computer language, and are used in computer programming to implement algorithms. https://en.wikipedia.org/wiki/Programming_language

I have a love of languages. When someone asks me what languages I know, I typically answer "human or computer?". 😀

I am Dutch by birth and blood. I was born in The Netherlands but grew up in the United States. Both of my parents grew up studying 4-5 languages. We spoke Dutch at home when I was young. I, of course, studied English in school and had very good teachers throughout my childhood, especially in high school. In middle/high school and college, I studied Spanish. I lived in the Spanish wing of the Foreign Language Floor in our dorm my freshman year. I even took a few basic classes in Russian later in college, though I have long since forgotten that unfortunately. And being married to a Brazilian, I have spent many years also working with Portuguese.

But this post is not about those kind of languages. This is about the other kind.

How It All Began

When I was 12 years old, my father brought home a Commodore PET 1000 computer. This was our first personal computer. 8KB RAM. Built-in audio cassette drive (for storage). Chiclet keyboard. Built-in 40x25 monochrome text screen with green letters on a black background. Little did I know then that this would be the start of a lifelong love of all things computer related, and especially programming languages.

Childhood

I taught myself Commodore BASIC on that PET system, mostly writing silly little programs like one that made a Saturn V rocket (that I painstakingly created using ASCII characters) scroll up the screen as if it were taking off. Mind you, this was pre-Google, pre-Web... heck, pre-public Internet. This meant that you were wholly dependent on whatever documentation you got with the computer or could scrounge. Back then there weren't even general books available like you have now in Barnes & Noble and other bookstores. In fact, the very idea of "computer stores" was still in its infancy.

Yet BASIC (Beginners All-purpose Symbolic Instruction Code) was easy enough even for this 12 year old to learn. A few years later we got an Atari 1200XL, which came with Atari BASIC. Unlike Commodore BASIC, Atari BASIC had extremely easy keywords for drawing on the screen like COLOR, LINE, and DRAWTO, not to mention SOUND for generating sound. Compare this to Commodore's expectation that you learn to properly PEEK and POKE the right memory locations to effect changes.

College Years

Undergraduate

That Atari 1200XL went with me to college, where I initially studied Aerospace Engineering. And in my freshman year I sold that computer (to my everlasting regret), having replaced it with an Atari 520ST which ran TOS ("The Operating System") and had GEM (Graphics Environment Manager) for its GUI (all stored in a hardware chip). I also had a 1200 baud modem that connected directly to the wall jack in our room via an RJ-11 splitter I bought at Radio Shack. This made my dorm room setup 4x faster than the "computer room" (a.k.a., closet with a foldout table, single DEC VT220 terminal, Bell telephone, and 300 baud acoustic coupler modem) that was in our dormitory. I also had a VT100 emulator, giving me full-screen editing capabilities at home, when most of the computer labs on campus were made up of DEC VT52 terminals that only supported line editing. (If you don't know what that is, consider yourself lucky. For others, remember edlin? 😀) Thankfully I missed punch cards at our university by a few years.

By this time, I had taken my first BASIC and FORTRAN 77 programming classes, both on the VAX/VMS systems that the engineering college used. Halfway through my sophomore year, after a semester taking 22 credit hours and averaging just 4 hours of sleep a night, 7 days a week, I finally came to my senses.

You see, I always expected to use computers. I just figured they would simply be a tool serving me in my real purpose. Like many young people who have looked to the sky and thought, "I want to go THERE!", I wanted to be an astronaut as a kid. Researching what that entailed, I found that many astronauts came from the U.S. Air Force. So my plan was to get into the U.S. Air Force Academy, become a pilot, and later shift over to NASA.

Then I got my first set of eye glasses when I was around 16 (likely due to all the time I spent in front of CRT computer monitors). Well at that time, even if you got into the U.S. Air Force Academy (yes I was a bit delusional that I could achieve this), the stats indicated that, out of the incoming class of around 2000 freshman, nearly 1/3 dropped out within the first year. And of those who graduated, only around 1/3 became pilots. And as I needed corrective lenses for nearsightedness, that meant, AT BEST, I could be a navigator. And my odds were so low it simply did not make any sense.

So this was Plan B. Study Aerospace Engineering and work my way in "through the back door." I was so sure of my plan that in high school I even engineered my answers on the various standardized tests such as the ASVABs to land my results on "aerospace engineer" (and they did!).

But in the fall of my sophomore year, following the college handbook's recommendations, among other classes I took a class called MAE (Mechanical and Aerospace Engineering) 12: "Introduction to Aerospace Engineering" with Dr. Palmer. What I only found out much later, however, was that this was no introduction. When I spoke to other engineering students later, they all went wide eyed and said, "Are you NUTS?! You signed up for Palmer's MAE12?! Everyone knows you don't take that class until the last semester! He throws the kitchen sink at you in that class!" Only I did not know that. And thankfully, in the end.

You see, what I did not know--which other students with either older siblings or parents who had been to college and knew the system better did know--was that the sophomore year in engineering there was considered "the weed out year". This was when they threw the book at you, trying to get you to quit. And not knowing this, I had doubled my stupid by signing up for not a single "blow off" class that semester. That is, I had 22 hours of rock solid classes, all requiring work.

That semester I cratered rather badly. But in the end it was the best thing to happen to me. It made me realize that the thing that really brought me joy was the time I spent on the VAX/VMS systems "hacking around" in the middle of the night. And it occurred to me, "Hey! I could get PAID for this!"

So I switched majors from Aerospace Engineering to Computer Science. (At that time the engineering college had no Computer Engineering program. The options were either Electrical Engineering or Computer Science over in the College of Arts & Sciences in the Statistics & Computer Science Dept., where most of my professors came from a mathematics background.) And in my first few years of CS classes, I studied IBM's PL/1 (the base language they used in the CS program), VAX Assembler, and later C. I had a C compiler for my Atari 520ST, though what I really remember was using Borland's Turbo C for our class where we had to write an operating system. We also had a class where we had to write a compiler (also done in C). And this was when I took my first database class, back at a time when Oracle ran on the VAX/VMS and did not even have table level locking, let alone row/field level locking, referential integrity constraints, or any of the features that are just taken for granted today. Everything you wanted to enforce/do you had to do using scripting in Oracle Forms (think PL/SQL). And, of course, this was when I first learned SQL.

Somewhere in all this, I had paid out of my own pocket to attend a one day training class called the "Borland OOP World Tour", mostly because it was the cheapest way to get a copy of the Borland C++ compiler. This is where I first learned about C++ and--after spending half the morning as Bruce Eckel taught thinking to myself "What is the big deal? You can do most of this with structs. What's so special about OOP?"--had my "ah HA!" moment regarding the potential benefits of object-oriented programming. I ended up with a B.S. in C.S. I then took the GREs, was accepted into the Masters in C.S. program, and landed a graduate teaching assistantship (GTA) position to pay my way through school. In the time between graduating and starting my Masters, the CS program was overhauled. They added in all kinds of requirements, including comprehensive exams, analysis of algorithms, and more.

Graduate

My first semester in grad school I taught Ada to incoming undergraduate CS students in the lab portion of their class (basically reading about a chapter ahead of them as I taught). The next semester I was "promoted" to teaching the second semester lab, and so on each semester. In the end I taught the labs for all the basic courses that undergrad CS majors took in their first two years. In fact, I had a few of the same students go through all of these classes with me as their lab instructor. (I put "promoted" in quotes because I had to create all the assignments, labs, quizzes, and tests each semester. So there was nothing promotional about having to start all over again, as I could not re-use any of my material. But in the process I learned as well, so I was fine with it. I find that teaching something helps me learn and refine it better myself.)

In my own coursework, I continued taking various classes, including one specifically about programming languages where we had to write programs in 10 different languages during the course of the 15 week semester. (Luckily the first half of the languages I already knew. So only when we were dealing with languages like Lisp, Scheme, and Prolog did I really have to buckle down. And no, I don't count those languages among the ones I truly know.) I took another class with a visiting professor (whose family I befriended), who was passionate about Simula, learning its role and influence on languages. I also took a class involving Java when it was still in beta (i.e., before it reached v1.0). And then there were other classes like the graduate level database class where we learned about Gemstone and other object-relational databases and their esoteric querying languages.

... And Beyond

Along the way and afterwards, my interest in programming languages continued. It was never the direct focus of my professional life. It was just something that was part of what I did. In fact, I never considered myself a programmer, as to me a programmer was someone who was paid to code 40+ hours/week. For me programming was "duct tape". I used whatever language was relevant to the task at hand.

In college I taught myself various batch processing languages from MS DOS .bat files (after I got my first PC) to VMS batch files (to create MS DOS-like commands when working in the VMS system), and later the various shell scripting languages used in the various *nix shells (e.g., Korn shell, Bourne shell, C Shell, etc.). During my college summer months I worked in my father's international shipping company, where I learned DQL (DataEase Query Language) while writing database applications, CPL (the scripting language for PRIMOS, the operating system that ran on the PR1ME computer there), and the scripting language in SuperCalc (the spreadsheet program they ran on the PR1ME), among others.

In grad school, after a friend introduced me to IBM's OS/2 Warp where I lost 3 nights of sleep, I eventually learned some REXX scripting to leverage the ZOC terminal program I used for all my TELNET/SSH needs. (I returned the favor by indoctrinating him into the world of Linux, which cost him 3 weeks of sleep. 😀)

Of course, the Web came into existence along the way. So there were the obvious languages like HTML and later XML which, though not programming languages, are a form of computer language. And then there was JavaScript.

As the years rolled on, I would learn whatever language I needed to in order to get things done. This included, but was not limited to, PHP when it had just reached v4 (which I wanted to use to replace the proprietary ASP code and MS FrontPage Server Extensions), Perl (initially to work with Infoblox NIOS that, back then, only had a Perl API), Lua (which I found to be used in various tools from nmap to Ethereal/Wireshark and more), Python (once I finally got past my apprehension of "format affects logic") as it is the main programming language in the networking space, and my latest acquisition: Go/Golang. There is also YAML, MarkDown, JSON, and others for the non-programmatic side of things. In between I also looked into other languages, such as Erlang (a functional language) when tinkering mostly in the VoIP (FreeSwitch/2600hz Kazoo) and IM (ejabberd) spaces, but those I don't claim any expertise in as I never truly wrote code in them.

The truth is, I could write a good bit about almost any of these languages and more. Mind you, I am by no means an expert in any of these languages the way that a professional programmer, who has spent their career only coding in one of these languages, should be (at least in my mind). But I do have an appreciation for where each of these languages fits into the pantheon of programming languages. And I believe I can hold my own where it matters. And this is where this post comes in.

Computer/programming languages pervade much of what I do, even though my job title has never had "programmer" in it. I built this blog site using Grav, which is written in PHP and stores pages in MarkDown and generates the appropriate HTML. I have modified my site with some Twig templating (which is very similar to Jinja2). I spend part of my professional time coding in Python, using various modules/tools including Django, Netmiko, and Ansible, along with AdminLTE and various Jinja2 templating there. My database background finds me using SQL in various places, often leveraging SQLite (it's just so easy), PostgreSQL, or MySQL/MariaDB. And my latest foray into Golang includes using the Fyne.io toolkit and expanding my range there.

And in all this I dig into where these different languages fit, both in my own work and in general. My philosophy of "right tool for the job" influences much of that. I chose Grav specifically because it was a file-based CMS that used MarkDown, as opposed to the 800 pound gorilla in blogging, WordPress, which stores all its content in an RDBMS like MySQL. Grav allows me to grep for information if needed, and I can simply tar/gz or ZIP up my site and copy it elsewhere. For while I genuinely hope something on this site is of use to others, it is as much a "brain trust" of sorts for my future self to reference when needed.

Today I use Python for most of my scripting needs, as it is one of the fastest languages to code in and has immense library support, especially in the networking space. And Go is likely to become my go-to (no pun intended) language for those solutions where a single, independent binary makes the most sense. (More on this in another post.)

This is my background, at least for now. I am sure I have forgotten a few languages, but this covers the broad strokes. And I will likely learn others, but I can't predict the future. But as I often find myself discussing one language or another, I figured I might as well lay the groundwork first.