Simple answer: Node.js is single-threaded and splits that single thread to simulate concurrency, while Elixir takes advantage of the concurrency and parallelism, native, of BEAM, Erlang's virtual machine , to execute processes simultaneously.

Below, we will understand this difference in more depth, exploring two key concepts: the Node.js event loop and Elixir's BEAM VM and OTP. These elements are crucial to understanding how each technology handles executing asynchronous tasks and how this affects performance and scalability in different applications.

1. What is the Event Loop?

Node.js operates on a single main thread and uses a mechanism called event loop to manage asynchronous operations. The basic concept is that it checks for pending tasks to be processed, such as I/O operations, promises and callbacks, and executes them when they are ready.

1.1 How it works in practice:

When an asynchronous operation is initiated (for example, a query to an API), it is delegated to libuv. Meanwhile, the event loop continues to accept other connections.
When the asynchronous operation finishes, libuv returns the result to the event queue, then event loop places the callback associated with the operation, on the call stack.

1.2 Limitations of the Event Loop:

• If a time-consuming or CPU-intensive task is on the call stack, it can block processing of other operations, reducing efficiency.

• Concurrency is limited as everything runs on a single main thread.

2. BEAM VM and OTP

Elixir is built on the BEAM VM, the same virtual machine that powers Erlang, known for its ability to handle high concurrency and resilience. Unlike Node.js, Elixir does not depend on a single thread. Instead, it uses extremely lightweight and isolated processes managed by BEAM.

2.1 How it works in practice:

• Each process in Elixir is independent, meaning they don't share memory and don't block each other.
• These processes are managed by BEAM, which can create and manage millions of processes simultaneously, distributing the load among all available CPU cores.
• In addition, Elixir comes with OTP (Open Telecom Platform), which provides a set of libraries and tools for building robust and distributed systems.

2.2 Advantages of BEAM and OTP:

• Scalability: BEAM can distribute processes across all CPU cores, maximizing resource usage.
• Resilience: If a process fails, it does not affect other processes. This allows you to build fault-tolerant systems.
• Real Competition: Unlike the event loop, which is limited to a single thread, Elixir can run processes truly in parallel, leveraging multiple CPU cores.

3. Comparing Node.js and Elixir in Practice

Let's imagine a server that needs to handle thousands of simultaneous connections, each one performing asynchronous operations and some heavy and time-consuming processing.

3.1 With Node.js:

• The server is efficient to a point, but as heavy operations pile up, the event loop starts to become overloaded. Although good use of the resources available in JS and Node can help a lot with performance: such as the correct use of async/wait and/or then/catch and built-in resources such as lib node:cluster
• This can lead to delays in responding to new connections, resulting in a significant hit to performance.

3.2 With Elixir:

• Each connection can be managed by a separate process. I/O operations, computation and even failures can be managed in isolation.
• BEAM distributes the load efficiently, ensuring that the system continues to function without major problems, even under high demand.
• If necessary, it is possible to communicate between processes via message.
• BEAM Preemptive Scheduling Mechanism.

Conclusion

Node.js is an excellent tool for many applications, especially those that deal with simple asynchronous operations and do not require heavy CPU processing. However, its single-thread-based concurrency model can be a bottleneck in more complex scenarios.

Elixir, with BEAM VM and native support for lightweight processes and massive concurrency, offers a robust and efficient alternative for systems that need to handle a large number of simultaneous operations and distribute load among multiple CPU threads. If you need resilience, scalability and high concurrency, Elixir is the choice.

While the title of this article is bold in suggesting that Elixir and BEAM outperform Node.js in asynchronous processing, it is important to recognize that there are significant differences between these technologies. The decision about which one to use must consider a variety of factors, not just the concurrency and parallelism discussed here. Aspects such as the ecosystem, the team's familiarity with the language, specific project requirements, and the nature of the tasks to be performed play a crucial role in choosing the best tool for the job. After all, each scenario has its particularities, and the choice of technology must be made with a holistic view, taking into account all the needs and challenges of the project.

Bibliography

Threads:

Threads are the smallest units of execution in a program. On many operating systems, a process can contain multiple threads, each executing a different part of the program. Threads can share memory and resources, but this can lead to concurrency issues such as race conditions.

Competition:

Concurrency is the ability of a system to handle multiple tasks at the same time. In a concurrent system, multiple tasks can progress independently even if they are not running simultaneously. BEAM, for example, manages competing processes that operate independently.

Event Loop:

The event loop is a design pattern used in systems like Node.js to manage asynchronous operations. It works in a single thread, executing tasks cyclically, responding to events such as I/O and asynchronous executions, ensuring that the program continues to respond while waiting for long operations.

Parallelism:

Parallelism is the simultaneous execution of multiple tasks on different CPU cores. Unlike concurrency, which refers to the management of concurrent tasks, parallelism involves actually executing these tasks at the same time. BEAM distributes processes across multiple cores to maximize parallelism.

Lightweight Processes:

In BEAM, lightweight processes are execution units that are much more memory and CPU efficient than traditional threads. They are isolated from each other and managed by BEAM, which allows you to create and manage millions of simultaneous processes.

Preemptive Scheduling:

Preemptive scheduling is a runtime management system where the operating system or virtual machine assigns time slices to each process, ensuring that no process monopolizes the CPU. At BEAM, this ensures that all processes have a chance to be executed fairly.

BEAM VM:

BEAM (Bogdan/Björn's Erlang Abstract Machine) is the virtual machine that runs Erlang and Elixir code. It is known for its ability to manage lightweight processes efficiently, supporting massive concurrency and parallelism, as well as providing fault tolerance.

OTP (Open Telecom Platform):

OTP is a set of libraries and design patterns that ship with Erlang and Elixir. It provides tools for building concurrent, distributed, and fault-tolerant systems, facilitating the development of robust and scalable applications.

libuv

is a cross-platform library that provides support for asynchronous I/O operations in Node.js. It is responsible for implementing the event loop and abstracting operating system functionalities, such as network operations, file system, and threads. libuv allows Node.js to efficiently execute asynchronous tasks in a single thread, utilizing an internal thread pool for blocking operations, ensuring continuity of the main event loop.

I/O operations

I/O (Input/Output) operations refer to any interaction between a program and the external world, such as reading or writing to files, communicating with hardware devices, or exchanging data over the network. These operations can be time-consuming and, on many systems, are performed asynchronously to prevent the program from blocking while waiting for the operation to complete.

References

ERLANG. The brief BEAM primer. Erlang Blog, 2020. Available at: https://www.erlang.org/blog/a-brief-beam-primer/. Accessed on: 29 Aug. 2024.

ERLANG. Getting started with Erlang [PDF]. Erlang.org. Available at: https://erlang.org/download/erlang-book-part1.pdf. Accessed on: 29 Aug. 2024.

NODE.DOCTORS. An animated guide to Node.js event loop. Dev.to, 2021. Available at: https://dev.to/nodedoctors/an-animated-guide-to-nodejs-event-loop-3g62. Accessed on: 29 Aug. 2024.

NODE.DOCTORS. Animated Node.js event loop phases. Dev.to, 2022. Available at: https://dev.to/nodedoctors/animated-nodejs-event-loop-phases-1mcp. Accessed on: 29 Aug. 2024.

NODE.JS. Cluster. Node.js, 2023. Available at: https://nodejs.org/api/cluster.html. Accessed on: 29 Aug. 2024.