First, let's understand what the event model is. The event model allows for a single process to use multiple call stacks. This is an example of concurrency not parallelism.

Second, when people talk about multiple threads they are typically talking about SMP, or simultaneous multi-processing. JavaScript already does this. It uses WebWorkers in the browser and clusters in Node. Each of those technologies can then coordinate task execution through messaging, such as IPC. Detached-state execution allows for child processes to execute with process independence from the calling process which means killing the calling process will not terminal the child process.

Third, when people talk about multiple machine execution they are typically talking about task distribution, which is not the same as decentralization. Distribution is similar to detached-state SMP but reliant upon network access for task distribution and status.

You can achieve all this with JavaScript right now. I have done it in a personal application built around decentralization and remote file system management.

If you are talking about nodejs, there is https://nodejs.org/api/child_process.html

Same way that python does parallelism, by relying on the underlying OS to schedule threads and use multiple cores.

For JS running in browser, you probably don't want any allowance for such scheduling in the scripts, and let the JS engine in the browser automatically establish parallelism if needed.

I think if you want that, JavaScript isn’t the right tool. The single threaded simplicity is a big part of why it is a useful tool. You can always spin up external processes from within your app, or use a load balancer or queue to share work with multiple identical processes.

The idea of just horizontally scaling up a node process wouldn’t make a lot of sense. How would you share scope between the different processes for example? You would need a whole new construct, at which point you’re really throwing away the advantages you had and you should probably be using a different language.

Its a good question. There are worker threads in Node but they seem clunky to use:

https://bitsfactory.lilanga.me/posts/nodejs-utilize-multi-co...

Stateless webservers are easier, since this is merely loaf balancing. Just run more processes:

https://stackoverflow.com/questions/2387724/node-js-on-multi...

Libuv which powers Node can execute multiple event loops (one per thread).

https://docs.libuv.org/en/v1.x/design.html

You'd need to write your app code in C++ which isn't very popular in web dev.

I'm not in the node ecosystem, but can't you "just" use node worker-threads for multicore, and run node on multiple machines for multi-machine?

If you want the features of BEAM/dist plus running some javascript, I'd suggest you build your coordination layer in a BEAM language and have some glue to run javascript as a spawned port, or possibly connect node as a c_node to dist.

People used to fork the JavaScript process according to the number of cores present, but it’s less popular now because most infrastructure is provisioned by vCPUs.

So people just provisioned for vCPU=1.

Node.js (v8) already offloads io tasks to their own threads so it’s already horizontal to some extent.