Why is there a JavaScript hate?
There are several key reasons why some developers hate JavaScript. JavaScript hate is actual because
- JavaScript is really easy to use. Even an normal person can use it. C++, Java, and other languages have a higher barrier to entry. And with junior developers writing a lot of JavaScript, a lot of JavaScript is going to be crap. This is not a a fault of the language, but a side effect of ease-of-use.
- JavaScript has faults. Other answers go into great detail about them, exaggerating many of them to the extreme, so I won’t bother with them here. It was designed quickly for marketing reasons (so they could say “we have a script language in the browser!”). The thing is, if you use ES2015 and a linter with strict rules, none of those faults are still relevant.
- Like PHP, JavaScript is a language “good” developers love to hate. It’s a signal that you’re part of the “cool” group, a dog whistle. So people rag on it to show how awesome they are. (I, ahem, may know about this particular fact, because I may have been one of those developers, once upon a time…)
- JavaScript used to suck a lot more. It’s gotten much better now with ECMAScript 2015 and more recent changes. You can transpile even ECMAScript 2016+ features into ES5, so you can use all the cool features today. But once upon a time, when many of the developers (including myself) first encountered JavaScript, there was a lot to complain about.
- Problems with the DOM get blamed on JavaScript. JavaScript is a programming language. The DOM and browser functions related to the DOM are simply a JavaScript API. JavaScript compatibility between browsers has been excellent for quite a long time. But everyone remembers the DOM API incompatibilities they had to fight with, and they paint JavaScript with the same brush.
I would say that every one of the major complaints that are found in other answers to this question has been addressed by ECMAScript 2015 and/or modern linters. That includes:
- Module systems
- A single standard class system
- The “value of this”
- Block scoping (I always have my linter enforce “no
var
keyword”) - Equality (always use
===
) - Language standardization across implementations
- Language “quirks” like semicolons (Just. F’ing. Use. Them. And make your linter enforce them! Bang, no problem!) and
parseInt
sometimes treating a leading zero as if it’s octal (when using “strict mode” parseInt won’t do that any more). - And when you’re ready for static types, it has TypeScript as a fully ECMAScript 2015-compatible JavaScript-with-types, after which you’ll never suffer another surprise type conversion that doesn’t work the way you expect.
Which is why I’m using JavaScript (actually, TypeScript) in my day job a lot these days and am not regretting it at all. There’s a lot to be said for it; it’s powerful like a Lisp, but much more readable, and includes a super-powered ecosystem of frameworks and libraries.
Finding similar topics, you should check: technology