I don't have any obscure favourites that I actually use. But I have a soft spot for a bunch of old, obsolete ones.
Niklaus Wirth's post-Pascal languages, including Modula-2 (and its offshoot Modula-3) and Oberon were fantastic. Their syntaxes fit on a single piece of paper. Modula-3 is an outlier, since it was developed without much involvement from Wirth, but it adds some nice stuff, such as generics. Oberon had a strong influence on Go.
As a kind of "lost language", Barbara Liskov's CLU (1974-75) is fascinating. Its syntax is Algol/Simula-like, but it comes with a lot of advanced features (iterators, generics, type parameters with constraints, exceptions, variant types, parallel assignments, inheritance-less classes, "everything is an object", garbage collection, no global variables) that eventually ended up in other languages, much later. CLU was never intended to be used, but as a testbed for ideas, and it never really was.
I have a soft spot for Modula-2 too. It was verbose (which I didn't mind) and used all-caps for some syntax which didn't look nice. It featured coroutines for concurrent programming with a very readable syntax.
Wirth felt the language was too large (although this is all relative since Modula-2 is smaller than many modern languages) and so Oberon, his next language, was deliberately pared down to the smallest number of keywords and features he could manage. I've always liked this philosophy and still think a smaller language is preferable to a larger language in many cases. There's something satisfying about knowing all the features of a language - you actually feel you might be able to master it.
Nial (and its interpreter QNial) is strangely unheard-of. It's an intruiging APL-like that uses English words and a simple, general syntax that permits nested parentheses, allowing lisp-like code. It extends APL to multidimensional arrays a la Numpy (which it well predates - 1981!), and throws in some interesting and exotic ideas for good measure such as arrays of point-free functions as a first-class structure. It's a lot of fun to do Project Euler type math problems in, and captures the essential spirit of APL/J/K etc but without the obfuscated syntax.
isprime is op n {not ((n = 1) or (0 in (n mod (rest count (floor (sqrt n))))))}
Icon [1] and Unicon [2] are very interesting languages. They both excel in string processing. Icon had some influence on Python. Unicon is a superset of Icon with many more features.
Unicon is still under development unlike Icon. I don't think Unicon has ever been discussed on Hacker News. Ever.
Definitely Haskell for introducing me to functional programming concepts (which I know use everywhere) and Erlang for introducing me to the actor model, embracing failure, and writing easily scalable and reliable code.
Of all the languages I've experimented with, I was fond of Dan Winkler's HyperTalk (the scripting language used by Apple's Hypercard app) because it was so high-level. It enabled a lot of people - particularly in education - to create app 'stacks' that might otherwise never have ventured into programming. And it was fun. I can't imagine a more noble goal for a language.
(The variant Supertalk is still in use, in SuperCard).
I have the following AHK enabled "features" for lack of a better term always running on windows.
Caps lock triggers a context sensitive - which app - screen overlay of relevant shortcuts (assembled by hand) as well as a menu which autofilters a long lsit of commands, other scripts or websearches, like yubnub.
I have commonly used actions assigned to mouse buttons:
```
WheelRight::Send !{Right}
Wheelleft::Send !{Left}
Xbutton1::Send ^{PgUp}
Xbutton2::Send ^{PgDn}
+MButton::Send ^w
+WheelDown::WheelRight
+WheelUp::WheelLeft
```
I have reassigned the function buttons I almost never used, along with some combinations to allow me to almost never use the mouse in certain use cases.
By highlighting text and hitting a hotkey, i get the evaluation of that as a math expression. With functions and memory
Small scripts that I use most days and call from caps menu include: global autocorrect, computer & network performance widgets, emoji/ascii art insert tool, rerun of apps that start on startup, on screen ruler, on screen color eye dropper, mouse wiggler to prevent screensaver, quake-style terminal emulator window for WSL bash, etc.
It also compiles into an exe easily and relaibly, so friends and family struggling with something can get a gui based app, usually a few hundred kbs, for something that is otherwise a big pain to do. A recent example was a mouse tracker for doing presentations, that always gave the mouses' current location.
Professor Jack Schwartz's SETL is great for designing algorithms at a high level yet executable if you want it. SETL is dynamically typed with compilation, type inference, and 'reppers' to optionally declare type info as tools to trade verbosity/effort for runtime efficiency (Think typescript vs javascript) all this in the late 70's.
I saw a presentation on Forth and ever since then I've loved tinkering with it.
The language is old, fast and powerful. It isn't quite compiled or interpreted (or maybe it's both), it can run on teeny tiny microcontrollers or be used for scripting.
The best part is, it's a completely different paradigm of how to program from any of the other modern languages I've used. There are no function arguments, and everything is done in reverse polish notation. There's no concept of parentheses in the language (parens are used for comments)
Learning Prolog was one of the better decisions I have made. Not because Prolog jobs are plentiful. Rather, understanding logic programming by broadened my problem-solving skill set.
I enjoy Clojure. It’s a lisp that runs on the JVM. It really taught me a lot about the power of immutable data structures, code as data, and first class functions.
I did some Ada in college. It's incredibly powerful, but it can be pretty difficult to work with. I don't know where else is used other than aviation and the military.
+1 for Ada. Loved they way it made tasks and monitors etc explicit. Easy to work with low level hardware. Liked the subtyping too. Often compilation => correct.
Serpent![1] It's a Python-like language created by the guy who wrote Audacity, for operating on MIDI files mostly, and doing audio automation, like markov chain composition. It's super cool.
The E programming language [0] for secure distributed computing. A language that makes it very easy to reason about what permissions your code actually has, by implementing the object-capability security model.
Picolisp (https://picolisp.com/wiki/?home) is one such lang not many know about but it brings a lot to the table (batteries included). It's super low on memory and it's (almost too) fast for most people.
i don’t believe that the question is valid in the context of hn (after all people here are curious by design and have probably heard about most things out there).
that being said, I quite enjoy Elixir. It builds on top of Erlang and the language and the community around it are just amazing.
Niklaus Wirth's post-Pascal languages, including Modula-2 (and its offshoot Modula-3) and Oberon were fantastic. Their syntaxes fit on a single piece of paper. Modula-3 is an outlier, since it was developed without much involvement from Wirth, but it adds some nice stuff, such as generics. Oberon had a strong influence on Go.
As a kind of "lost language", Barbara Liskov's CLU (1974-75) is fascinating. Its syntax is Algol/Simula-like, but it comes with a lot of advanced features (iterators, generics, type parameters with constraints, exceptions, variant types, parallel assignments, inheritance-less classes, "everything is an object", garbage collection, no global variables) that eventually ended up in other languages, much later. CLU was never intended to be used, but as a testbed for ideas, and it never really was.