DEV Community: kavin.dev

How Node.js Handles Thousands of Requests Without Blocking - The Magic of libuv

kavin.dev — Fri, 03 Jul 2026 03:02:43 +0000

When developers first learn Node.js, they often hear statements like:

"Node.js is single-threaded."
"JavaScript is synchronous."

At the same time, they see Node.js handling thousands of requests, reading files, and making API calls — without blocking the application.

So, how is that possible?

The answer is libuv.

What is libuv?

libuv is an open-source C library that provides Node.js with asynchronous, non-blocking I/O capabilities. It is one of the core components that makes Node.js fast and efficient.

JavaScript itself doesn't know how to read files, create network sockets, or manage timers. Instead, Node.js relies on libuv to communicate with the operating system and perform these tasks efficiently.

Think of it like this:

Why Do We Need libuv?

Imagine you're reading a large file.

Without asynchronous programming, JavaScript would have to wait until the file is completely read before executing the next line of code — making your application unresponsive.
With libuv, the file is read in the background while JavaScript continues executing other tasks.

Example

const fs = require("fs");

console.log("Start");

fs.readFile("data.txt", "utf8", (err, data) => {
  console.log(data);
});

console.log("End");

Output:

Start
End
(file contents)

Instead of waiting for the file to finish reading, Node.js continues executing the next statement immediately.

What Does libuv Do?

libuv is responsible for several important features in Node.js.

1. Event Loop

The Event Loop is implemented by libuv. It continuously checks whether asynchronous operations have completed.

When an operation finishes, its callback is placed in the queue, and JavaScript executes it when the call stack becomes empty. This is what allows Node.js to remain responsive even while many operations are happening simultaneously.

2. File System Operations

Operations like fs.readFile(), fs.writeFile(), and fs.appendFile() are all handled through libuv. These operations don't block JavaScript while waiting for the operating system.

3. Thread Pool

People often say:

"Node.js is single-threaded."

That's true — for JavaScript execution. However, libuv maintains a thread pool behind the scenes.

The default thread pool contains 4 worker threads. Tasks such as:

File system operations
DNS lookups
Compression
Cryptography

...are executed by these worker threads instead of blocking the JavaScript thread.

4. Network Operations

libuv also manages networking, including:

HTTP servers
TCP sockets
UDP sockets

That's one reason a Node.js server can efficiently handle thousands of simultaneous client connections.

5. Timers

Functions like setTimeout(), setInterval(), and setImmediate() are all managed internally by libuv.

How Does libuv Work? (Step-by-Step)

Let's trace through a concrete example:

const fs = require("fs");

console.log("1");

fs.readFile("notes.txt", () => {
  console.log("2");
});

console.log("3");

Execution flow:

JavaScript prints 1
fs.readFile() is handed over to libuv
JavaScript immediately prints 3
libuv performs the file read in the background
Once the file is ready, libuv places the callback into the Event Loop
The callback executes and prints 2

Output:

1
3
2

A Simple Analogy
Imagine you're waiting for pizza.

Without libuv
You:
"Is my pizza ready?"

Kitchen:
"No."

You:
"Now?"

Kitchen:
"No."

You:
"Now?"

Kitchen:
"No."

You're constantly checking.

With libuv


You:
"I'll wait."

🍕

Kitchen:
"_Your pizza is ready!_"

** Key Takeaways**

JavaScript runs on a single thread
libuv performs asynchronous operations
libuv implements the Event Loop
libuv manages timers

Summary

Feature	Handled By
Event Loop	libuv
File I/O	libuv (thread pool)
Network (TCP/UDP)	libuv
Timers	libuv
JS Execution	V8 Engine

libuv is the invisible engine that keeps Node.js non-blocking. Without it, Node.js would just be a synchronous runtime — nothing special.

Next time you call fs.readFile() or spin up an HTTP server, remember: libuv is doing the heavy lifting behind the scenes.

JWT Explained: What It Is, How It Works, and Why You Should Care

kavin.dev — Sat, 27 Jun 2026 08:28:38 +0000

If you've ever built a login system and wondered "should I use sessions or tokens?" - this one's for you.

So..What Even Is a JWT?

JWT stands for JSON Web Token, it's just a way for a server to hand a client a small, self-contained package of information that the client can carry around and present whenever it needs to prove something — like "hey, I'm logged in."

JWT vs. Sessions — What's the Difference?

Structure of a JWT

A JWT looks like this:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOiIxMjMiLCJleHAiOjE2OTAwMDB9.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Scary at first, but it's just three Base64-encoded parts separated by dots:

HEADER.PAYLOAD.SIGNATURE

Header - tells you the algorithm used (e.g. HS256):

{
  "alg": "HS256",
  "typ": "JWT"
}

Payload - the actual data. This is where user info lives

{
  "userId": "012",
  "email": "kavin@dev.to.com",
  "exp": 1690000000
}

Signature -this is what makes it trustworthy. The server creates it by signing the header + payload with a secret key:
HMACSHA256(base64(header) + "." + base64(payload), SECRET_KEY)

Quick Summary

A JWT is a signed, self-contained token the client carries around.
t has three parts: Header, Payload, Signature
Access tokens are stateless (no DB check), short-lived
Refresh tokens are stored in DB, longer-lived, used only to refresh access tokens
When an access token expires → client sends refresh token → gets a new access token (and new refresh token with rotation)
Store refresh tokens in HttpOnly cookies for better security

Understanding React Rendering Flow

kavin.dev — Wed, 27 May 2026 03:20:07 +0000

⚛️

If you're learning React, one of the most important concepts is understanding what happens internally when a component renders.

At first, React can feel magical.

You write JSX… and somehow the UI updates automatically.

But behind the scenes, React follows a very systematic rendering flow.

Let’s break it down step-by-step 👇

React Rendering Flow

Developer Writes Components
        ↓
Components Return JSX
        ↓
JSX Converts into React Elements
        ↓
React Creates Virtual DOM
        ↓
React Compares Old & New Virtual DOM
        ↓
Updates Only Changed Parts in Real DOM
        ↓
Browser Displays Updated UI

1 Developer Creates Components

In React, UI is built using components.

A component is simply a JavaScript function that returns UI.

Example:

function Welcome() {
  return <h1>Hello Captain</h1>;
}

Components make applications:

Reusable
Organized
Scalable
Easier to maintain

2 Components Return JSX

Inside components, we usually return JSX.

Example:

return <h1>Hello</h1>;

JSX looks like HTML, but it’s actually JavaScript syntax.

Browsers cannot understand JSX directly.

So React transforms it internally before rendering.

3 JSX Converts into React Elements

React converts JSX into plain JavaScript objects called React Elements.

Example:

<h1>Hello</h1>

becomes something like:

{
  type: "h1",
  props: {
    children: "Hello"
  }
}

These objects describe what the UI should look like.

React Element Structure

A React Element mainly contains:

Property	Purpose
`type`	HTML tag or component
`props`	Properties/data
`children`	Nested content
`key`	Unique ID for lists

4 React Creates the Virtual DOM

Using React Elements, React builds a Virtual DOM.

What is Virtual DOM?

A lightweight JavaScript representation of the Real DOM stored in memory.

Virtual DOM = Fast in-memory copy of UI

Instead of directly manipulating the browser DOM every time something changes, React first updates the Virtual DOM.

This makes rendering much faster and more efficient.

5 React Performs Diffing (Reconciliation)

Whenever state or props change:

React creates a new Virtual DOM.

Then React compares:

Old Virtual DOM
vs
New Virtual DOM

This comparison process is called:

Diffing / Reconciliation

React tries to identify:

"What exactly changed?"

instead of rebuilding the entire page.

6 React Updates the Real DOM

After finding the differences:

React updates only the changed parts in the Real DOM.

This selective updating is why React apps feel fast and responsive.

Benefits:

Better performance
Efficient updates
Smooth UI interactions

7 Browser Paints the Updated UI

Finally, the browser renders the updated UI on the screen.

Important point:

React manages updates,
but the browser actually displays the UI.

Why React Is Fast

React improves performance because it:

Uses Virtual DOM
Updates only changed elements
Avoids unnecessary DOM operations
Efficiently re-renders components

Final Thoughts

Understanding React’s rendering flow helps you:

Write better components
Optimize performance
Debug rendering issues
Understand hooks and state updates more deeply

Once you understand this internal workflow, React becomes much easier to reason about.

What helped you understand React rendering for the first time?

Drop your thoughts below

How to Install NVIDIA Drivers on Fedora 44

kavin.dev — Thu, 07 May 2026 03:53:34 +0000

This guide covers the RPM Fusion method — the recommended and most maintainable way to install NVIDIA proprietary drivers on Fedora. No manual .run installers, no broken dnf states.

Prerequisites

Before you start, make sure your system is fully up to date

sudo dnf upgrade --refresh

Reboot if there were kernel updates:

sudo reboot

Step 1 — Enable RPM Fusion Repositories

Fedora doesn't ship proprietary drivers by default. RPM Fusion fills that gap. You need both the free and nonfree repos:

sudo dnf install \
  https://mirrors.rpmfusion.org/free/fedora/rpmfusion-free-release-$(rpm -E %fedora).noarch.rpm \
  https://mirrors.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm

## Step 2 — Install the NVIDIA Driver

Install the akmod-nvidia package. The akmod (automatic kernel module) system automatically rebuilds the driver whenever your kernel updates — saving you from the classic "driver broke after update" headache.

sudo dnf install akmod-nvidia

*Optional *

If you need CUDA support (for ML, video encoding, etc.), add this too:

sudo dnf install xorg-x11-drv-nvidia-cuda

Step 3 — Wait for the Kernel Module to Build

This is the step most guides skip over — and it's important.

After installation, the kernel module needs to compile. Do not reboot immediately. Wait for the build to complete:

sudo akmods --force
sudo dracut --force

You can verify the module is built by running:

modinfo -F version nvidia

You should see a version number like 570.xx.xx in the output. If you see an error instead, do not reboot yet — something went wrong.

Step 4 — Reboot

Once the module is confirmed built:

sudo reboot

After rebooting, verify the driver is active:

nvidia-smi

You should see your GPU listed with the driver version and memory usage.

Wrapping Up

The RPM Fusion + akmod-nvidia approach is the most reliable way to run NVIDIA drivers on Fedora. It survives kernel updates, works across Fedora versions, and doesn't require babysitting .run scripts.

Got questions or a specific GPU edge case? Drop them in the comments below. 🐧

How To Install ROG Control Center on Fedora 44,43 Based Distros (asusctl Guide)

kavin.dev — Fri, 01 May 2026 15:08:43 +0000

If you're running an Asus ROG/TUF laptop on Fedora 42,43,44, you've probably noticed there's no official Armoury Crate for Linux. But don't worry, the open source asusctl. suite has you covered with fan control, performance profiles, GPU switching, and RGB lighting.

Step 1: Enable the COPR Repository

sudo dnf copr enable lukenukem/asus-linux
sudo dnf update --refresh

Step 2: Install asusctl and supergfxctl

sudo dnf install asusctl supergfxctl rog-control-center
sudo dnf update --refresh

Step 3: Enable Services

sudo systemctl daemon-reload
sudo systemctl enable --now asusd.service
sudo systemctl enable supergfxd.service

step 4: Verify Kernel Modules

lsmod | grep asusYou should see modules like asus_nb_wmi, asus_armoury, asus_wmi, and hid_asus listed. ## Step 5: Launch ROG Control Centerrog-control-center`

Or find it in your application menu.

Troubleshooting

asusd.service fails to start?

Run it manually to see the raw error:
sudo asusd

"Asus kernel isn't loaded" warning?

Ignore it — it's safe and cosmetic.

Profile switching not working?

asusctl profile --list
asusctl profile -P Balanced

What You Can Control

Fan Curves
Performance Profiles (silent, Balanced, Turbo)
GPU switching (Integrated / Hybrid / Dedicated)
Keyboard RGB lighting

Conclusion

No Windows VM needed anymore! The asusctl project is actively
maintained and gets better with every update.

Useful Links: