When studying a programming language, I find it useful to look up the background of its creator(s). It will tell you much about its internal design, style and usefulness.
A few examples.
Lisp, and to a lesser degree, Python. You can really tell that John McCarthy and Guido van Rossum have a strong mathematical background. The language is simple, elegant and gives you few, very carefully designed tools. Lisp is maybe the language that is conceptually the most beautiful, yet totally impractical. You probably should write in Lisp, in some ideal world, but you won’t be able to get anything done. It completely clashes with how you actually think and would like to write a program.
C. Ah, a physicist. Simple tools, yes, but completely designed for the task at hand. A good C program may be very powerful, but you always feel you have to study for years until you can get it right. It often feels like black magic. Properly understanding pointers and memory allocation alone can take quite a long time, even just on a conceptional level. You may get the basic idea, but then there are all kinds of traps and exceptions and weird cases were just everything breaks down.
I always feel reminded of quantum physics. It may not be that hard to get the concept of uncertainty at first, but when you look at practical cases, it gets totally messy. You have to use funky equations that bloat and bloat, weird concepts just so you can handle it and get results at all, and when you design an experiment, it will still break down and you’ll spend weeks fixing bugs.
I love the language, but if the universe were written in it, it would have constant leaks, be insanely huge compared to its actually purpose and most of its parts would be all over the place, in seemingly unrelated places. Actually, that does sound quite familiar…
C# and Java. Designed by a committee, led by a software engineer. That really tells you everything you need to know. They are full of cruft (backwards compatibility is one of the worst ideas ever), concepts that sound nice on paper, but have not proven to be really useful and huge, quite often to the point of being slow. Companies and governments favor these, for obvious reasons.
Perl. The only (?) programming language designed by a linguist, which is probably why I love it so much. Actually, it feels a lot like Japanese to me. The set of keywords and basic functions is huge, with a word for each specific idea and fine nuances. Context is important and words can mean very different things depending on how you use them. In fact, because of context, you can often leave out redundant or obvious parts.
It may be the only language to encourage you not to use (explicit) variables unless you think you need to.
Looks reflect purpose, such that weird constructs actually look weird, while common constructs become clean and simple. This empowers you to represent ideas the way you think is best for the job. You can always say things differently, if you want. You can be more explicit when talking to a foreigner, slur and mumble when speaking among friends (or to yourself), emphasize a specific part or just use your own kind of dialect. While this makes it possible to write the most incomprehensible program ever, it also allows you to write poetry.
Of course, over time, this has led to weird exceptions, idioms that may not seem obvious at first and a full-on culture you can not ignore when using the language. But the reason why it’s maybe the most human language is it’s choice of elementary building block: Lisp is build around the list, C focuses on memory and numbers, in Smalltalk everything is an object, but the first thing in Perl is the word. Everything is (kinda) a string and most of it’s features are specifically designed just to handle those in efficient and smart ways. Humans do not think in objects, numbers or lists – our mental stack is way to small for this. We can barely add numbers with more than 4 digits or keep track of more than a few dozen people and our memory is kinda hazy, but we can easily remember and use tens to hundreds of thousands of words in complex structures, with ad hoc grammar and no formal (or even central) definition at all. There is a good reason why you use plain text to explain stuff and only the most twisted of minds would consider a mathematical proof straightforward and intuitive. So why do we build languages mostly like the latter and rarely like the former? I don’t know.