Language List

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.

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 (and JCL): Very old languages that date back to my college CS days. 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).

I’m lumping JCL in with these largely because it comes from that era of my career and because it’s an ancient, obsolete, massive language that was cryptic and difficult.

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.

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.

Some day there might even be a compiler for it! 😀

While I’m mentioning my own languages: DL (Definition Language) and DDL (Data Definition Language). Maybe some day I’ll post about them. They’re very simple.

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: Forth fascinated 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.

[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!)]

HTML, CSS, JavaScript (DOM and AJAX), ColdFusion, http: Web pages and web apps.

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 did a fair amount of J2EE programming for some outward-facing corporate web applications for the CRM group at The Company.

IBM JCL: A nightmare of a language used to provide the IBM mainframes with information needed to launch and execute a program.

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!”

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.

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:

Pascal: A friendly, simple little programming language.

Perl: A jewel in my tool kit… until I discovered Python (see below). It’s a language one can love for its power and flexibility, but loath 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.

Prolog: This is another language I only met in passing but would like to get to know better.

Python: The only other language (besides Lisp) to inspire my undying love, regard, and fascination. Python is wonderful!

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.


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.

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.


Unix shells (sh, ksh, csh, bash) plus awk, ed, and sed: