[Node.js] Intro to Node.js

1) What is Node.js?

  • JavaScript without browser (eg. server-side scripting, scripting); represents "Javascript Everywhere"
  • Unifying web application development around a single programming language (rather than different languages for server and client side)
  • Event-driven, non-blocking I/O model - lightweight & efficient.
  • Package ecosystem, npm, is the largest ecosystem of open-source libraries in the world.
  • Open source (free)
  • Built on Chrome's V8 Javascript engine
  • Is "fast" because it uses small amount of threads to handle many clients via asynchronous calls. However, it is only effective if each work/task is small.

2) Javascript background

Generally considered an Interpreted language, but modern Javascript engines compiles it as well (since 2009). Javascript internally compiled by V8 with just-in-time (JIT) compilation to speed up execution. While it might take a bit more to have Javascript ready, once done, it's more performant than purely interpreted code.

3) Confusion - Single or Multi Threaded?

Javascript is single or multi-threaded? This is often confusing.

Firstly, putting aside multi-threading/processing (via worker threads and clustering), the NodeJS stack/environment only have 1 execution of javascript and that runs on 1 thread; which is the single-threaded event loop. But, there are other threads (managed by libuv) in NodeJS that handles asynchronous operations, most famously the I/O operations. This is what makes NodeJS multi-threaded. A more in-depth comment is these asynchronous operations happen only when we call a library that utilizes them; more will be explained in another post.

In short, there is only 1 execution of javascript, but there are other threads running in the NodeJS stack/environment to make it more asynchronous.

Secondly, multi-threading and processing via worker threads and clustering makes it more 'multi-threaded'. Note that the only way to make > 1 instances of javascript running is to do multi-processing.

3.1) Libuv

Libuv is a C++ library that provides support for asynchronous I/O based on event loops. It is capable of multi-threading. Node.js uses libuv to operate single-threaded event loop and worker threads.

Without libuv, NodeJS is just a synchronous Javascript execution.

3.2) Single-threaded event loop

While the event loop is single-threaded, I/O operations are actually delegated to libuv from the event loop. When I/O operation are completed in libuv, it runs the callback waiting on this event and pushes it back to the main thread.

Under the hood, libuv by default creates a thread pool with 4 threads to offload asynchronous work to. Today's OS already provide asynchronous interfaces for many I/O tasks (including access to third-party systems, like database). Whenever possible, libuv will use those async interfaces, avoiding the usage of thread pool.

3.3) Worker threads

Separate threads used to compute CPU-intensive tasks, because if used in event loop, it will block the entire event loop.

Comments

Post a Comment

Popular posts from this blog

[Redis] Redis Cluster vs Redis Sentinel

1) In-Depth Guides to Redis Cluster and Sentinel For more in-depth explanation for Redis Cluster or Redis Sentinel, please read my other posts: Sentinel:  https://notafraidofwong.blogspot.com/2019/05/redis-redis-sentinel.html Cluster:  https://notafraidofwong.blogspot.com/2019/05/redis-redis-cluster.html 2) Deciding between Redis Sentinel and Redis Cluster Similarities : Both solutions provide high availability for your system. 2.1) Redis Cluster 2.1.1) Pros Shards data across multiple nodes Has replication support Has built-in failover of master 2.1.2) Cons Not every library supports it May not be as robust (yet) as Standalone Redis or Sentinel Setup and maintenance is more complicated 2.2) Redis Sentinel 2.2.1) Pros Automatically selects new master in case of failure Easy to setup, (seems) easy to maintain 2.2.2) Cons No data sharding; master might be overutilized. Another distributed system to maintain. 3) So how do I decide? In
Read more

[Unit Testing] Test Doubles (Stubs, Mocks....etc)

Image
In unit testing, isolation is key. The goal of unit testing is to test individual components, and not an entire system . The class/object/function you are testing is System Under Test (SUT) , and the other components of the system are Collaborators or Dependencies. Test Double  is a generic term for any kind of 'pretend' object used in place of a real object for testing purposes.  There are several types of Testing Doubles. We will start with: Fake Stub Mock Command Queries Mocks vs Stubs And then: Dummy Spies Spies vs Mocks I) Basic Testing Doubles a) Fake Fake are objects that have working implementations, but not same as production one. Usually they take some shortcut and have simplified version of production code. Note that Fake is a generic term - that can point to anything; usually mock and stubs. An example of this is an in-memory implementation of a database. This fake implementation will not access the actual database, but will u
Read more

[Node.js] Pending HTTP requests lead to unresponsive nodeJS

This is a recap conclusion to the potential problems of a NodeJS program I worked on previously. The program simulates thousands of clients navigating a website by sending thousands of http requests to a given API . The idea is to load test a particular API to make sure they can handle high traffic. Because we are simulating clients, it's important to keep track of the state of the simulated client as well. The problem with this program is it is buggy and becomes unresponsive from time to time (the only solution is to restart it). The problem was fixed by re-writing the entire program in Java, but it was regretful that I never had enough time to find the exact reason the nodeJS version of it failed. The following are potential causes I suspect: 1. Exceptions The NodeJS program was not written very neatly and stacked callbacks on top of callbacks on top of callbacks. This made it very difficult to keep track of exceptions and unexpected http responses are prone to happen. So
Read more