Ah, the languages that I’ve loved, used, known, or met well-enough in passing to code in them. Also, some I met just long enough to share a cup of coffee with but are worth mentioning.

[11/01/2015: Got bored and stopped for now. Will resume later.]
[04/19/2020: Having another go, but still not finished. (This is boring!)]
[10/13/2022: Jumping back in again. Still not quite done but close!]

Ada: A brief very casual acquaintance via a mutual tutorial, but I did write and compile several small programs. Ada is worth knowing about for the lengths it goes to in trying to support error-free code. It’s heavily typed with many built-in protections.

Also: Named after the First Lady of programming, Lady Ada Lovelace.

ALGOL and PL/I: Very old languages that date back to my college CS days. Two of my first contacts with programming languages! We mainly used them for written coding assignments.

Algol is notable in defining an entire class of languages (C, Pascal, and Java, are all Algol-like languages). It’s one of the first early major computer programming languages.

PL/I was cool for being a massive language with some surprising data types. For instance, it had a tree data type! It was said that very few coders ever learned the entire language (the same might be true of Ada, another massive language).

ASM (Z80, 6502, 8086, MIPS, MIX, 68HC11): I first encountered assembly — as MIX — in my college algorithms class, which (of course) used The Art of Computer Programming, by Donald Knuth (or the three volumes that were out then).

That led to a lot of lines of code in Z80, 6502, and 8086 assembler in my early days. My later encounters involved MIPS and doing some development at work against the 68HC11.

Working at the assembly level is awesome and extremely educational. Most of the best programmers I’ve met have done assembly work of some kind. I highly recommend it for any serious programmer. It really helps you understand how the computer works.

BASIC (Data General Nova, Sinclair, BASICA, GW-BASIC, Commodore 64 and 128, True, Quick, and Visual): Pretty much since the beginning, and up until very close to the end, some form of BASIC has been part of my main work.

It started with college work on the DG, continued with the Sinclair and Commodores, and really got involved when PCs came around. A good chunk of my professional work was done in VB.

It wasn’t until I was in a serious Java and J2EE web app environment that BASIC started to fade from my life. By the last few years at work, it was all but gone.

BOOL: Yes, it’s my own made-up language, but considering all the time I’ve invested in it, and how many lines of code I’ve written in it, it’s definitely one of my languages.

Someday there might even be a compiler for it! 😀

[I finally gave up on BOOL. I’m no longer maintaining the Book of BOOL blog. I held a five-day wake on my main blog. See Mon, Tue, Wed, Thu, and Fri.]

While I’m mentioning my own languages: DL (Definition Language) and DDL (Data Definition Language). Maybe someday I’ll post about them. They’re very simple. [Update: I finally did!]

C and C++: C was the first compiled language I spent a great deal of time with. I wrote hundreds of thousands of lines of C. I got into C++ fairly early in its life cycle, because I was fascinated by how early C++ compilers were just front end processors that spit out C code (cfront).

(If you know my last name and search the archives, you’ll find I was a regular in the USENET comp.lang.c newsgroup.)

COBOL: I never wrote a line of COBOL, but I was once given the task of reverse-engineering a COBOL program into some other language. Mostly it’s listed here because it’s the only computer programming language I’ve ever used to pick up a gal (long story).

Eiffel and Erlang: Two languages I met at a party and someday want to get to know better. Added to this list as a reminder. (I did briefly look into Erlang but wasn’t very whelmed. Something about the language put me off, although I can’t recall exactly what that was now.)

Forth: Fascinates me for how it works (the stack). I used the basic idea behind Forth as a key architecture note in BOOL (see above). It’s also cool in that Forth is used by astronomers to program their telescopes.

Fortran: Another language I never wrote in but needed to know well enough to reverse-engineer programs written in. (Such a conversion of a Fortran program to C resulted in one of the (fortunately rare) major fails in my career. The original code used massive data arrays C didn’t support, and it was early enough in my career that I wasn’t up to engineering virtual disk space.)

GRIP: An obscure graphics programming language for old Unigraphics CAD/CAM software. So lost to history that it barely exists on the web.

Haskell: One of several explorations into purely functional programming languages (which I still haven’t wrapped my head around enough to write really good code for). I’ve got a compiler and language manuals; Haskell is mostly a future project.

HTML, CSS, JavaScript (DOM and AJAX), ColdFusion, http: Web pages and web apps. A lot of these over the years starting with my own website back in the early 1990s. I still write my own HTML on that site (although I haven’t done much with it in a long time).

A great deal of this was done through work, especially in conjunction with Java and J2EE (see below).

I might also include SGML here, since I explored it to understand HTML better.

Java and J2EE: In the latter stage of my career, most of what I did was in Java, a language I didn’t take seriously at first but grew to love. After many years of assembly and C programming, Java was a pretty friendly face. I ended up writing a lot of lines of Java code. It became one of my primary languages.

I did a fair amount of J2EE programming for some outward-facing corporate web applications for the CRM group at The Company. And a lot of library and framework development. I’m especially proud of the DataBridge and DataCollector applications. [See DataBridge, DataBridge Drivers, DataCollector, and DataCollector Factories.]

IBM JCL: A nightmare of a language used to provide the IBM mainframes with information needed to launch and execute a program. It’s an ancient, obsolete, massive language that was cryptic and difficult. I needed for the IBM 360 at my college. Never gone near it since.

Lisp: A language that’s beyond cool. First time I’ve ever laughed out loud with delight while reading a programming manual. “Lisp does that? HA!”

I never used it productively, but I wrote a fair number of Lisp lines playing around with the language. It was so much fun. And all those parentheses had a certain visual geek appeal. I’ve used the basic construction of (verb data) in other languages. It’s a powerful paradigm, data structures where the first member defines its kind or class.

I should write a post about the MasterMind program I wrote in Lisp!

Microsoft BATCH: I wrote more than enough lines of BAT code to include this on my CV. In fact, I’ve written articles about BATCH programming for an inhouse company newsletter. It’s a surprisingly powerful language once you dig into it.

I still use it from time to time but nothing like back in the day. No doubt will so long as I use Windows.

Microsoft COM (“ActiveX”): I read in a book once that “ActiveX” is a term that means “Microsoft! Warm! Good! Fuzzy!” and almost nothing else. In general, it refers to the Component Object Model that allows rather awesome automation of Microsoft products.

I used this a lot, most from within Visual BASIC, to build Word documents and Excel spreadsheets on the fly. It allows you to do just about anything a user using the product could do.

Of course, with awesome power…

MS-DOS and TSR apps: After college, mostly all I had were the IBM PCs I owned (often built from parts). And at first, mostly what was freely available as far as languages. Microsoft’s MASM was available through work (we serviced IBM PCs for a while back in the day), so I did a lot of work in assembler.

And had a lot of fun with TSR apps. I did one for use at work, and it drew attention to my software skills. The Company had until then seen me in hardware and teaching roles. It was arguably that TSR app that switched me to the software track.

Pascal: A friendly, simple little programming language. Encountered in college and many times since, almost always in illustrations of some algorithm. I had a Pascal compiler for a while, but never wrote much code for it. I’d already gotten into C, which seemed much more powerful.

Perl: A jewel in my tool kit… until I discovered Python (see below). Perl is a language one can love for its power and flexibility, but loath (or love) for looking so ugly. (Perl programs often look like line noise got into the transmission.)

That said, Perl’s ability to do what you meant is impressive. It’s pretty funny how often you can guess at what a Perl program should be, and Perl figures out what you meant. I did love it for many years (did some PHP coding, too), but I don’t miss it. (That said, it’s worth knowing because PHP is still in use.)

Prolog: This is another language I only met in passing but would like to get to know better. It’s a very different approach to coding — oriented on problem solving, on matching goals.

Python: The only other language (besides Lisp) to inspire my undying love, regard, and fascination. Python is wonderful! Since I retired, just about all my programming is in Python. [I’ve written a number of posts about Python features.]

Regular Expressions: A key piece of advice for anyone who wants to be a programmer is to learn regular expression syntax. It pops up in all sorts of tools. [Finally posted about them!]

Ruby: (Not the same as Ruby on Rails.) Another ship that passed in the night. I only saw the glimmer of its lights on the horizon. Maybe someday we’ll meet again.

Ruby on Rails: Almost needed it for something I was doing once. Started looking into it but decided it was more involved than I wanted to pursue.

Smalltalk: If there was ever a language I wish I’d gotten to know better, it’s Smalltalk. I’ve dabbled with it, but (as with Haskell) didn’t get into it enough to really wrap my head around the paradigm. I’m not sure I’m entirely down with the whole Smalltalk environment thing.

One thing I did take from Smalltalk culture is a view of code as a living thing that evolves. The Smalltalk way of making small tweaks to improve your tools is exactly how I operate.

SQL (and ODBC): It’s an open question: Have I written more SQL queries or for-next loops in my career? I think it’s a close contest. I’ve done a lot of SQL.

One of my favorite challenges for my Unix-loving, Microsoft-hating, friends was a common task from my CRM days. A manager wants to show some up-to-date live data in a meeting. Said manager, of course, should have no ability to change the presentation, let alone the data. Given their data query, in under half an hour, I could: [1] write an SQL query to access the data (using ODBC on SQL Servers); [2] embed the SQL in an Excel spreadsheet for automatic data population of a table; [3] use the table data to make a cool chart; [4] link that chart in a PowerPoint presentation I give the manager. All the PowerPoint can do is follow the link to the chart in the spreadsheet (which I control and make available on the network). But when it does so, it forces a refresh of the chart, the table data, and the SQL query. Live up-to-date data in a nice chart the manager can’t break!

TCP/IP: Not exactly a language, but a protocol one has to know if one is going to write TCP server/client apps. Which I got into for a while. It’s a nice skill to have. Provides an interesting option for inter-application communication — link through sockets.

Unix shells (sh, ksh, csh, bash) plus awk, ed, and sed: I spent about eight years in the Unix world as my primary environment. Since I ran Windows at home, it required some hoop jumping to move work back and forth. I was writing a lot of C code then, and the MS-DOS and Unix C environments have notable differences.

But I came to learn why my Unix friends thought so little of either Microsoft or Apple. (Neal Stephenson has a great parody of this in this booklet-length essay, In the Beginning… Was the Command Line.) Unix really is awesome in many, many ways. But see above for my challenge to Unix.

XML (XSD, XSLT, WSDL): There is, on the one hand, the XML notion, which is quite easy to learn, and on the other hand, the many well-established XML dialects, such as WSDL. And a ton more. XML is just as ubiquitous as HTML. Both have turned out to be wonderfully useful.