[pdimitar]

Well, I upvoted you.

IMO it's about time we converge on just 4-5 languages -- each with unique benefits that can't be had easily in the other ones! -- and finally start to be truly productive.

Programming is mostly a complete mess today and everybody loves their own ugly disabled baby. Sigh.

[blacktriangle]

Upvoted and do like the idea, its an interesting question to see how many languages do we really need. I remember some paper from the 80s suggesting in the future all we would need is Ada and Lisp. This is somewhat echoed with the GNU projects attempt at C for low level dev and Guile for higher level dev and scripting. With no judgement of suitableness or not trying to exclude just tossing out examples, I'd guess it looks something like:

Small footprint systems language - C, Zig, Ada/SPARK; Higher level dynamic language - CL, Scheme, JS, Clojure; Full Spectrum Language - Rust, Red + Red/System; Basic low level embedded - Forth; Higher level static language - Haskel, SML, Java;

But already these start breaking down, particularly static languages are a minefield. Lazy vs eager evaluation, nominal vs structural typing are two major axis of differentiation there. Then for both static and dynamic languages the question of immutable by default vs immutable as an add-on. Further there's a question of do you need 3 languages for system, high level, and full spectrum vs picking one of the two approaches? And even this binning of 5 completely ignores to what degree concurrency should be a first-class concern of the language. Then there's the whole question of VMs and is there value to building your whole ecosystem on a shared VM? And further, now there's the problem of exposing functionality to non-developers. Should we include a tool like Lua or R that targets non-devs, use a tool like Racket or Red with their very explicit support for creating small custom DSLs, or is that a total non issue because the correct solution is to write GUI tools for that market?

Then the bigger question is, to kitchen sink or not. Languages like CL, Scala, and C++ have taken an approach of implement a ton of features and then trust the developers to sort it out. Other languages are laser focused on a single feature and then take it to its extreme, kinda like how Clojure does with immutability or Pony with actors. Yet if we don't embrace multiparadigm languages, we're leaving a ton of research on the table or accepting the zoo of programing languages.

Yeah programming is a shitshow.

[pdimitar]

> I remember some paper from the 80s suggesting in the future all we would need is Ada and Lisp. This is somewhat echoed with the GNU projects attempt at C for low level dev and Guile for higher level dev and scripting.

This is an even more true argument today (minus the concrete language names). We desperately need such a curated subset.

The problem is of course us the pesky humans with short-sighted feelings we cling to as if our life depends on it. Desired job security is a big offender as well.

The pertinent questions today with regards to a language are:

- Is the runtime fast (if it's interpreted)?

- If it's compiled ahead-of-time, does it produce efficient machine code? (Golang is one example of machine code that can be better, whereas OCaml and Rust are known to produce some seriously fast machine code.)

- Are the runtime's performance characteristics predictable, e.g. latency remains stable under load? (Especially if the runtime has a garbage collector.)

- Does it run on a reasonable amount of platforms? ARM, x86 (32/64 bit), AVR, and a few more? Can it run on embedded devices?

- Does the language/runtime/ecosystem give you good parallel/concurrent abilities? Preemptively scheduled actors and/or green threads is probably the best idea for servers (Erlang / Elixir are good example do due to the underlying BEAM VM). IMO this is hugely important nowadays. Stuff like parallel iterators and parallel map/reduce/join/various-transform operations are other important enablers.

- Does the language help you avoid various bugs? Examples are Rust's borrow checker or many languages' support for sum types.

---

Additionally... why do we even use languages that don't get compiled by GCC or LLVM, at all? I am tired of listening to people's stories about their beautifully simple and genius compiler... which of course can't even do SIMD intrinsics or properly unroll loops. Yeah, "genius" and super simple indeed. /facepalms

Will we ever learn? Gods.

---

I've been around and I can claim that many times people get attached to the language simply because it has good libraries and good community. I fully relate to that and it's the reason why I want to work with Elixir even after 5 years of mostly uninterrupted career with it but... at one point, after many other problems are solved, you inevitably start hitting brick walls and you question your career choices.

I can't claim any strong experience or authority even after almost 20 years in the industry but so far only Rust seems to be a very good all-around language with a dead-serious and dedicated community that's trying to penetrate basically everywhere. The good news is that they might just succeed because the language is that good -- although it too started showing some warts but so far they're bearable.

But I don't see the world putting their differences aside and starting to work on a common cause. It's sadly not how humanity works. :(