Programming Languages I've Loved and Hated

Programming Languages
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.

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.

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, the first version of Visual Basic did not directly support arrays, an omission that convinced me that Basic would forever be a dumbed-down language.

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 Assembler) 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 the 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.

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.

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.

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¹.  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++.

Ksh / Bash / Csh: Easy to learn. Easy to love. It fit seamlessly with the Unix philosophy of pipes, filters, and redirection. The down-side was that there were many shell languages, 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, weren't very portable.

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 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.  It has extensive library support.  And 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... perhaps that rogue Perl programmer too.

Swift: "Tailored" for iOS. Love.  It's very similar to C++, but without the baggage and awkward notation.  Figuring out Apple's Xcode GUI was harder than learning this language.

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

¹ Car guys and gals know Miata is always the answer.
² I know, pythons kill by cutting off air supply.


schafdog said…
Like your list and not that different from mine.

But I totally agree that Miata is always the answer!

Just parked my MX-5 after 4 hours of driving in the spring sun in Denmark.
Michael Yam said…
@schafdog -- Wonderful! The Miata was on my list, but my son steered me (us) to a 1991 MR2. Now I need to work it into a blog post.

Popular posts from this blog

Post Processing: Swift, Kotlin, Team Scaling Fallacy, Levandowski

Programmer Humor for the Holidays

Apple's Busy End of Year