International JavaScript Conference’s Post

🚀 Does Node.js Really Have 4 Threads? A common misconception: > “Node.js is multi-threaded because it has 4 threads.” Let’s structure this properly 👇 1️⃣ JavaScript Execution in Node.js Node.js runs JavaScript on a single main thread using: V8 Engine Event Loop Everything below runs on ONE thread: Express routes Middleware Business logic Promise callbacks async/await Timers 👉 This is why Node.js is called single-threaded. 2️⃣ Where Do the 4 Threads Come From? Node.js uses libuv internally. libuv provides: A thread pool Default size = 4 threads These threads handle blocking system-level tasks. 3️⃣ What Actually Uses the Thread Pool? The 4 threads are used for: File system operations (fs) Crypto tasks (bcrypt, pbkdf2) Compression (zlib) DNS lookups (non-network) Flow: 1. Blocking task detected 2. Task offloaded to libuv 3. One thread processes it 4. Result returned to Event Loop 5. Callback executed on main thread 4️⃣ Important Clarification Node.js is: ✅ Single-threaded for JavaScript execution ✅ Multi-threaded internally for I/O handling ❌ Not multi-threaded for your business logic If true parallel JavaScript execution is required: worker_threads cluster Multiple Node processes Understanding this distinction helps design better APIs, avoid CPU blocking, and build scalable backend systems. #NodeJS #JavaScript #BackendDevelopment #EventLoop #Libuv #AsyncProgramming #ScalableSystems #SystemDesign #FullStackDevelopment

The function shown in the picture is a Generator Function in JavaScript. It’s capable of handling even infinite loops and comes with three built-in methods: next(), return(), and throw(), each with its own functionality. The most powerful feature, however is the yield keyword, which can pause the function until a value is successfully processed. Recently, I solved a LeetCode problem using a generator to create a nested array sequence. This exercise helped me understand both algorithms and generator functions better. Here’s the twist I discovered: "yield" has an extra superpower it pauses the main function until the "yield" statement completes, giving you precise control over execution flow. Now I’m curious what do you think is the time complexity of this function? Comment below! #JavaScript #WebDevelopment #C2C #DataStructures #LeetCode #USjobs #FullStackDevelopment #GeneratorFunction #TechLearning #SoftwareEngineering #CodeOptimization #JSDeveloper #TechCommunity

🚀Day 4/100 – Understanding JSON & Fetch in JavaScript Today I focused on two fundamental concepts in modern web development: 1️⃣ JSON (JavaScript Object Notation) JSON is the standard format for sending data between a client and a server. Key things I reinforced today: Keys must be in double quotes Strings must use double quotes Numbers & booleans don’t need quotes JSON stores only data (no functions, no undefined) I practiced converting between objects and JSON: JSON.stringify() → Object ➝ JSON string JSON.parse() → JSON string ➝ Object Understanding this flow is critical because servers send data as JSON strings, and we convert them back into JavaScript objects to use in our applications. Data Flow: Server ➝ JSON String ➝ Parse ➝ JavaScript Object ➝ UI 2️⃣ Fetch API I learned how to retrieve data from an API using fetch(). Basic flow: Send request using fetch() Convert response using response.json() Use the data Also practiced the cleaner modern approach using async/await, which makes asynchronous code much more readable and scalable compared to chaining multiple .then() calls. What I Realized Today- If you don’t understand JSON and fetch deeply, you can’t properly build real-world applications. Every frontend app talks to a backend, and this is the bridge. On to Day 5. #100DaysOfCode #JavaScript #WebDev #API #JSON #CodingChallenge #Frontend #SoftwareEngineering #MERNStack #LearningEveryday

Day 52 of My #100DaysFullstackChallenge Today I explored deeper backend architecture concepts in Node.js. Instead of just writing code, I analyzed the strengths and weaknesses of what I built. What I Implemented • A custom HTML template replacement module • Routing using Node’s core http module • JSON-based data rendering • Event-Driven Architecture • A custom class extending EventEmitter • Custom event emission and listeners (Observer Pattern) Advantages I Observed  Modularization (Custom Modules) Improves maintainability, separation of concerns, and reusability.  Event-Driven Architecture Promotes loose coupling — components communicate through events instead of direct dependencies. Extending EventEmitter Makes systems scalable and structured, similar to real-world backend services.  Core HTTP Routing Helps understand how frameworks like Express actually work under the hood. Disadvantages / Trade-offs  Manual string replacement for templating does not scale well compared to template engines like EJS or Handlebars.  Event-driven systems can become difficult to debug if events are emitted in many places.  Writing routing logic with raw http quickly becomes verbose and harder to maintain as applications grow.  EventEmitter is synchronous by default — heavy handlers can block execution. Today wasn’t just about coding — it was about understanding architecture decisions and their consequences. That’s the shift from beginner to backend engineer mindset. On to Day 53. #NodeJS #BackendDevelopment #SoftwareArchitecture #JavaScript #100DaysOfCode

dotenv-gad: type-safe, validated environment variables with zero runtime surprises. Define schemas once: TypeScript Get full IntelliSense, automatic .env.example generation, schema composition, sensitive value redaction, and a CLI that checks/fixes/types everything. Plus a Vite plugin that safely exposes only client variables without leaking secrets. It’s lightweight, works with Vercel/Railway/Docker/CI, and plays perfectly with TypeScript + modern stacks. If you’re done debugging env typos in production, give it a try: → https://lnkd.in/diZSQ7fG Feedback welcome especially if you’re using it in Next.js / Express / Nest / whatever! #TypeScript #NodeJS #DeveloperTools #EnvironmentVariables #OpenSource

Deep Dive into Node.js Architecture A simple architecture diagram can look complicated at first. Event Loop. Thread Pool. libuv. Callbacks. But once I broke it down step by step, the flow became much clearer. Node.js is often described as single-threaded. What I learned is that this doesn’t limit its ability to handle concurrency — it just handles it differently. JavaScript executes inside the V8 engine on a single main thread. When an asynchronous operation is triggered — like a file read, API call, or database query — Node.js does not pause execution. Instead: • The task is delegated to libuv • libuv manages a thread pool for blocking I/O operations • Once completed, the callback is pushed into the Event Queue • The Event Loop continuously checks the call stack and executes callbacks when it becomes free The key insight for me was this: Node.js scales not because it creates more threads, but because it keeps the main thread free and coordinates asynchronous work efficiently. Understanding this internal flow changed the way I think about backend performance and system design. Next, I’ll dive deeper into how the Event Loop phases actually work. #NodeJS #BackendDevelopment #JavaScript #SystemDesign #LearningInPublic #MERNStack

Understanding the Node.js Event Loop: How JavaScript Handles Thousands of Requests with One Thread One of the most fascinating aspects of Node.js is its ability to manage massive workloads with remarkable efficiency. At the heart of this lies the event loop—a mechanism that allows JavaScript to process thousands of concurrent requests without spawning multiple threads. 🔑 Key takeaways from the article: The event loop is the backbone of Node.js’s non-blocking architecture. It enables asynchronous operations, ensuring smooth performance even under heavy traffic. By leveraging callbacks, promises, and async/await, developers can write scalable applications that remain responsive. This design is why Node.js powers everything from real-time chat apps to high-performance APIs. If you’ve ever wondered how a single-threaded language can handle workloads that traditionally require multithreading, this deep dive into the event loop is a must-read. 👉 Check out the full article to strengthen your understanding of how JavaScript achieves concurrency in such an elegant way. #Nodejs #JavaScript #WebDevelopment #Scalability #EventLoop

1️⃣ Call Stack ⭐Executes synchronous JS code ⭐LIFO (Last In, First Out) ⭐Only one thing runs at a time 2️⃣ Web APIs (Browser / Node.js) ⭐Handles async operations: ⭐setTimeout ⭐fetch ⭐DOM events ⭐Runs outside the call stack 3️⃣ Task Queues There are two important queues 👇 🟡 Microtask Queue (HIGH priority) ⭐Promise.then ⭐async/await ⭐queueMicrotask 4️⃣ Event Loop (The Manager 🧑💼) Its job: ⭐Check if Call Stack is empty ⭐Execute ALL microtasks ⭐Take ONE macrotask ⭐Repeat 🔁 forever 🔍 One-Line Visualization (Easy to remember) CALL STACK   ↓ WEB APIs   ↓ MICROTASK QUEUE (Promises) ⭐   ↓ MACROTASK QUEUE (Timers)   ↓ EVENT LOOP 🔁 #JavaScript #EventLoop #AsyncJavaScript #WebDevelopment #FrontendDeveloper #Coding #LearnToCode #DeveloperCommunity

🧠 99% of JavaScript developers answer this too fast — and get it wrong 👀 (Even with 2–5+ years of experience) ❌ No frameworks ❌ No libraries ❌ No async tricks Just pure JavaScript fundamentals. 🧩 Output-Based Question (Objects & References) const a = { x: 1 }; const b = a; b.x = 2; console.log(a.x); ❓ What will be printed? ❌ Don’t run the code 🧠 Think like the JavaScript engine A. 1 B. 2 C. undefined D. Throws an error 👇 Drop ONE option only (no explanations yet 😄) 🤔 Why this matters Most developers assume: const makes data immutable assigning creates a copy objects behave like primitives All three assumptions are dangerous. This question tests: • reference vs value • memory behavior • how objects are stored • what const actually protects When fundamentals aren’t clear: state mutates unexpectedly React bugs appear out of nowhere data leaks across components debugging becomes guesswork Strong JavaScript developers don’t just write code. They understand what lives in memory. 💡 I’ll pin the explanation after a few answers. #JavaScript #JSFundamentals #WebDevelopment #FrontendDeveloper #FullStackDeveloper #CodingInterview #DevCommunity #ProgrammingTips #LearnJavaScript #SoftwareEngineering

🧹 JavaScript is evolving to make 𝗿𝗲𝘀𝗼𝘂𝗿𝗰𝗲 𝗰𝗹𝗲𝗮𝗻𝘂𝗽 more explicit and reliable JavaScript's 𝗺𝗲𝗺𝗼𝗿𝘆 𝗺𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁 has long been implicit; garbage collection happens without developer control, and cleaning up resources like open streams, sockets, or iterators has been ad hoc at best. That's changing. A new explicit 𝗿𝗲𝘀𝗼𝘂𝗿𝗰𝗲 𝗺𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁 𝗽𝗿𝗼𝗽𝗼𝘀𝗮𝗹 in the ECMAScript standards process introduces a unified way to declare cleanup behavior. At its core, this includes: 🔹 A standard [𝗦𝘆𝗺𝗯𝗼𝗹.𝗱𝗶𝘀𝗽𝗼𝘀𝗲]() method: enabling a predictable cleanup interface across APIs. 🔹 A 𝘂𝘀𝗶𝗻𝗴 declaration: tying resource lifetime to scope so cleanup happens automatically when a variable goes out of scope. Example: 𝒄𝒍𝒂𝒔𝒔 𝑫𝒃𝑺𝒆𝒔𝒔𝒊𝒐𝒏 {  𝒄𝒐𝒏𝒏𝒆𝒄𝒕𝒊𝒐𝒏𝑺𝒕𝒓𝒊𝒏𝒈; 𝒄𝒐𝒏𝒔𝒕𝒓𝒖𝒄𝒕𝒐𝒓(𝒄𝒐𝒏𝒏𝒆𝒄𝒕𝒊𝒐𝒏𝑺𝒕𝒓𝒊𝒏𝒈) { 𝒕𝒉𝒊𝒔.𝒄𝒐𝒏𝒏𝒆𝒄𝒕𝒊𝒐𝒏𝑺𝒕𝒓𝒊𝒏𝒈 = 𝒄𝒐𝒏𝒏𝒆𝒄𝒕𝒊𝒐𝒏𝑺𝒕𝒓𝒊𝒏𝒈; 𝒄𝒐𝒏𝒔𝒐𝒍𝒆.𝒍𝒐𝒈(`𝑪𝒐𝒏𝒏𝒆𝒄𝒕: ${ 𝒄𝒐𝒏𝒏𝒆𝒄𝒕𝒊𝒐𝒏𝑺𝒕𝒓𝒊𝒏𝒈 }`); } 𝒒𝒖𝒆𝒓𝒚(𝒔𝒒𝒍) {   𝒄𝒐𝒏𝒔𝒐𝒍𝒆.𝒍𝒐𝒈(`𝑬𝒙𝒆𝒄𝒖𝒕𝒆 𝒒𝒖𝒆𝒓𝒚: ${ 𝒔𝒒𝒍 }`);   } [𝑺𝒚𝒎𝒃𝒐𝒍.𝒅𝒊𝒔𝒑𝒐𝒔𝒆]() { 𝒄𝒐𝒏𝒔𝒐𝒍𝒆.𝒍𝒐𝒈(`𝑫𝒊𝒔𝒄𝒐𝒏𝒏𝒆𝒄𝒕: ${ 𝒕𝒉𝒊𝒔.𝒄𝒐𝒏𝒏𝒆𝒄𝒕𝒊𝒐𝒏𝑺𝒕𝒓𝒊𝒏𝒈 }`); } } 𝒄𝒐𝒏𝒔𝒕 𝒄𝒐𝒏𝒏 = "𝒑𝒐𝒔𝒕𝒈𝒓𝒆𝒔://𝒍𝒐𝒄𝒂𝒍𝒉𝒐𝒔𝒕:5432/𝒂𝒑𝒑𝒅𝒃"; 𝒊𝒇 (𝒄𝒐𝒏𝒏) { 𝒖𝒔𝒊𝒏𝒈 𝒔𝒆𝒔𝒔𝒊𝒐𝒏 = 𝒏𝒆𝒘 𝑫𝒃𝑺𝒆𝒔𝒔𝒊𝒐𝒏(𝒄𝒐𝒏𝒏);  𝒄𝒐𝒏𝒔𝒕 𝒓𝒐𝒘𝒔 = 𝒔𝒆𝒔𝒔𝒊𝒐𝒏.𝒒𝒖𝒆𝒓𝒚("𝑺𝑬𝑳𝑬𝑪𝑻 𝒊𝒅, 𝒏𝒂𝒎𝒆 𝑭𝑹𝑶𝑴 𝒖𝒔𝒆𝒓𝒔 𝑳𝑰𝑴𝑰𝑻 1"); } These additions give developers a way to both name and control cleanup logic, moving beyond the inconsistent patterns we've used for years. The proposal (already implemented in major browsers except 𝗦𝗮𝗳𝗮𝗿𝗶) standardizes garbage collection and cleanup semantics, making code more predictable and easier to reason about. For engineers who care about performance, robustness, and maintainability, this is a meaningful step forward for writing 𝗿𝗲𝘀𝗼𝘂𝗿𝗰𝗲-𝘀𝗮𝗳𝗲 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁. #JavaScript #WebDevelopment #ECMAScript #FrontendDev #BrowserAPI