Languages aren't compiled or interpreted: implementations are.
That's true in theory, utterly false in practice. Major design choices hinge on whether the language is intended to be interpreted or compiled. Interpreting languages that are intended to be compiled can be done but it usually amounts to compiling in the background and doesn't work out well. Compiling languages that are intended to be interpreted typically results in an order of magnitude slower performance compared to a language designed to be compiled. The information needed to optimize the compiled code just isn't there so the compiler cannot eliminate type checks, type coercions, bounds checks, overflow checks, etc. Typically all function calls are virtual and many memory accesses are doublely indirect.
Node.js isn't fast. It's concurrent. You can handle many thousands of simultaneous requests, as long as none of them are working particularly hard.
That's not what concurrent means in this context. The word you're looking for is "asynchronous". All of the javascript code you write will execute on a single thread in Node.js. Some APIs are asynchronous with a callback. That style of programming is much older than me and I'm a greybeard. Asynchronous code is great if you need the performance and can deal with the complexity but it shouldn't be the only option. And seriously, Javascript? for performance? really?
Server-side web programming can have a lot of in-flight requests being handled simultaneously, and not much need for synchronization because the requests are relatively independent (and the heavy lifting of dealing with race conditions is being handled by the database, operating system, file system and other libraries not written in javascript.) Real concurrent programming has much more data passing between threads of execution and the Node.js design of one single-threaded process per core is going to really suck for that.
Look at this stackoverflow question about Node.js and multi-core processors (scroll down to the more up to date anwser.)
"Node.js is one-thread-per-process. This is a very deliberate design decision and eliminates the need to deal with locking semantics. If you don't agree with this, you probably don't yet realize just how insanely hard it is to debug multi-threaded code."
That made me actually laugh out loud. Threads were invented because they are easier than asynchronous programming. Asynchronous programming has it's own pitfalls. Writing asychronous libraries is hard, most programmers don't have much experience with it, and many available libraries can't be used because they're not asynchronous. It's all or nothing: one blocking call (or just one long running call) and every in-flight request in that process is stalled and you have one core doing nothing. The node.js people will tell you that if you're writing long running code in javascript, you're probably doing something wrong, completely contradicting the supposed advantage of being able to do client and server code in the same language.
It's an intentional design decision all right, but not for that reason. The fact is that javascript engines like V8 were designed from day one to run in browsers and are inherently single threaded. Now that they've escaped the browser they're trying to make their single threaded nature out to be a feature. They're hyping asynchronous single threaded code because that's the only option. The browser implementers have zero interest in adding multi-threaded javascript support. Adding threaded javascript to browsers would be very difficult to say the least and rich source of new bugs, and the browsers just don't need it. Adding threading to just the server would fracture the language and remove the only advantage Node.js has. So instead Node.js tries to spin the lack of threads as a feature.
The performance "gains" people talk about with Node.js are entirely due to being single threaded and asynchronous. They're comparing asynchronous Node.js code to e.g. threaded Java. It's been well-known for decades that if you want ultimate performance you have to eliminate the overhead of context switches and go asynchronous. Again, big deal. We've known that since forever, and you can do that in many languages. C# has better language and library support for asynchronous operations. C++11 has excellent support as well. And if you want to see the ultimate in high performance asynchronous programming, just look at any OS kernel. All mainstream OSs (Linux, Windows, OS/X, iOS, BSD) are written this way, in plain old C. So most of the hype around Node.js is just because they've accidently rediscovered asychronous programming because they can't have threads.
Node.js : The speed of a dynamic interpreted language combined with the programming simplicity of low-level asynchronous systems code.
Exactly what collision course are we talking about?
The collision is that javascript is becoming the de-facto standard "byte code" and virtual machine target that other languages compile to, which is traditionally Java's (and somewhat .Net's) turf. TFA completely misses that point. The javascript VM is already deployed everywhere and the Java and .NET (and other) VMs definitely are not. Plus, for better or worse, HTML5 is a cross-platform GUI framework that actually works and both programmers and users are familiar with it. Java GUI sucks everywhere, .NET GUI sucks everywhere but Windows.
If you can write code in Java, C#, Python, or even C++, run it directly on the server, and compile it to javascript on the client, then you can use one language for the client and the server and it doesn't have to be javascript. This is both an incredibly great idea and a horrible idea at the same time. It's great because a ubiquitously deployed VM, with reasonable security and with cross-platform GUI capabilities that don't totally suck is exactly what we need. It's horrible because javascript is just the wrong tool for that, but it's what we have. As bad as it is, it can actually work pretty well in practice. Ironically the only thing really missing is threads.
This video is a pretty funny take on javascript as a bytecode.