there are many programming languages - thousands. and the number keeps growing. informally, "programming language" often means syntax, semantics, compiler implementations, available libraries, extensions and the community all in one. but the basis of languages are syntax and semantics, because the core utility of a language for a developer is to describe what a computer should do. the implementation and software written in it can be seen as just following from that. that is why i see syntax and semantics as the main criterion for choosing a programming language. learning a language and getting to know its detailed semantics and associated environment well is a big investment because it takes many years of learning to become really good with it. people usually learn the languages the company uses, they are told to learn, the ones that seem the most popular or those of which the marketing reached them then stick with it for life. how languages become popular is an interesting topic by itself. often languages become popular because people write programs in it that become popular, but that does not really say much about the qualities of the language used though. the initial choice is often incidental, but the choice for the tool to be used to solve the next problem often depends on the tool previously used: say someone spent two weeks learning language x and a new program is to be written - why start with a new language and require significantly more time for solving the task at hand because of the unfamiliarity, instead of just re-using the previous tool and associated knowledge and get it done. the dependency grows quickly. why ever use a different tool, when things can be done with the known with known effort. then there is fun in figuring things out: something might be fundamentally uncomplicated and creating issues that would never need to be solved with other tools, but that is usually not obvious and it is exciting to find solutions so the investment continues. the time when a programming language was invented does not matter as much. languages can evolve and old designs can prevail being superior. the state of implementations is more important. with programming languages it seems to be more likely for popular bad things to be improved with much effort until it works just well enough than for people to switch to fundamentally better things.
a note about the word readability, which is sometimes used to describe programming language syntax. the word seems to be easily confused with "ease of thought". many things are sure easy, if they have been trained for a few years. notice that reading is a process that takes place for extracting information from a visual pattern for example. this process can be divided into smaller processes, little actions that are necessary. for example having to look back to the beginning of a line to read the next one, which takes time, or recognizing something surrounded by a whitespace character as a separate thing, remembering a mix of agglutinated characters to be associated with a concept, et cetera. humans are not computers and costs may differ, but too much micro-effort over time might be stressful and limit intellectual capacity. how easy something is to be read is a question of the amount of required non-transferable knowledge and the effort required after the knowledge has been acquired and the action trained. notation can allow different degrees of variability, where different formattings look significantly different but have the same meaning. for example, whitespace is usually variable and many significantly different code formatting styles emerge from different authors, yet it is often ignored by the compiler in many cases and the meaning of the program is not influenced. but different formattings can make code harder to work with
while the following list does not go far beyond opinion, i only rate languages i have used for at least 16h+
the simplest and most flexible language. syntax and semantics follow an ideal of unusually high pragmatic and auto-didactical efficiency. it is almost as simple as possible to learn, parse and translate.
c written with s-expressions
relatively easy to predict outcomes (principle of least suprise), low-level with static typing, manual memory management and direct memory access. compilers to create highly optimised machine code for a lot of different platforms available. lacks features like a basic module (dependency) system or hygienic macros