> "I'm looking for the Swahili and the Japanese of programming. Something completely different, that will expand the ways I'm thinking about programming."

APL/J [0][1] and Haskell [2][3]. Ways-of-thinking expansion guaranteed. You can also build real world stuff with Haskell. As someone already mentioned, you could also give ClojureScript a try.

Also learn low level programming with C and Assembly if you want. You will learn a lot, and they will expand your horizon.

Racket ecosystem is also good. Look into Prabhakar Ragde's flanaries. [4]

[0]: https://aplwiki.com/wiki/Main_Page

[1]: https://m.youtube.com/c/codereport

[2]: https://www.cs.nott.ac.uk/~pszgmh/pih.html

[3]: https://www.youtube.com/playlist?list=PLe7Ei6viL6jGp1Rfu0dil...

[4]: https://cs.uwaterloo.ca/~plragde/flaneries/

Gleam is fantastic! https://gleam.run/ The syntax is familiar but there are several next-level features: - no conditionals (case all the way down) - `use` expressions - pipe operator

It compiles to either erlang or JavaScript, so I was able to jump right into building something fun with a new language.

>I previously gave Clojure a try, that was a pretty good fit, but the JVM / ecosystem put me off.

I felt similarly w/ leiningen (too much boilerplate) but was lisp-curious still so gave racket (https://racket-lang.org/) a try and appreciated the batteries included philosophy of the standard library and was inspired to learn more about writing a programming language (also see: https://beautifulracket.com/)

Upvote for Gleam. Completely different paradigm. Made for building internet scale apps with offline first functionality in a fault tolerant way. Also great community.

> I'm looking for the Swahili and the Japanese of programming. Something completely different, that will expand the ways I'm thinking about programming.

Smalltalk and Haskell.

I would have said Lisp/Scheme, but if you've already tried Clojure then you likely wouldn't gain anything from it.

Haskell is so alien that coming from javascript/ruby will feel like knowing almost nothing.

It's rigid and forces you into a way of thinking about problems with the single/strict paradigm approach. Very difficult to program in, but I feel like learning it teaches you a lot about the way you program in other languages.

It boils down to the question: is your code provably robust? You learn very often, its not.

Consider Elixir. It blends familiar Ruby-like syntax with the power of functional programming and the Actor model, offering a fresh, joyful way to think about code.

And if you're coming from Ruby and want to learn Elixir, I humbly recommend http://PhoenixOnRails.com

>I previously gave Clojure a try, that was a pretty good fit, but the JVM / ecosystem put me off.

I recommend trying Common Lisp then. It's one of the primary inspirations for Clojure, and it's not tied to JVM - it's an ANSI standard with multiple independent implementations, my favorite is this one: https://www.sbcl.org/

The best combination I know of "weird" and "can build neat things" is Elm. It has some serious problems for industrial use but they don't really apply to side projects.

Elixir is less Ruby-like than the syntax looks. If you build a multi-user document editor or something similarly concurrent that might fit the brain-expansion mandate.

Well, you can learn brainfuck. Or regex if youre insane.

I'd say anything functional should be fun. Haskell, scheme, ML. Try metaprogramming in scheme, or find the most interesting way to use recursion in Haskell that you can come up with.

There's a new project that uses interaction nets as a model of computation called HVM. There's also a pretty easy to learn language that comes with it called Bend, it's just syntactic sugar for the HVM language which looks really cool. Maybe learn them both.

Any of those should really change the way you think of programming and computation.

There's always niche stuff like Erlang and R if you just want something different.

All right I would suggest that regex is one of the coolest things ever invented… so it actually is worth learning!

I think regex is just a baseline thing most programmers are going to need to know. Most every text editor supports it, it's very handy in VS code to query codebases.

Yeah I think so too, it can be a pain but it is very useful. I "know" it in that I can slap something together, but I'm not an expert in it so I usually have to do a little fixing when I use it.

I always consult MDN regex whenever I need some help. Most of it is pretty simple:

[a-z] - a range of characters .* - any number of characters or none .+ one or more character. ^ - start of sequence $ - end of sequence

But what I can’t seem to get is lookahead and look behind syntax! Always have to look it up!

You might enjoy learning Lean, which is a functional programming language specifically for theorem proving. You can tackle interesting types of questions, and it is actively used in mathematics research.

Here's a neat walkthrough from Terence Tao, which might give you a sense of whether it's something that piques your interest: https://terrytao.wordpress.com/2023/12/05/a-slightly-longer-...

Scheme is a small LISP written in C. It is smaller and simpler than Clojure. Common LISP is much more advanced if you find Scheme limited.

Erlang and Smalltalk are both interesting languages based on message passing paradigm.

Verilog - a hardware description language. Tetris in hardware? No problem! There are free simulators out there but using real FPGA boards can be expensive.

CUDA/Shaders - massively parallel take at the programming.

Scheme is the common dialect of many implementation projects, and is specified in English. Some of those Scheme implementations use C, some do not.

Scheme implementations are not all smaller and simpler than Clojure as a whole. Of course they have a lot more content than just the core specified in the Scheme report.

Gauche Scheme has a reference manual of over 1000 pages, for instance.

Racket can be counted as a Scheme implementation; it is also large.

There is a list of Scheme implementations in the Wikipedia:

https://en.wikipedia.org/wiki/Category:Scheme_(programming_l...

OCaml and try writing a small compiler/interpreter.

Try Richard Bird's latest two books for Haskell to see how pure functional programming and allows for equational reasoning and the power that grants you.

Try a lisp and work your way through SICP.

Try Forth using Starting Forth and Thinking Forth for stack-based programming.

Try Prolog for logic-based programming.

Try APL for array-based programming.

For a higher-level look at PLs, try this book: https://en.wikipedia.org/wiki/Concepts,_Techniques,_and_Mode...

> I'm looking for the Swahili and the Japanese of programming. Something completely different, that will expand the ways I'm thinking about programming. I don't really see much benefit in learning Swift or Rust in that regard.

I understand what you wrote, but when after 10 years of programming in C++ I've learned Rust, it did actually change the way I think about organizing programs. If you dismiss Rust because it feels "normal", then maybe please revise your position on it.

But if you really want Swahili, then try functional programming: Haskell, Racket, etc.

For something completely different, try the old Viva/Azido stuff. It looks like there's a stray MSI file online: https://github.com/abdullin/viva-tools/tree/main/files . Be sure to get the subfolders near it. It will run on Wine. You could learn Verilog alongside it, just so it you appreciate what Viva tried to do. Also, you should learn LISP or Scheme.

If you liked Clojure then you might want to try ClojureScript.

Haskell is interesting. For example, you can implement a poor man's Prolog in a Haskell list comprehension.

APL looks interesting and very alien to me. I assume that since it is array or matrix based that it is similar in some ways to Matlab, et cetera but the way people talk about it kind of makes you want to dive into its culture and at least read the original paper on it.

Maybe you should take your turn at inventing your own language?

Erlang? (If Swedish is good enough).

Prolog, or picat

Of questionable value, but probably the best resume builder and conversation starter:

https://codewithrockstar.com/

I can see the value immediately. That's hands-down the best fizzbuzz I've ever read.

There are better versions out there, for example:

https://aphyr.com/posts/353-rewriting-the-technical-intervie...

- Dlang : overall much better than Golang

Fast compilation and has GC (default) similar to Go, and more sane and intuitive than C++ or Rust.

Has many useful and productive features for modern software engineers from packaging, TDD, inline assembly, native linear algebra library (i.e in-house LINPACK), nested function, second to none CTFE, awesome generics, compiled scripting REPL facility:

DLang Features Overview:

https://dlang.org/comparison.html

Sounds like a cool language, and I’m always open to learning, but I’ve never ever seen a job using D

Also, the D language creator often posts here on HN (Walter Bright).

> JavaScript/TypeScript: a mess

Absolutely correct. The solution that’s hard to teach is to use less in them. If you only use primitives, one type of condition, one type of loop, and then organize everything as if they were functions or data structures you will be just fine. Most people lack this discipline and do what’s easy or stylish only to complain about it later.

A nice thing about Go is that it's pretty easy to read other people's code, like libraries you might want to use.

It helps ! And don't get hung up on "advanced topics" like generics til yer ready.

Rust may be difficult, but it is not not complex

Maybe Prolog or J?

In that vein, take a look at Datalog and Egglog.

> I previously gave Clojure a try, that was a pretty good fit, but the JVM / ecosystem put me off.

ClojureScript / Squint then

that question lacks good motive.

but future-wise, go, zig and rust is where i would focus.

An assembler like NASM?

COBOL

Jai?

My (very limited) understanding is that Jai is deliberately pretty general-purpose and C-like, just with additional features and conveniences optimized for building games/game engines. What's mind-expanding about it?

The comptime stuff is neat. JB has a demo with a game running during the compile phase.