How Node.js Event Loop handles thousands of requests

💡 Today I learned how libuv works behind the scenes in Node.js When we talk about Node.js, it mainly has two core parts: 1. ⚙️ V8 Engine – Executes JavaScript code. 2. ⚡ libuv – Handles all the asynchronous, non-blocking I/O operations. Whenever we write JavaScript code in Node.js, the V8 engine runs the synchronous parts line by line. But when Node encounters an async task like: fs.readFile() setTimeout() https.get() …it offloads them to libuv so the main thread doesn’t get blocked. 🔍 What libuv Does? libuv is the superhero that makes Node.js non-blocking. It manages: - A Thread Pool (for file system & network tasks) - Multiple Callback Queues (for timers, I/O, immediates, etc.) - The Event Loop (that decides when each callback should run) 🌀 How the Event Loop Works The event loop in libuv runs continuously in cycles and has four main phases: 1.⏱️ Timer Phase – Executes callbacks from setTimeout() & setInterval(). 2.⚙️ Poll Phase – Executes most I/O callbacks like fs.readFile() or https.get(). 3.🚀 Check Phase – Executes callbacks from setImmediate(). 4.🧹 Close Phase – Handles cleanup tasks like closing sockets. Between every phase, Node checks for microtasks like process.nextTick() and Promise callbacks, which have higher priority and run before moving to the next phase. ⚡ In Short: 1. V8 runs your code synchronously. 2. Async tasks go to libuv. 3. libuv manages them in background threads. 4. The event loop schedules their callbacks efficiently. That’s how Node.js achieves asynchronous, non-blocking I/O even though JavaScript is single-threaded! 🧠✨ #NodeJS #JavaScript #WebDevelopment #Backend #LearningInPublic #libuv #EventLoop #AsyncProgramming

Async/Await — cleaner code, same engine. Let’s decode the magic behind it ⚙️👇 Ever heard the phrase — “JavaScript is asynchronous, but still runs in a single thread”? That’s where Promises and Async/Await come into play. They don’t make JavaScript multi-threaded — they just make async code smarter and cleaner 💡 Here’s a quick look 👇 // Using Promise fetchData() .then(res => process(res)) .then(final => console.log(final)) .catch(err => console.error(err)); // Using Async/Await async function loadData() { try { const res = await fetchData(); const final = await process(res); console.log(final); } catch (err) { console.error(err); } } Both do the same job — ✅ Promise handles async tasks with .then() chains ✅ Async/Await makes that flow look synchronous But what’s happening behind the scenes? 🤔 The V8 engine runs your JS code on a single main thread. When async functions like fetch() or setTimeout() are called, they’re handled by browser APIs (or libuv in Node.js). Once those tasks complete, their callbacks are queued. Then the Event Loop picks them up when the main thread is free and executes them back in the call stack. In simple words — > Async/Await doesn’t change how JavaScript works. It just gives async code a clean, readable face 🚀 That’s the power of modern JavaScript — fast, efficient, and elegant ✨ #JavaScript #AsyncProgramming #WebDevelopment #Frontend #FullStack #NodeJS #ReactJS #MERNStack #Coding #SoftwareEngineering #DeveloperLife

🚀 𝐃𝐚𝐲 𝟏 – 𝐍𝐨𝐝𝐞.𝐣𝐬 𝐄𝐯𝐞𝐧𝐭 𝐋𝐨𝐨𝐩 𝐃𝐞𝐞𝐩 𝐃𝐢𝐯𝐞 🔁 💚 Day 1 of my 15-Day Advanced Node.js Challenge! Today’s topic: The Event Loop in Node.js 🌀 The Event Loop is the heart of Node.js — it allows JavaScript to handle asynchronous operations efficiently, even though it runs on a single thread. Let’s test your Node.js knowledge 👇 ❓ 𝐐𝐮𝐞𝐬𝐭𝐢𝐨𝐧: 𝐖𝐡𝐞𝐧 𝐲𝐨𝐮 𝐫𝐮𝐧 𝐭𝐡𝐞 𝐜𝐨𝐝𝐞 𝐛𝐞𝐥𝐨𝐰, 𝐰𝐡𝐚𝐭 𝐝𝐨 𝐲𝐨𝐮 𝐭𝐡𝐢𝐧𝐤 𝐠𝐞𝐭𝐬 𝐩𝐫𝐢𝐧𝐭𝐞𝐝 𝐟𝐢𝐫𝐬𝐭? 𝐜𝐨𝐧𝐬𝐨𝐥𝐞.𝐥𝐨𝐠("𝐒𝐭𝐚𝐫𝐭"); 𝐬𝐞𝐭𝐓𝐢𝐦𝐞𝐨𝐮𝐭(() => 𝐜𝐨𝐧𝐬𝐨𝐥𝐞.𝐥𝐨𝐠("𝐓𝐢𝐦𝐞𝐨𝐮𝐭"), 𝟎); 𝐏𝐫𝐨𝐦𝐢𝐬𝐞.𝐫𝐞𝐬𝐨𝐥𝐯𝐞().𝐭𝐡𝐞𝐧(() => 𝐜𝐨𝐧𝐬𝐨𝐥𝐞.𝐥𝐨𝐠("𝐏𝐫𝐨𝐦𝐢𝐬𝐞")); 𝐜𝐨𝐧𝐬𝐨𝐥𝐞.𝐥𝐨𝐠("𝐄𝐧𝐝"); 🧠 Why? console.log() runs immediately (synchronous). setTimeout() goes to the macrotask queue. Promise.then() goes to the microtask queue, which runs before macrotasks. ⚙️ Key takeaway: The Event Loop first completes synchronous code, then runs microtasks, then moves to macrotasks (like timers). Understanding this helps write non-blocking, high-performance Node.js apps and makes debugging async code much easier! 💬 Your turn: Have you ever faced confusing async behavior in your Node.js code? How did you fix it? #NodeJS #EventLoop #AsyncProgramming #BackendDevelopment #LearningInPublic #JavaScript #15DaysChallenge #Developers

🚀 Async/Await vs Promises — When and How to Use Them Ever got confused about when to use Promises or Async/Await in Node.js or JavaScript? Let’s simplify it 👇 ⚙️ Promises Represent a value that may be available now, later, or never Great for chaining multiple async tasks But can become messy with too many .then() calls 🧩 Example: getUserData() .then(user => getPosts(user.id)) .then(posts => console.log(posts)) .catch(err => console.error(err)); ⚡ Async/Await Cleaner, more readable syntax for handling Promises Makes async code look synchronous Easier to handle errors with try...catch 🧩 Example: async function fetchUserPosts() { try { const user = await getUserData(); const posts = await getPosts(user.id); console.log(posts); } catch (err) { console.error(err); } } 💡 When to Use What ✅ Use Async/Await for sequential tasks and cleaner code ⚡ Use Promises (or Promise.all) for parallel async operations 🧠 Pro Tip: Both work on the same concept — non-blocking Promises. Async/Await just helps you think synchronously while running asynchronously. 🔥 Mastering this difference will make your Node.js code more efficient and elegant! #NodeJS #JavaScript #AsyncAwait #Promises #WebDevelopment #CodingTips #100DaysOfNode

🚀 𝐌𝐚𝐬𝐭𝐞𝐫𝐢𝐧𝐠 𝐭𝐡𝐞 𝐍𝐨𝐝𝐞.𝐣𝐬 𝐄𝐯𝐞𝐧𝐭 𝐋𝐨𝐨𝐩 🔄 Node.js, with its single-threaded JavaScript environment, relies on a robust event loop to manage asynchronous operations, like API calls. Let's break down the key components that power this magic: 🔹 1️⃣ Call Stack – The current function that's being executed. 🔹 2️⃣ Microtask Queue – Where high-priority tasks like Promise callbacks wait to run. 🔹 3️⃣ (Macro) Task Queue – Queues up tasks like setTimeout, I/O events, etc. Each iteration of the event loop picks one from here. 𝑯𝒆𝒓𝒆'𝒔 𝒘𝒉𝒂𝒕 𝒎𝒂𝒌𝒆𝒔 𝒊𝒕 𝒄𝒍𝒆𝒗𝒆𝒓: 🌟 Microtasks First Before Node.js goes to the next task in the task queue, it clears out all microtasks. Even new ones added during execution no delays, no skipping! ⏩ One Task Per Loop Each loop iteration executes exactly one task from the macro queue, then goes back to process any pending microtasks. 🔁 Instant Sync If a microtask triggers another microtask—it still gets executed in the same loop cycle. No waiting around! Mastering this event loop flow is essential to building fast, smooth, and responsive Node.js apps. Nail these concepts, and you'll be dancing through async JavaScript with confidence! 👨💻 Image Credit: Nicolas Wagner Follow Gaurav for more such posts :) #NodeJS #EventLoop #AsyncJavaScript #WebDevelopment #LinkedInLearning #InterviewQuestions #JavaScript #FullStackDeveloper

🚀 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗖𝗹𝗼𝘀𝘂𝗿𝗲𝘀 When a function remembers the variables outside its scope that’s a closure. Here’s all you need 👇 𝘧𝘶𝘯𝘤𝘵𝘪𝘰𝘯 𝘮𝘢𝘬𝘦𝘊𝘰𝘶𝘯𝘵𝘦𝘳() {  𝘭𝘦𝘵 𝘤𝘰𝘶𝘯𝘵 = 0;  𝘳𝘦𝘵𝘶𝘳𝘯 𝘧𝘶𝘯𝘤𝘵𝘪𝘰𝘯() {   𝘤𝘰𝘶𝘯𝘵++;   𝘤𝘰𝘯𝘴𝘰𝘭𝘦.𝘭𝘰𝘨(𝘤𝘰𝘶𝘯𝘵);  }; } 𝘤𝘰𝘯𝘴𝘵 𝘤𝘰𝘶𝘯𝘵𝘦𝘳 = 𝘮𝘢𝘬𝘦𝘊𝘰𝘶𝘯𝘵𝘦𝘳(); 𝘤𝘰𝘶𝘯𝘵𝘦𝘳(); // 1 𝘤𝘰𝘶𝘯𝘵𝘦𝘳(); // 2 Even after 𝗺𝗮𝗸𝗲𝗖𝗼𝘂𝗻𝘁𝗲𝗿() is done 𝗰𝗼𝘂𝗻𝘁 is still remembered 🔥 That’s closure one of JS’s smartest tricks. 💡 𝗪𝗵𝘆 𝗶𝘁 𝗺𝗮𝘁𝘁𝗲𝗿𝘀: Closures let you keep data private, avoid global variables, and build stateful logic like counters, event handlers, and API wrappers. #CareerGrowth #JavaScript #WebDevelopment #100DaysOfCode #CodingTips #Frontend #NodeJS #ReactJS #DevCommunity #WebDev #PakistanTech #technology #FreelancingPakistan #StartupPK

If both Promises and async/await do the same job, why does the output look different? Both handle asynchronous code in Node.js, but the way they execute makes all the difference. When using a Promise, the code in the main thread doesn’t wait for the background task to finish. It proceeds and executes the next lines while the background task continues. console.log("Start"); // API call (takes 2 seconds) fetch(`https://lnkd.in/dFBr7zPe) // Returns a Promise .then(() => console.log("API call done!")); console.log("End"); Output: Start End API call done! (after 2 seconds) That’s because the main thread doesn’t stop; it just keeps going. Now see the same thing with async/await console.log("Start"); // API call (takes 2 seconds) await fetch(`https://lnkd.in/dFBr7zPe); console.log("API call done!"); console.log("End"); Output: Start API call done! End In the case of await, the main thread pauses execution until it receives the result from the background task. During this wait, that part of the code is temporarily removed from the call stack. Once the result comes back, execution resumes from the same line and continues normally. Here, await tells Node.js to wait for the result before moving ahead. That’s why async/await code is more readable and easier to follow than using .then(). #Nodejs #JavaScript #AsyncProgramming #WebDevelopment #CodingTips

🤔 𝗕𝗲𝗳𝗼𝗿𝗲 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝘀𝘁𝗮𝗿𝘁𝘀 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗻𝗴... 𝘄𝗵𝗮𝘁 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗵𝗮𝗽𝗽𝗲𝗻𝘀 𝗶𝗻𝘀𝗶𝗱𝗲 𝘁𝗵𝗲 𝗲𝗻𝗴𝗶𝗻𝗲? I was revisiting some JS fundamentals and came across something interesting — Before 𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝗖𝗼𝗻𝘁𝗲𝘅𝘁, 𝗖𝗮𝗹𝗹 𝗦𝘁𝗮𝗰𝗸, or 𝗦𝗰𝗼𝗽𝗲 𝗖𝗵𝗮𝗶𝗻 even exist… the JS engine has already done a lot of work. ⚙️ 𝗦𝗼 𝘄𝗵𝗮𝘁 𝗱𝗼𝗲𝘀 𝗮 𝗝𝗦 𝗲𝗻𝗴𝗶𝗻𝗲 𝗱𝗼 𝗯𝗲𝗳𝗼𝗿𝗲 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻? Let’s take Google Chrome’s V8 Engine (also used in Node.js) as an example: 1️⃣ Reads your code as plain text 2️⃣ Breaks it into small tokens (let, {}, function, etc.) 3️⃣ Builds a structured tree called 𝗔𝗦𝗧 (𝗔𝗯𝘀𝘁𝗿𝗮𝗰𝘁 𝗦𝘆𝗻𝘁𝗮𝘅 𝗧𝗿𝗲𝗲) 4️⃣ Checks for syntax errors here (before running anything) 5️⃣ Converts AST → 𝗕𝘆𝘁𝗲𝗰𝗼𝗱𝗲, ready for execution Only 𝗮𝗳𝘁𝗲𝗿 𝗮𝗹𝗹 𝘁𝗵𝗶𝘀 — the 𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 is created, hoisting happens, and your code finally starts running. And yes, this process isn’t just for 𝗩𝟴 (𝗖𝗵𝗿𝗼𝗺𝗲 / 𝗡𝗼𝗱𝗲.𝗷𝘀) — 𝗦𝗽𝗶𝗱𝗲𝗿𝗠𝗼𝗻𝗸𝗲𝘆 (Firefox), 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁𝗖𝗼𝗿𝗲 (Safari), and even 𝗖𝗵𝗮𝗸𝗿𝗮 (old Edge) do something similar. Different engines, same concept: 𝗣𝗮𝗿𝘀𝗲 → 𝗔𝗦𝗧 → 𝗕𝘆𝘁𝗲𝗰𝗼𝗱𝗲 → 𝗘𝘅𝗲𝗰𝘂𝘁𝗲 → 𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗲 It’s wild how much JavaScript does before we even hit that first 𝘤𝘰𝘯𝘴𝘰𝘭𝘦.𝘭𝘰𝘨() 😅 #javascript #v8engine #javascriptcore #nodejs #executioncontext #namastejavascript #programming #learninpublic #frontend #backend #techcommunity

🚀 𝗗𝗲𝗲𝗽 𝗖𝗹𝗼𝗻𝗲 𝗢𝗯𝗷𝗲𝗰𝘁𝘀 𝗶𝗻 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 (𝘁𝗵𝗲 𝗥𝗜𝗚𝗛𝗧 𝘄𝗮𝘆) Most of us have cloned objects at some point using: const clone = JSON.parse(JSON.stringify(obj)); But… this method silently breaks things 😬 It: ❌ Removes functions ❌ Converts Date objects into strings ❌ Loses undefined, NaN, and Infinity ❌ Completely fails with Map, Set, or circular references So what’s the better approach? ✅ Option 1: Use structuredClone() Modern, fast, and now available in most browsers + Node.js (v17+). It correctly handles: • Dates • Maps • Sets • Circular references No fuss. No polyfills. Just works. ✅ Option 2: Write your own deep clone (for learning) A recursive deep clone function helps understand how object copying really works. (Sharing my implementation in the code snippet images above 👆) ⚡ Pro Tip: If you're dealing with complex nested objects, just use structuredClone(). It’s native, efficient, and avoids hours of debugging later. 🔥 If you found this helpful, 👉 Follow me for more bite-sized JavaScript insights. Let’s learn smart, not hard 🚀 #JavaScript #WebDevelopment #Frontend #NodeJS #CodeTips

𝗨𝗻𝗹𝗼𝗰𝗸𝗶𝗻𝗴 𝗥𝗲𝗮𝗰𝘁 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 𝗶𝘀𝗻'𝘁 𝗮𝗯𝗼𝘂𝘁 𝘁𝗵𝗲 𝗹𝗮𝘁𝗲𝘀𝘁 𝗹𝗶𝗯𝗿𝗮𝗿𝘆; 𝗶𝘁'𝘀 𝗮𝗯𝗼𝘂𝘁 𝗺𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝘁𝗵𝗲 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗲𝗻𝗴𝗶𝗻𝗲 𝘁𝗵𝗮𝘁 𝗽𝗼𝘄𝗲𝗿𝘀 𝗶𝘁. 💡 While React evolves, its power remains an abstraction over core JavaScript. A deep understanding of these fundamentals is what separates proficient developers from elite engineers. Here are 𝘁𝗵𝗿𝗲𝗲 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗽𝗶𝗹𝗹𝗮𝗿𝘀 every developer must master: 𝟭. 𝗖𝗹𝗼𝘀𝘂𝗿𝗲𝘀 A closure is a function that remembers its surrounding state (𝗹𝗲𝘅𝗶𝗰𝗮𝗹 𝗲𝗻𝘃𝗶𝗿𝗼𝗻𝗺𝗲𝗻𝘁), giving it access to its outer scope even after the outer function has returned. In React, it's the core mechanism for Hooks like useState and useEffect, allowing them to persist state across re-renders. Misunderstanding this causes stale state and flawed dependency arrays. Code example: function createCounter() {  let count = 0;  return function() {   count++;   console.log(count);  }; } const myCounter = createCounter(); myCounter(); // 1 𝟮. 𝗧𝗵𝗲 '𝘁𝗵𝗶𝘀' 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 & 𝗔𝗿𝗿𝗼𝘄 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀 In JavaScript, this refers to the function's execution context. Arrow functions (=>) solve binding issues in class components by lexically inheriting this from their parent scope. Though less common now, understanding this is vital for maintaining legacy codebases and many JS libraries. 𝟯. 𝗔𝘀𝘆𝗻𝗰𝗵𝗿𝗼𝗻𝗼𝘂𝘀 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 (𝗮𝘀𝘆𝗻𝗰/𝗮𝘄𝗮𝗶𝘁) async/await is syntactic sugar over Promises that simplifies asynchronous code. In React, it’s the standard for managing API calls in useEffect, enabling clean handling of loading/error states and avoiding the "pyramid of doom." Mastering these concepts elevates you from simply using React to truly architecting with it. 𝗕𝗲𝘆𝗼𝗻𝗱 𝘁𝗵𝗲𝘀𝗲 𝘁𝗵𝗿𝗲𝗲, 𝘄𝗵𝗶𝗰𝗵 𝗲𝘀𝗼𝘁𝗲𝗿𝗶𝗰 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗯𝗲𝗵𝗮𝘃𝗶𝗼𝗿 𝗱𝗼 𝘆𝗼𝘂 𝗯𝗲𝗹𝗶𝗲𝘃𝗲 𝗵𝗮𝘀 𝘁𝗵𝗲 𝗺𝗼𝘀𝘁 𝗽𝗿𝗼𝗳𝗼𝘂𝗻𝗱 𝗶𝗺𝗽𝗮𝗰𝘁 𝗼𝗻 𝗹𝗮𝗿𝗴𝗲-𝘀𝗰𝗮𝗹𝗲 𝗥𝗲𝗮𝗰𝘁 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀? #JavaScript #ReactJS #WebDevelopment #MERNstack #SoftwareEngineering #Coding