JavaScript vs Scala

JavaScript looks for every possible way to treat the code you write as runnable and is very reluctant to point out likely errors. For example, you have call a function with too many arguments, the extra arguments are simply discarded.

If you forget a var or new, you can clobber the global scope. For tiny scripts (JavaScript's original use case) globals are great, but for larger applications globals are generally regarded as a Bad Thing. This is because changes to one small part of a program can randomly break things anywhere else. These kinds of bugs are notoriously hard to find.

'5' - 1 == 4, but '5' + 1 == 51. There are other examples that make even less sense.

this is bound to whatever object called the function. Unless you invoke it as a method. Unless you invoke it as a constructor. Unless it's an arrow function.

Since JavaScript is a dynamically typed language, you don't have to learn about data types if you start using JavaScript as your first language. Data types being one of the most important concepts in programming. This will also cause trouble in the long run when you will have to (inevitably) learn and work with a statically typed language because you will be forced to learn the type system from scratch.

JavaScript has a long litany of warts and gotchas. JavaScript will bite you if you're just a wee bit careless. You have to exercise a great deal of caution and awareness. You either have to know the entire 545-page ES6 spec to avoid them all, or use a linter to help restrict you from using the bad parts (and you still have to be familiar with the language), but beginners don't know these things. (Linters are also prone to time-wasting false positives.) This is a significant cognitive burden on even the experienced programmer (as if coding wasn’t hard enough already), but try learning to program in the first place on top of all of this and you'll understand that JavaScript is a terrible choice for the beginner.

Much often needed functionality is not in the standard library. (Contrast with Python.) However, there are well established libraries such as Lodash, to fill the gap (however, due to the diverse/fractured ecosystem it may not be clear what library to use).

Therefore, attempts to call methods on them will fail. This is especially frustrating since these are often returned instead of throwing exceptions. So a failure may appear far away from the actual cause, which makes bugs very hard to find.

Beginner programmers often make the mistake of coding something, seeing it works in the browser they tested it in, and then scratching their heads when it doesn't work in another browser. Ideally you'd want a language that works consistently across all platforms in order to be able to focus more on the programming and less on the underlying environment. It just takes time away from learning and forces you to spend time figuring out why this worked in browser X but not browser Y.

This is very surprising for beginners. Especially since 00 through 07 seem to work just fine. And this isn't just for hardcoded numbers. The parseInt() function has the same problem, but only on some systems.

Many cases when you should get an Array, you just get an Array-like object instead and none of the Array methods work on it.

JavaScript is a language that is ran inside of the browser. Because of this, you are limited to what the browser can do. Sometimes they even have different functions to accomplish the same thing! A great example of this is the following:

This works in Chrome and IE:

document.getElementById("foo").innerText;

And this works in FireFox and Chrome and IE:

document.getElementById("foo").textContent

You're also unable to use some of the less-popular CSS3 features in one browser versus the other. Can't give a detailed list due to ongoing development.

JavaScript can work synchronously but its current use is mainly around asynchronous instructions, and it's surely not a good way to start learning programming.

Given "" == 0 is true, and 0 == "0" is true, therefore "" == "0" is false. What?

The language and the web platform move fast these days. this makes it difficult for students as there is a lot of fragmentation and outdated information.

The closest JS gets (IMHO) is jQuery for consistent DOM api. From libraries to fill the hole left by no comprehensive standard library (eg: lodash, underscore, ramda, functionaljs, sugar, core-js, stdlib, locutus, or the N implementations of range or pad on npm), to front-end frameworks (angular, aurelia, vue, react, ember, polymer, etc), and everything in between; the JS ecosystem is hugely diverse and there is rarely a "major" library or framework for a given purpose.
This is overwhelming for a new user. While diversity is good, at least having a major/primary library/framework for a given need/use is highly desirable for a "learn this first"language in order to be productive and focused (not to mention finding fast and accurate help from the community).

Trying to keep up=javascript fatigue. You won't have time to learn anything else if this is your first language, and you will probably think all programmers are crazy. Plus web assembly may open the door for better alternatives.

You really want to be using a good editor (light IDE) and a linter, type checker (e.g.:Flow), etc. until you grok the language. And choosing / setting-up that development environment is it's own learning curve. If taught in a classroom, using a subset of JS with solid tools, there is an argument that JS could be an ideal first language... however, that is a lot of ceremony to protect the new programmer from JS gotchas. But without the tools, JS can be a very painful painful first language (trying to figure out why your code isn't doing what you intended).

But beginners won't know better. And even after you learn, you might have to deal with others' code that uses the bad stuff. JavaScript was originally developed in 10 days. It just wasn't designed that carefully.

JavaScript is rather inconsistent when dealing with different types. For example, when working with the + operator and two numbers, they will be added, two strings will be concatenated:

3+5; // 8;
"Hello "+"world"; // "Hello world"

When using + with a string and a non-string operand, the non-string operand is converted to a string and the result is concatenated:

"the answer is "+42; // "the answer is 42"
"this is "+true; // "this is true"

In any other case (except for Date) the operands are converted to numbers and the results are added:

1+true; // = 1+1 = 2; 
null+false; // = 0+0 = 0;

Angular, React, Ember, Meteor, Backbone, Knockout, Express, Mithril, Aurelia. The web frameworks pass in and out of fashion too quickly to keep up with. The endless civil wars are becoming tiresome.

Scala is an industrial language. It brings functional programming to the JVM, but not with a "start small and grow the language" perspective, but rather a very powerful language for professional programmers.

The type system is too complicated yet still less powerful than Haskell's.

Even for seasoned programmers it's a difficult language.