We ran out of good names years ago. Then Java came along and we used up all the words beginning with J. Then the dotcom years scooped up all the domain names and all the twsted up wrds like flickr. Then npm took all the variationsofpunctuation, varations-of-punctuation and variations_of_punctuation. Now there are no virgin words left in the English speaking world.
Writing JavaScript and feeling you're surrounded by errors is pretty normal. It's a hastily-designed language. There's no getting away from the fact that everything is going to feel a little bit fragile. Just accept it and don't expect perfection.
Leading questions, I'm afraid. Yes, equality is still broken, maps are broken (and in new & interesting ways in EMCAScript 6), and the language is occasionally whitespace-sensitive.
JavaScript was hastily designed, has never recovered, and shows no sign of ever fixing the fundamental problems. :-(
Case sensitivity i'm assuming you mean the automatic semi-colon insertion due to a line break after a return statement? I have a hard time seeing this as being a reason to dislike an entire language.
Most languages have features to avoid, JavaScript is no different. Many JavaScript developers use linters to avoid the poor `==` feature. I'm unfamiliar with the argument of the `Map` datastructure implementation being broken. Do you have a reference to that claim?
Can you expand on that, please? Because it seems to me that state fulness propagates up through the system. I can't imagine a system that was pure in the large but side-effecting in the small. I'd be interested to hear how that works...
One way is to use local mutable state within functions that are implemented so as to be not rely on external state, which are then indistinguishable to calling code from pure functions.
If only there was an effect system that could guarantee purity and at the same time not be in the way (i.e. allow full or Scala-like type inference). Then purity would be guaranteed by types, like it is in Haskell. (N.B. I'm not asking for Haskell's purity by default. I advocate impure as default, with a type guarantting purity.)
Scala's compile times (along with other aspects of its development experience) are among my biggest annoyances with the language. It just seems like it should be way better than it is for such an intellectually advanced language.
I've been investing a lot of time in learning Scala because I think that it's at the head of the vanguard of a software engineering revolution, but with some of its ergonomic issues, I can't help thinking it's eventually going to lose out to something that's more elegant from a design standpoint and has better tooling.
Lightly? I'd say one of the most important features were removed - implicits and most of the typesystem magic. Kotlin feels just like Java with lambdas, better null checking. slightly improved generics and some minor syntactic refinements. Most of its "features" will be obsoleted by Java 8.
It's basically equivalent to Scala for the compilation itself (no noticeable difference).
But the browser refresh in dev mode can take up to 5 seconds (or down to under 1 sec, depends on the machine).
There is a tool that helps with this by using clever tricks to refresh the browser without reparsing the standard lib:
https://github.com/lihaoyi/scala-js-workbench
