Both are mentioned in the thread, but lately I have been thinking that Zig and Scheme feel like the Yin and Yang of programming languages. Learning both of these languages won't teach you everything there is to know about programming, but it will teach you a complimentary set of foundational information that will make it easy to pick up any other programming language.

You will learn

- programming with manual and automatic memory management

- static typing and dynamic typing

- compile time execution and runtime compilation

- imperative programming and functional programming (neither language enforces imperative or functional programming, but their ecosystems strongly encourage one style or the other)

- errors as values and errors as exceptions

- SIMD programming and programming with the numeric tower

- various concurrency primitives

- what interfaces fundamentally are

- textual code editing vs structural code editing

Probably lots of other complimentary concepts too. But what's also interesting, is that it's completely reasonable for any person to learn the whole language for both of these. I've read both all of the R7RS small paper (which includes the entire definition of the language and the standard library), as well as the entire Zig language reference (which does not include the standard library, but I have also read a large portion of the Zig standard library, sans a lot of the std.os.* syscall wrappers).

It's really hard to think of high level languages that you can't easily pick up after learning these two. Prolog? You can learn logic programming in Scheme before switching over. Fortran? C? You learn most of the interesting concepts required to program in these languages from learning Zig. Erlang? Go? You can learn their concurrency models in Scheme and Zig.

Common Lisp. THE most important language to learn. It is all here.

Math. Especially Linear Algebra

APL. Learn the true power of array-like thinking and strong use of symbols.

Assembler. Learn the language machines speak.

Forth. Learn how to program with self-created, minimal tools to create great things.

Bash. Learn how to use the full power of the machine in a terminal.

Emacs Lisp. It's not a language, it is everything you'll ever need.

C. Because it is everywhere, usually as a glue language between systems.

Python. So you can see how badly a language can be designed.

Verilog. Learn to fashion hardware in a language.

LEAN. Write provably-correct software.

HTML. Because you wouldn't be reading this otherwise.

Javascript. Because you occasionally have to make useful web pages.

Java. Because you can do network programming.

X11/Wayland. Because you can reach out and show things.

Regex. Because you can't parse without it.

Erlang. Because things break and you need to survive.

CUDA. Because you need to know how to write kernels.

SNOBOL. Patterns are programs. Programs are patterns. Plus 3 way branching.

Latex. Because you need to communicate to other meat-things.

SQL. Because databases underlie it all

OCAML. Because Type-correctness matters

Lambda Calculus. Because you need to know how it all works in theory.

Haskell. Because you need to learn a real higher level language.

C++. Because you need to see cancer in its raw form

Swift. Because you can make the stone in your hand do things.

Qiskit. Quantum computers are coming

Of course LLMs are going to make all of these languages so rarely spoken that they will be like COBOL. The future of programming is maintenance programming. Legacy systems won't be rewritten, they will be "maintained". If you know what a PROCEDURE DIVISION you'll always have a job.

Prolog. Because rule-based programs used to matter.