Too many languages

There are thousands of programming languages.

The purpose of a programming language is to express programs. The
purpose of learning programming languages is to build up a toolbox for
reasoning about and synthesizing programs in any one given language.

There are diminishing returns on learning programming languages, and
time is scarce.

Therefore one must select between programming languages to study.

A good selection of languages has both
+ breadth
  + satisfies a number of real world economic needs.
+ focus
  + exploits similarity between languages and incremental learning.
  + some unifying basis

A good member of a particular selection meets a number of the
following criteria:
+ Satisfies one particular school of thought on programming languages.
+ Significant difference from predecessors
+ Significant influence on successors
+ Economically significant
+ Advanced i.e. no direct, established and proven heir.
+ A good language.
  + Easy to express programs with
  + Easy to read programs expressed with
  + Easy to reason about programms expressed with

No one of these criteria are sufficient or even necessary conditions.

A bad member satisfies the opposite criteria.

>>66
``Lost'', in the way I used it meant exactly ``deliberately abandoned'', so I don't understand why you contrasted the two.

Deliberately abandoned in no way implies deliberately abandoned due to the idea being bad, or it being inferior to what exists.

Technologies die due to economic pressures. ``Good enough'' is a thing. People use Java don't they? Do you think Java is the world's best language? It's not, but it's ``Good enough'', proven and there are network effects in using it.

It's insanely foolish to think that markets optimize on technical merits (or that any similar evolutionary sort of process does).

As Alan Kay said (paraphrasing cause it was in some video I watched ages ago) ``Just imagine the most perfect being, and then *prfft* an elephant stomps on it, and that's it. It's gone''

Nothing just ``turns out'' WTF are you talking about? ``flexibility''? I'll grant you ``speed'' but I can't really name anything else, certainly not ``flexibility''.

And why on earth are you talking about ``high level operations''

What in heck does garbage collection, type tagging and bounds checking have to do with ``high level operations''. Those aren't implemented as operations, the whole point.

Finall ``A stupid idea that works is still a stupid idea'': Yiddish proverb.