Programming Languages I’ve Loved And Hated

Upon encountering various programming languages during my career, some appealed to me instantly, while others left me cold. I never really understood why, but perhaps by writing about them, I can discern a pattern.

This article originally appeared here and has been updated to include Kotlin and Rust, along with photos of important books of the time.

My first language was academic

PL/C: This was the first language I learned. Structured, imperative, and procedural, PL/C was Cornell’s teaching variant of PL/1, and the language shaped much of my thinking. It was a good language, and I liked it, but it was also an academic language and one I would never see or use again.

A practical language which I hated

Basic (IBM PC): It was hate at first sight. The language relied on line numbers, needed GOTOs, and was interpreted. But it was early in the PC days and I had to use it if I wanted to do anything useful. In time, Basic became a compiled language and eventually evolved into Visual Basic for Windows programmers. But even then, Visual Basic 1.0 did not directly support arrays, an omission that convinced me that Basic would forever be a dumbed-down language.

Wow! Assembler was an awakening.

8088 Assembler: Instant love. Before this, a computer to me was hidden away in a refrigerated room and guarded by a wizard (sysadmin). 8086/88 Assembler was the language that opened the doors to the internals of the PC. It was a joy to access RAM, video memory, disk drives, and the BIOS itself. I built binaries first with the shareware compiler CHASM (CHeap ASMembler) and later moved onto Microsoft’s Macro Assembler. While far from a structured language, I learned to organize my code neatly, use meaningful labels, and be aware I could not JMP more than 128 bytes because of Intel’s segmented architecture. Some of my contemporaries disliked Intel’s use of segments, especially if they were experienced with Motorola’s linear address space, but I had no qualms about it.

Grogono’s book was the standard for Pascal

Turbo Pascal: Pascal brought back memories of PL/C. The two shared a family resemblance in a Grandpa, Grandson way. Borland made it possible for me to explore Pascal by selling an inexpensive compiler for about $50, but as much as I liked Pascal, I never found an opportunity to use it professionally.

The Classic K&R White Book

C: Love at first sight. It had the high level structure of Pascal and the low level access of Assembler. I’ve written much about this language while reviewing K&R’s The C Programming Language.

The Third Edition has the best cover

C++: Love / Hate. I loved classes, and the concepts that came with them: public, private, and protected variables, pure abstract classes, and default arguments. I felt neutral about inheritance. I hated exception handling because it took flow of control elsewhere. I hated templates because they were more suitable to library writers than everyday programming. And I hated references, because they were syntactic sugar, and obscured the true nature of a variable. Preferring “&” and “*”, these symbols alerted me that I was treading in memory territory. I did, however, love C++ in that I did not need to use the features I hated, subject to the office culture of course.

Lastly, I was open to object-oriented programming, but hated the way C++ was always the answer (circa 1990). Linus Torvalds developed Git in C, and I am on his side when he famously went on a rant in response to someone who argued Git would have been better written in C++.

JCL, the first scripting language

Ksh / Bash / Zsh / Csh: Easy to learn. Easy to love. Shell languages fit seamlessly with the Unix philosophy of pipes, filters, and redirection. The down-side is that there are many dialects, each with their own quirks. And when upgrading to the next version of Unix or Linux, the shell behavior can change in subtle ways and break existing code. Shell languages, despite their ease of use, aren’t very portable.

Above is my old JCL reference book for the IBM 370 Mainframe. I didn’t use JCL much, and when I did, it wasn’t much fun. Nevertheless, it has a place on my bookshelf for being the first scripting language.

One of the authors is a friend. That didn’t help me love the language.

Java: The opposite of love isn’t hate. It’s indifference, and that is how I felt about Java. The language never inspired me to look deeper, to learn its capabilities. I didn’t subscribe to the write once run everywhere credo, as the reality was closer to write once, debug everywhere. That wasn’t Java’s fault though, as not all browsers — namely Microsoft IE — followed web standards. Automatic garbage collection didn’t appeal to me either, as I appreciated — even needed — the symmetry of allocating and freeing my own memory, of closing files I opened, of constructors and destructors. Anyway, I don’t know Java well enough to comment further, but perhaps one day, I’ll take another look.

Perl: First impressions count, and Perl was a language that could be either pretty or ugly. Unfortunately, my first assignment with Perl involved maintaining a script that was pretty ugly. Despite later seeing examples of well written code, I was scarred and preferred to work in Ksh and use Unix / Linux tools. And then I discovered Python which could do everything Perl could do, but better.

Python: A breath of fresh air. It could be object-oriented, or it could be procedural. Use it as a script, or use it for something substantial. Python has extensive library support. With respect to the grammar, I liked that space mattered as a way to enforce neatness and readability. Unfortunately, that very feature put off some of my colleagues, including the author of the Java book above.

Swift: “Tailored” for iOS. Love. It’s very similar to C++, but without the baggage and awkward notation. Using Swift instead of Objective C, I have released two iOS apps to Apple’s App Store: Limit Up Limit Down Calculator and MR2 Check Engine.

Kotlin: Useful for developing Android apps. Using Kotlin instead of Java, I have released two Android apps on Google Play: Limit Up Limit Down Calculator and MR2 Check Engine.

Kotlin is similar to Swift, but I enjoyed developing in Swift more. You can read more in my article Swift vs Kotlin.

Rust: A curiosity to me. Proponents breathlessly tout Rust as a secure and memory safe language, adding that C/C++ is not. Repeatedly. This leaves the impression that Rust is a one trick pony, and a defensive one at that.

I know Rust has more going for it, including great concurrency handling, and a superior cargo / build environment. Memory safety is not its only super power, and I wrote about it in Rust’s Other Super Power.

For now, I am lukewarm toward Rust.

Any languages you’ve loved or hated? Leave a comment below.