Elixir. Especially with OTP to write distributed systems. Or with phoenix and liveview for web apps

It's a functional language based on Erlang with a nicer syntax

Functional programming

I've seen a lot of technical recommendations, but what I found most fun to experiment with is visual/art/music stuff, so here are some recommendation if that's also your thing. It's not strictly programming, because most of it requires learning more skills than just that, but I see that as an advantage. YMMV, though.

The Book of Shaders is and extremely good introduction to some basic shader stuff. Especially thanks to the interactive editor they have in their tutorials, and web tools like Shadertoy, experimenting with shaders is easier than ever. It was the tutorial that made me finally get past the "super confused" part of learning shaders.

It's kind of math heavy, especially once you get into 3D stuff, but I find it fun to learn, plus it's a rabbit hole and you can do some pretty cool stuff once you get into it. In general, anything technical artist related is interesting.

Another thing I'd recommend is looking into Algoraves. Algoraves are live performances where both visuals and music is performed by people live-coding their tracks and projections in some kind of language that's made for the task. TidalCycles, one of the libraries/languages that's commonly used, has a web editor, and there's also Sonic Pi, although I've never tried that one.

Processing is another language/tool used for making visual art. It also has a web edittor (with a lot of tutorials), and can make some cool visual stuff that can be fun to learn.

And one last recommendation, this time not about art, but about learning/building your CPU, your own assembly language, and learning to do stuff in it! Turing Complete is a puzzle game, where you will learn how to build your own CPU, starting from a single NAND gate, slowly combining them into registers, memory, adders, ALU, up until you have your own, complete and working CPU. You then create your own instruction set and use your CPU to solve a few puzzles.

It's super fun and engaging, and I'd consider learning logic gates and building a CPU as kind of also programming.

It's very different. You have to come at problems in a very different way because the tools at your disposal are not what you're used to.

The language itself is quite elegant and simple, if you strip it down to its essence it's basically "when you see A on the left side of the equals sign, replace it with B on the right side of the equals sign" repeated until your program has either errored out or been boiled down to a single value. The type checker ensures that the replacement will be legal no matter what's happening at runtime, and can really help with getting things lined up just right because it's very thorough.

The simplicity also leads to complexity, though, for a few reasons. The solution to any problem is usually generalizable, since there's such a small surface area to the language itself and the type system allows for very abstract declarations of what a thing does, which leads to very beautiful solutions that are also so general and reusable that it can take work to figure out "okay, so this thing composes one function that is traveling recursively down the list of pairs, applying this function to the first item, and that's composed into this other function that is pulling them apart into separate lists..." whereas if it had been written the "dumb" way it'd be more like "oh, we're breaking these items into two lists and tweaking the first item as we go," unnecessarily tied to the one particular scenario and totally unusable anywhere else in your code, but also more readable and concrete. There's an entire vocabulary of functions that do abstract things that you have to learn to make sense of what's going on sometimes.

Related to that is monads, which are such a common pattern in Haskell that the language has special notation for them; they're an incredibly powerful tool for putting values in a context and/or creating an environment where background details can be handled out of sight, but they're also so generalizable that they span from the simplest monad that basically just captures "this thing might not actually exist" all the way to the IO monad which, in a way, represents the entire universe, or at least your entire computer. Learning Haskell means wrapping your mind around them, which isn't impossible, they're actually quite simple, basically just 2 functions that need to follow a few rules, but it takes a few examples and explainers to really get it.

Generally I think any programmer benefits from at least trying out something like Haskell, even if you never become an expert or use it day-to-day, it'll give you a new angle to think from and could spark thoughts you never would have had before.

Perl! It is a language with a lot of soul and the llama book is actually fun to read.

Lack of advanced features like generics and a weak type system (although still better than JavaScripts type system). Its library ecosystem is also pretty anemic because it's generally assumed if you're writing Lua it's as part of a script embedded in something else and most of those won't let you pull in random Lua libraries. There are stand alone Lua interpreters that let you run Lua on its own but most people writing Lua code aren't using them and so the community to develop a rich library ecosystem isn't really there like it is in most other languages.

It's a bit safer and a lot more convenient to use, but still lets you do dangerous things with pointers. At its core it's still fundamentally the same as C just with a bunch of helpful tools and features to make doing all the stuff you do in C easier and more convenient.

Really the biggest thing it does significantly better than C is its macro system. C macros are "dumb" in that the C pre-processor does a simple find and replace on the source files without doing any kind of processing on the underlying C code so you can E.G. write C macros that spit out mangled illegal C code when you run them. Likewise a C #include is literally the same thing as copy and pasting the contents of the included file before it gets fed into the compiler.

Zig on the other hand has a smart macro system that's actually aware of the zig code and works in concert with it at compile time.

Speed and the fact that Go compiles into a single binary, so you don't need a specific runtime environment.

Lolcode:

HAI 1.2

HOW IZ I FIZZBUZZ YR INPUT
    I HAS A RESULT ITZ A YARN

    I HAS A FIZZ ITZ MOD OF INPUT AN 3
    I HAS A BUZZ ITZ MOD OF INPUT AN 5

Learn what makes LISP LISP (lambda calculus), then start creating LISP-like interpreters in. every. language.

This video might pique your interest in the topic - William Byrd on "The Most Beautiful Program Ever Written" [PWL NYC] (tldw; he explains and shows how to build a LISP interpreter in LISP)

Assembly: ... but it’s not hard in the “I don’t get it” way, so much as “oh god, that’s only 1% of what I need to do and it took me an entire day”. This is also a great way to develop a deeper understanding of pointers and memory management.

Well explained.
Although I understood memory beforehand, I found the little bit of Assembly I did pretty useful in getting a better understanding. This also ended up opening me to think of how multithreading worked underneath.

I found C pretty fun, but that might be my bias.
It was fun because it felt pretty close to hardware and let me understand how stuff can go wrong, without tripping me into it (the last part is subjective. I suppose most people would feel having been tripped, when using C).

C++ was fun and useful as long as I thought of it like C. Once I went into software development and had to make sure stuff worked out well on top of mistakes that might come out of collaboration, I had to start considering things like smart pointers almost all the time and it was no longer as much fun.

Rust is definitely not going to give the fun of C. Although it is more desirable for Software Development, when you start learning it, you will find quite a few blockers, that you might feel unreasonable. Me, even after having used C and C++ and realising the problems faced when making software and then having seen proper explanations of the features of Rust, still have a problem with the feeling of it.

Python: if you just want to do some mathematics on computers, this will be more desirable. The "fun" for this one is that you don't need to worry as much when doing some scratchpad stuff. Start going big though and it stops getting any fun, pretty fast.

This is probably an unpopular opinion, but I find modern C++ with templates and constexpr to be quite fun, mainly from the perspective of trying to do as much at compile-time as possible. Most of the resulting code is nearly incomprehensible and never gets used for anything outside of a godbolt demo, but trying to do complex tasks within the limited and unintuitive world of compile-time evaluation is something I've never really been able to find in any other language.

i don't want to hear about rust, const generics are almost useless and you know it, specialization isn't really a thing and nothing like variadic templates exists yet

Praise be to Odin.

My favorite these days for embedded stuff is Rust. It's soooooo nice.

My AHEK-95 keyboard has an IR receiver and I programmed it with a cheap $0.50 remote. I only set it up to send the play/pause, next/prev, and volume control but in theory I could make it work with a huge universal remote to do whatever I want.

There's a demonstration of it working to send some numbers here: https://youtu.be/iv6Rh8UNWlI

The language thay you are already using! You need to understand FP, not a new language. Definitely read "Grokking simplicity" by Eric Normand.

But if you want to learn a new language more suited for FP, I would hardly recommend either guile scheme, racket, or clojure (all are lisps and you can use and build real word things with them forever). Haskell is also great but it's much harder than lisps.

You can do oop or fp with lisps, there is basically no syntax, you can get started and actually focusing on doing FP in a month. (Som say you can learn the language itself in a week, which you can but if you are really dedicating time to it).

I think Haskell would be a good choice. It's mature, used for real things (amongst a particular crowd, at least) and it's emphatic about being purely functional. Even when it is forced to enable other styles like imperative, it's done in a way that's syntactic sugar for a pure version (do notation being a great example of this, it's really just a chain of lambdas). You can do functional style programming in a lot of languages now, but they'll also let you mix and match other styles, which can make it easy to "cheat." Haskell will teach you functional programming and that's it.

Also, since it sounds like you're familiar with Rust, it uses a lot of ideas from Haskell. Rust enums are a clone of Haskell's algebraic data types, patterns are almost exactly the same, traits are typeclasses right down to the fact that the compiler can derive some common ones automatically, Rust strongly encourages immutability while Haskell basically requires it, and in both languages you're only allowed to break the rules if you start using things with the word unsafe in them. My experience learning Rust was "oh, C and Haskell had a baby named Rust, cool!" The big difference is that in Rust, you're programming from inside a C-style computer with RAM, while in Haskell you're programming in a mathematical void and the computer is tidily packed away in a box labeled IO.

A fun guide for learning Haskell is here: https://learnyouahaskell.github.io/

Befunge!

100% agree! I write enterprise monsters for a living, in a bunch of different languages, and by far my favorite thing to do is make blinken-lights and other doohickies with my Arduino.

Doesn't have to be Python or even the Arduino subset of C++, though. I like to use Go (tinygo.org) for anything that it will compile on