> "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/)

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

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.

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

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.

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/

Golang is awesome. Super simple to learn.

I’m a typescript/C/python dev and I’ve been learning Golang for a perspective change.

Specifically I’ve been learning Golang and Test driven development together and I’m really enjoying it. I want to build a game with Golang, but you can build anything with it.

Here’s my thoughts on mainline languages:

- Python: clunky

- JavaScript/TypeScript: a mess

- C#/Java: Too enterprisey

- C: bundle of fun but hard

- C++: never tried it but heard it’s a massive language

- Golang: simple, effective

- Rust: too complex, overhyped

- Swift: looks good

- PhP: not interested in it

- Ruby: looks gross

- Gleam/erlang/elixir: interesting

Non-mainline languages:

- Lisps: look really fun. Read about crash bandicoot development

- APL: this may just be your Swahili

- Forth: incredibly powerful stack based lang

- Orca: music + 2D language

Maybe Prolog or J?

> 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

Zig looks fun, as a low level alternative to Rust. Similar use case as Rust, but much simpler.

Jai?