Thoughts on programming languages

<3 <3 <3 CL is what every programming language should be. RMS once said that you don't know what an elegant language is if you haven't tried CL, and I'd reduce that claim to just CL. Whilst Scheme is too simple for its own good, or at least when you actually want to make something and not just jerk over your language in academia, CL is really the sweetspot for a language that is very elegant and beautiful in a mathematical way. You've heard this already a thousand times, so I merely urge you to try it out and judge for yourself. On that note, even though CL is very complex and compilers like SBCL compare to C compilers in complexity, the core principles are still very simple. Everything is a list and as such the compiler will just evaluate lists, which makes the syntax more pseudocode-like and easier to parse for both the programmer and the compiler. The macros are a very powerful feature of the language and they cannot be compared to compared to #define macros in C, not only because they are so much more powerful, but also because they are not just an afterthought and something that results in ugly hacks, like with

1. Suppose you want to write an emulator, you will find that in CL you

can use defmacro to combine semantically similar opcodes under one macro, meanwhile the only comparable feature in mainstream languages is C++ templates, and those are still not as elegant as defmacro and will only get more clusterfucked with each new C++ version, as C++ is just a clusterfuck as a whole. Also, it would be really negligent of me to not mention the REPL. I cannot stand recompiling my code every time, write test functions, use a debugger like the GDB, since you can just evaluate any code on the fly in the REPL. Any value you want to find out can be found out by just typing it into the REPL. It's better than any debugger by far and it's not even funny. Side note: Also, to reuse the emulator example, you can just execute opcodes on the fly and don't have to write a new ROM to test something; perhaps you could skip that step by directly writing out the function in your language of choice, however it's still not interactive and that's the main point of the REPL.

Unfortunately there isn't any CL compiler that compiles to bare metal x86, thus leaving you either with the choice to write your own CL compiler – a task almost not worth doing for any project whatsoever – or leaving you solutions like Movitz, that have their idiosyncracies and weirdness. Mezzano did write its own CL compiler, it's possible, but certainly no weekend project, or even one-year or two-year project.

The CLOS (Common Lisp Object System) is a unique take on OOP and I'm not sure whether it is any better than any other approach, I just don't know much about OOP, likewise everyone who claims to know OOP doesn't really know OOP either, so I'm just using it as an additional feature and a good way to organize my Lisp code more, without having any elaborate opinion on the thing itself.

All in all, if you ever wondered whether somebody can be in love with a programming language and you want a programming language waifu, go learn CL and I bet you found the love of your life.

Everything I said about the elegance of Lisp applies to FORTH, too, however in a different way. People say Lisp is the perfect high-level language and so is FORTH adequately the perfect low-level language. To me, Lisp is still more beautiful, but I get where the FORTH people are coming from. In FORTH everything is about stacks and manipulating them; no registers! (Or at least on a true FORTH implementation for hardware that was meant to run on it ALGOLites one day sat down and conspired against all cool languages, so current day FORTH is in practice also running on registers, but there is a seperate article for that rant. Anyhow, FORTH doesn't have GC, nor does it have various datatypes and such. Everything is a word that gets executed on the stack. You PUSH data on the stack, you POP data, you DUPlicate data, and you ROTate data. Every functions is also on the stack and gets executed in reverse-polish notation order. You can read the Wikipedia page for FORTH, if that interests you further. The point is that due to it only being "words" on a stack, a FORTH compiler is extremely simpler, in fact you can write a funcitonal FORTH compiler in the boot sector of a computer without any problems. FORTH often times is used to boostrap new hardware because it is so easy to implement. The issue is that FORTH is very limited. It's great if you write your own OS and want to boostrap the OS with a compiler that can be written in a weekend (see jonesforth and its many variants), but it's not really meant to do everyday programming. I would almost, even though I like FORTH, categorize it as similar as Scheme, whereas both are very simple and beautiful, but have only very limited use cases. (Scheme people will retaliate and argue that there is plenty of real world applications like the GUIX Linux distribution, however it doesn't seem to compare well to CL).

Factor seems to be a more practical language with a similar elegance as FORTH, with it being targeted at more everyday-ish programming. I need to research this further to see what it really is.

C has thousands of useful libraries and tools, as such it's hard to dismiss, but C compilers have to be ugly and complex, and C has many pitfalls that make your life as programmer harder for no reason (something something segfaults). The compilers for it are very mature and it's still among the fastest languages currently just because people invested so much time into optimizing the compilers for it and because modern hardware is optimized for C, an ALGOL-deriviate.

In spite of all the dislike I feel for the language, I have to admit that I had a lot of fun with it, and more esoteric features like X-Macros exist, even if they do despite the language's design, not because of it.

I don't know much about this. I wrote a few throwaway scripts in it and I've heard it's similar in it's code as data approach (like Lisp), but I never bothered looking deeper into it. Certainly more interesting than most similar languages. Also it's kind of dead, but so is every other language on this page so far.

I used to do a lot in POSIX shell and even going so far as claiming it's my best skill in programming, but by its very nature as a shell, it's just not very capable with only the standard UNIX utilities and even if you add tools like jq or curl, it still is inferior to proper programming languages in how effective it is, in how fast it is, in how useful it is, and much more.

Ksh from all the shells I've tried so far. I recommend you read "The Korn Shell programming language", it's a great book on old-school UNIX shell stuff.

Many people dismiss awk as a standard UNIX tool like sed or cut, but it's much more than that. You can actually write proper programs in it and the awk program installed on your POSIX implementation of choice will function as an interpreter for those. It doesn't have any elegance or beauty perks, in fact it's quite ugly, however it is extremely useful and runs circles around Perl and Python when it comes to text processing (and running circles around Perl in text processing is a big accomplishment). Code puzzles that rely on text manipulation like Advent of Code can be solved in awk and the syntax is simple enough that you can learn it in one weekend, maybe not the fullest extend, but enough that is useful.

Check this out, if you're interested: https://gregable.com/2010/09/why-you-should-know-just-little-awk.html

Clojure is supposedly a Lisp, but it's really not. All things that can be said about Lisp being nice, can be discarded at the sight of Clojure. Nonetheless, it is fun to program in and using the JVM is a bonus too. I don't want to shit on a language just because it doesn't please any of my preferences and I want to admit that some things can be fun without it being the greatest or most well designed thing in the world.

On my FX-4300 (in the anno domini 2026) Emacs+Clojure+OpenJDK+CIDER runs noticibly slower than Emacs+SBCL+Sly, not unusably slow, but it is noticibly and that's more an annoyance if anything; still noteworthy though.

Invented or at least popularized OOP and supposedly also reached its peak with it. The IDE it uses seems nice, no clue whether it is as nice as the fanboys claim.

Eventually I will extend this list, but those are the languages I think need more attention and everybody should at least try once. I could have put C++ or Python on here, but I don't have much thoughts on these besides that they're useful when you need them, and not very interesting in any way.