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 together or any of those. nevertheless, 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 first 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 they work with 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 and avoid considering alternatives. 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. the initial choice often seems incidental, but the choice of 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 y and require significantly more time in total for solving the task at hand, instead of re-using the existing knowledge and get it done somehow but quicker. the dependency grows. why ever use a different tool, when there is a known, more or less predictable path with existing tools. 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 if other tools were used, but that is usually not obvious, and it is exciting to find solutions. it does not matter much how long ago a programming language was invented. languages can evolve and old designs can theoretically 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 an overcomplicated, inconsistent syntax might be more common because it is popular and an associated ecosystem exists
this word seems to often mean "ease of thought" but i would like to note that many things sure are easy, if they have been trained for a few years. 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.
notation can allow different degrees of variability, where different formattings used make code structure look very different and harder to work with, while the code still has the exact same meaning. for example, whitespace is usually optional in many places and many different code formatting styles emerge from authors using whitespace differently
while the following list does not go far beyond opinion, i only rate languages i have actually used for more than two work days
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.
some inherent consistency/simplicity, probably from "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 better alternative at the moment
c written with s-expressions