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 most important aspect when judging 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 about the tool to use 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 use a new language and require significantly more time for solving the task at hand, instead of re-using the previous knowledge and get it done. the dependency grows quickly. why ever use a different tool, when things can be done with less time and predictable effort. then there is fun in figuring things out: some things that are simple to solve with some languages might be more work in another, so far that there are issues that would never need to be solved with other tools, but that is usually not obvious and, change is costly, it is exciting to find solutions so the investment continues. it does not matter much when a programming language was invented. languages can evolve and old designs can prevail being superior. the state of implementations is 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 bases. for example a noisy, inconsistent syntax might be more common because it is popular and an associated ecosystem exists
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. additionally, notation can allow different degrees of variability, where different formattings used make it look significantly different and harder to work with, with the code having the same meaning. for example, whitespace is usually optional in many places and many significantly different code formatting styles emerge from different authors
while the following list does not go far beyond opinion, i only rate languages i have used
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 minimalistic syntax (principle of least suprise), low-level with a high degree of freedom, for example with memory use. its features usually have a fairly obvious implementation, but there is undefined behaviour or unspecified semantics that compiler implementations handle differently. has 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 and adequate binding scoping, memory ownership semantics, hygienic macros and other important things which makes it frankly tedious/dangerous in use but i dont see a language at the moment that improves on it