Most of language bashing I see seems to be a mix of very limited perspectives, a lot of effort put into inventing supposed downsides, ignorance and choosing a wrong tool for the task, spiced with overconfidence and fitting the crowd. Most of strong language love seems to be a mix of giving too much weight to relatively irrelevant features, cherry-picking use cases, limited knowledge of available alternatives, turning the blind eye to various problems and considering oneself to be the ultimate definition of programming needs. In either case nothing I would like to subscribe to.
I spent 13 years working professionally with a few languages and dealed with two dozen more. With the wide spectrum of tools I experienced, I can’t feel much more than either appreciation, usually mild, or noticing there are some issues, usually non-critical.
The tragedy, the inhumanity of it all… I think someone is in dire need of a hug. (Either that, or the extraction of a
really big stick…) Do try to cheer up, or you might burst something.
But, since the can has been well and truly opened…
Some of that applies rather often, sure, especially in forum topics like these. And especially where people offer no justification, or the justification of "my experience is bigger than your experience" (generally involving a large helping of assumption). For me, I just figure a programming language is a tool to get a job done, not the purpose unto itself. (Unless, of course, developing it actually
is your job…) But while some languages go out of their way to give you a good correctness to work ratio, so you can concentrate on the task at hand — regardless of your skill level, or superiority complexes — others just, don't. That said, there is no such thing as the perfect language and every language has it's niche (a big part of why there are so many of them), and love or hate, is often determined by whether a language suits your style of thinking, and your style of thinking is often determined by the language(s) to which you are familiar — a somewhat self-reinforcing pattern, at least until you've picked up enough to a reasonable degree that they all start to blur together as merely differing dialects of each other.
Those other languages however, seem to be determined to sneak every corner case they can find into your path. Yes, with due care and experience, you can still still write some good code in pretty much anything, but I always find it a bad sign when a language adds the === equality operator — it's usually a pretty good indication you're in for a loooong learning curve, just to avoid tripping over it's footguns. A language has failed, if it takes an average person years of experience to just code correctly — and a quick read of PHP package issues tends to make my point for me. ( md5('240610708') == md5('QNKCDZO'), anyone?) It's something I see all too often in PHP, JavaScript, and C/C++ — though in C++'s case, that's mostly because it's just such a large language over all, with an astounding amount of very bothersome legacy (and that stuff you said about it at the end). I will (and did) say, in C/C++'s case, I fall into the camp of people who don't have too much trouble, because we stick with our trodden path — even if mine is slightly different to many, on account of having been a little spoilt by D, before picking up C++ again.
I also note that people who are arguably very good at C++ … still fall afoul of it's quirks with frightful regularity. And for most people I've come across who don't (myself included), it's because they tend to stick to the parts they know and avoid the rest. C++ is just like that. If you truly have a good grasp across the full breadth of the language, you're either a vastly above-average programmer (in which case your opinion matters little to us mere mortals), don't have a life outside of programming (you
definitely need more hugs), or C++ is the only language you can claim to know terribly well — this is just the reality of C++. And its for those reasons rather than anything particularly technical, that I can't say I like it.
There's also good evidence that C++ was awakened from it's long doze by my pet favourite, too. There was clearly someone whispering in C++'s ear, telling them about all the things they're lagging behind in. So if nothing else, D is inspirational!
There were some “wow, nice” moments. One is the underlying model of ECMAScript, though that is almost never used in practice and very rarely understood.
On that note, I often say to people, JavaScript (and by extension ECMAScript) is a fantastic
academic language, for languages sake — and is also significantly unfit for the purpose it finds itself most commonly being used, and should especially never have been let anywhere near the internet. The incredible amount of work that's gone into (and is still going into) making it both performent, and most importantly safe (and the frequent issues incurred attempting to achieve both at the same time), is proof enough of that. For the role to which JavaScript is generally applied, you should have to work hard to make it unsafe, not the other way around. Good or bad as it is in and of itself, judged on the purpose for which it is most often applied (and often out of necessity at that), it fails quite badly (though, still not quite the worst). Yes, you
can be good at it, but that's true of any language, and not cause enough to count it a "good" language in my book — and it's quirks and gaping large holes annoy me frequently, so no, I don't like it.
Then there's the point that you simply can not design a well rounded cohesive language, in what was it, 10 days? You're never going to get a good quality language like that, and so many of it's design choices rather clearly tell that tale. (Much the same holds true for Visual Basic, if not worse from what I recall, and I don't much like that one, either.)
Home
Help
Search
Login
Register
Poll
