DEV Community: Node Doctors

4 FREE Resources To Boost Your Node.js Developer Career ⚡

Fabrizio Lallo — Sun, 04 Dec 2022 23:00:00 +0000

Do you want to speed up your Node.js career?

These are the resources I wish I knew when I started learning Node.js, and guess what? They are completely FREE:

1. Event Loop 🔁

An animated guide to understanding how Event Loop works under the hood.

What's better than learning through animations and graphics?

✍🏻 Andrew Hu - https://dev.to/nodedoctors/an-animated-guide-to-nodejs-event-loop-3g62
✍🏻 Fabrizio Lallo - https://dev.to/nodedoctors/animated-nodejs-event-loop-phases-1mcp

2. Broken Promises 💔

Using promises correctly is crucial to maintain Node.js performance and writing clean code.

✍🏻 James Snell & Matteo Collina- https://www.youtube.com/watch?v=yRyfr1Qcf34&t=1181s

3. Async Iterators 🔃

Knowing iteration protocols is essential to write more modern and idiomatic Javascript code.

✍🏻 Luciano Mammino - https://github.com/lmammino/iteration-protocols-workshop

4. Streams 🚰

Learning streams allow us to build efficient Node.js applications.

You can build a video streaming service or ingest and transform terabytes of data, which is in great demand nowadays.

✍🏻 Luciano Mammino - https://www.youtube.com/watch?v=yRyfr1Qcf34&t=1181s

Let's Connect 🌎
Follow us on Twitter @fabrizio.lallo and @AndrewHu368 for more Node.js content

5 Top Node.js Streams Resources You Should Learn to Level Up Your Node.js Skills 🚀💯

Fabrizio Lallo — Fri, 02 Dec 2022 12:27:31 +0000

If you want to master Node.js, stop screwing around 🛑.

Learn Streams.

Streams are the fundamental block of the essential Node.js features:

HTTP server
File management
Encryption and Decryption

This means you can build (TODAY) a video streaming service or ingest and transform terabytes of data just by learning streams.

You can use these resources and unlock all the Node.js power 🔐🔥.

1. Streams workshop 📒

Don’t you know anything about theory and practice about streams? This workshop is the gold standard and the perfect place to get started with streams—an ideal combination of theory and practical exercises.

Author ✍🏻: Luciano Mammino

Link 🔗: https://github.com/lmammino/streams-workshop

2. Everything you should know about Node.js Streams 📽️

If you are more of a “video guy,” these are fantastic walkthrough about how streams work and how you can use them in your project.

PLUS 🆕: the first video contains the new stream features introduced in Node.js v18.

Author ✍🏻: Erik Wendell

Link 🔗: https://youtu.be/BdePYKgrMh0

EXTRA:
Author ✍🏻: Luciano Mammino

Link 🔗: https://youtu.be/ldcfYB_mo6Q

3. Understanding Streams in Node.js 🔁

Modern Node.js streams with async iterator.

Author ✍🏻: Liz Parody

Link 🔗: https://nodesource.com/blog/understanding-streams-in-nodejs/

4. NodeJS Backpressuring in Streams 🚱

Backpressure is an important technique to prevent your application from being overwhelmed by data. It is essential to understand and master backpressure.

Author ✍🏻: Vladimir Topolev

Link 🔗: https://enlear.academy/nodejs-backpressuring-in-streams-52638f505e1b

5. How To Code A Video Streaming Server in NodeJS 🕹️

All Node.js stream knowledge is put into practice to build a real-world example: a video streaming service.

Author ✍🏻: Abdisalan Mohamud

Link 🔗: https://youtu.be/ZjBLbXUuyWg

If you liked the article, follow us on Twitter @fabrizio.lallo and @AndrewHu368

Credits to Conny Schneider
https://unsplash.com/photos/pREq0ns_p_E

Node.js animated: Event Loop Phases

Fabrizio Lallo — Sat, 19 Nov 2022 20:52:26 +0000

In the previous article, Node.js animated: Event Loop, you explored how Libuv and the event loop enable asynchronous task handling in Node.js' single-threaded environment. We simplified the event loop as a mechanism that pushes callbacks from a single event queue to an empty call stack. In reality, the event loop is composed of multiple phases, each responsible for specific asynchronous tasks.

The event loop phases

A phase is a FIFO queue of callbacks to execute. When the event loop enters a given phase, it executes callbacks until the queue is exhausted or the maximum number of callbacks is run and moves to the next stage.

The event loop has 6 phases, and they run in the following order:

Timers: executes callbacks scheduled by setTimeout() and setInterval().
Pending callbacks: executes I/O callbacks deferred to the next loop iteration.
Idle-prepare: only used internally.
Poll: retrieve new I/O events and execute I/O-related callbacks
Check: executes callbacks scheduled by setImmediate().
Close callbacks: some close callbacks, e.g., socket.on('close', …).

The event loop doesn’t constantly keep spinning. If there are no active I/O handlers and the event loop doesn’t need to process any callbacks, the Node.js program automatically exits. On the other hand, the event loop stops on the poll phase to capture incoming requests whenever you create a web server and the phases are empty.

Timers and check phase

You are ready to apply your newly acquired knowledge. Still, you can be disappointed when running a setTimeout after a setImmediate, or vice versa, because the result is not deterministic.

setTimeout schedules a callback after at least the defined milliseconds have elapsed. The CPU could be busy and Libuv is unable to set the task as complete before the event loop processes the timer phase. Consequently, the setImmediate callback could be run in advance, although the timer is the first phase.

In this example, the CPU is not busy, and the setTimeout callback is immediately added to its dedicated queue before setImmedate.

In this second example, the event loop starts processing the timer phase, but the timer has not expired yet, so setImmediate callback is run in advance.

Exploring the poll phase

You are now wondering how I can test the phases processing order. The following code snippet will help you prove the order of the phases.

Once Node.js starts the program, the event loop processes all the queues and blocks on the poll phase waiting for incoming requests. When someone makes a GET HTTP request to the server, the event loop goes through these steps:

The event loop pushes the request handler on the call stack.
A setImmediate callback is added in the check phase.
A setTimeout callback is scheduled in the timers phase.
The event loop moves to the check phase. The setImmediate callback is popped off from the queue and pushed on the call stack for execution.
The event loop does not move any callbacks from empty queues.
The setTimeout callback is popped off from the timer queue and pushed on the call stack for processing.

The code is available at:

Animated Node.js-02-event-loop-phases repository

Conclusion

Now, you understand the event loop and its phases. You can also tell the difference between setTimeout and setImmediate and expect a non-deterministic behavior when running them in sequence. In addition, you know that event loop blocks on the poll phase waiting for new I/O requests on a Node.js web server.

But where are promises handled in Node.js?

You will explore it in more detail in the following articles.

Resources

If you liked the article, follow us on Twitter @fabrizio.lallo and @AndrewHu368

Node.js animated: Event Loop

Andrew Hu — Sat, 05 Nov 2022 18:15:13 +0000

We have all heard about JavaScript and Node.js being single-threaded, but what does it mean in practical terms?

It means that JavaScript can do one thing at a time. For example, we cannot simultaneously multiply and sum numbers. We usually do operations in sequence. We add and then multiply or vice versa. Modern computers are fast, and the result of two or more consecutive tasks seems to be computed simultaneously, but there are exceptions.

We all have tried to scrape data from that slow website or waited more than thirty seconds before getting the result of a database query. Do we want to block our single thread from executing more tasks because of a slow database query? Luckily, Node.js doesn’t stop from running other operations because of Libuv, a C++ library responsible for the event loop and asynchronously handling tasks such as network requests, DNS resolution, file system operations, data encryption, etc.

What happens under the hood when Node.js works on tasks such as database queries? We will explore it by following this piece of code step by step.

The V8 JavaScript engine manages a call stack, an essential piece that tracks which part of our program is running. Whenever we invoke a JavaScript function, it gets pushed to the call stack. Once the function reaches its end or a return statement, it is popped off the stack.

In our example, the line of code console.log('Starting Node.js') is added to the call stack and prints Starting Node.js to the console. By doing so, it reaches the end of the log function and is removed from the call stack.

The following line of code is a database query. These tasks are immediately popped off because they may take a long time. They are passed to Libuv, which asynchronously handles them in the background. At the same time, Node.js can keep running other code without blocking its single thread.

In the future, Node.js will know what to do with the query because we have associated a callback function with instructions to handle the task result or error. In our case, it is a simple console.log, but it could be complex business logic or data processing in production applications.

While Libuv handles the query in the background, our JavaScript is not blocked and can continue with console.log(”Before query result”).

When the query is done, its callback is pushed to the I/O Event Queue to be run shortly*.* The event loop connects the queue with the call stack. It checks if the latter is empty and moves the first queue item for execution.

The code is available at https://github.com/fabrilallo/event-loop-1

Pop quiz on the event loop

Try to figure out what the following code prints on the console.

Conclusion

The event loop, the delegation, and the asynchronous processing mechanism are Node.js's secret ingredients to process thousands of connections, read/write gigantic files, handling timers while working on other parts of our code.

In the article, we saw the vital role of Libuv and its ability to handle numerous potentially long-running tasks. At the same time, we went through the event loop and its role as a bridge/connector between callbacks of asynchronous operations in the I/O event queue and the call stack. In the following articles, we will explore in greater detail how timers, I/O, promises, and ticks are handled by the different phases of the event loop.

If you liked the article, follow us on Twitter @fabriziolallo and @andrewhu368

What is Node.js?

Fabrizio Lallo — Sun, 30 Oct 2022 21:38:22 +0000

JavaScript had the reputation of being a toy language. A tool to add interactivity to web pages. For a long time, its use cases were limited to the browser, but the creation of Node.js completely changed its role in the modern web development world.

Node.js allows us to run JavaScript outside the browser, and out of nowhere, a limited language became the favorite companion for thousands of developers working on small and big projects.

Its vibrant community created many tools that power many applications on servers, desktops, and embedded systems.

Node.js is commonly used with Express or Fastify to power complex backend services.
Electron package Node.js and Chrome to create cross-platform desktop applications. It is used in production to power programmers’ favorite editor VSCode and messaging applications like Microsoft Teams.
Embedded systems can leverage low.js to develop applications.

Why Node.js?

Before Node.js

Contrary to popular belief, Node wasn’t invented to allow JavaScript outside the browser. The latter was a positive outcome. It was developed to create more performant web servers.

Ten years ago, handling multiple user connections involved the creation of a new thread, an independent unit of execution within the web server process. This methodology implied two problems:

If you perform a database query, it blocks the entire thread from executing other operations until it receives the result.

Handling concurrent connections with associated threads requires high memory consumption and increased difficulty in managing synchronization between them.

The Node.js way

JavaScript and Node.js solve the problem of threads' high memory usage and synchronization by using a single thread paired with an event loop mechanism.

In the code snippet above, Node.js can handle concurrent connections and run other pieces of code because the database query execution is delegated to the event loop. The database operation has a callback function which is run when the event loop notifies the single thread that the query is completed.

Node.js internal overview

To understand Node.js, we need to understand V8.

V8 is a C++ program that runs JavaScript code and converts it into instructions understandable by the computer microprocessor. V8 is included in Google Chrome and other browsers to run our websites JavaScript and enable our rich web experience.

The V8 engine is not limited to modern browsers but can also be embedded into any C++ program and extended with more functionalities. Not by chance, Node.js is a C++ program that integrates the V8 engine and other libraries to enrich JavaScript with new features:

libuv, the C++ library responsible for the event loop, TCP and UDP connection sockets, DNS resolution, file system operations, data encryption, etc.
C++ bindings are responsible for invoking C++ code when running Node.js-specific JavaScript code.
The JavaScript core API.

Conclusion

Node.js clever design and event loop has empowered thousands of developers and products to create web servers capable of handling thousands of concurrent connections without the hassle of threads’ high memory consumption and synchronization. Node.js event loop capabilities are not limited to database queries and concurrent connections, but they are also used in production to process large files, encrypt/decrypt data, perform network requests, etc.

You will explore in more detail the event loop in the following article.

If you liked the article, follow us on Twitter @fabrizio.lallo and @AndrewHu368