Why setImmediate() runs before setTimeout(0) in Node.js

JavaScript Silent Errors — why they sneak up on you (and how to stop them) 🕵️♂️💥 Silent errors are bugs that don’t crash your app or throw a clear error — they just do the wrong thing and quietly ruin your day. Here are the most common culprits, short examples, and quick fixes you can start using today. What “silent” looks like Your function returns undefined instead of the object you expected. An assignment quietly fails (but code keeps running). A promise rejection never gets handled and silently breaks a flow. You swallow errors in an empty catch block. Tiny examples that bite 1. Forgotten return in arrow with block body const getUser = () => { name: 'Akin' }; // NOT returning the object console.log(getUser()); // undefined — no exception, just wrong // Fix: use parentheses or an explicit return const getUser2 = () => ({ name: 'Akin' }); 2. Assignment to non-writable property (non-strict mode = silent) const o = {}; Object.defineProperty(o, 'x', { value: 1, writable: false }); o.x = 2; // no error in non-strict mode — assignment ignored console.log(o.x); // 1 // Fix: use 'use strict' or check property descriptors 3. Swallowed error try { JSON.parse(badData); } catch (e) { // silently ignored — you never know parsing failed } // Fix: log/handle, or rethrow 4. Unhandled promise rejection (can be quiet) fetch('/api/thing') .then(r => r.json()); // no .catch -> rejection may be missed // Fix: always .catch() or use try/catch with async/await How to catch these earlier (practical checklist) Enable strict mode: use strict (or use modules — they’re strict by default). Use linters: ESLint with rules like no-empty, no-implicit-globals, no-unused-vars. Type safety: adopt TypeScript or Flow to catch wrong shapes/returns. Don’t swallow errors: never leave empty catch blocks — log or handle them. Always handle promises: .catch() or try { await ... } catch (e) { ... }. Add global handlers: window.addEventListener('unhandledrejection', e => console.error(e)); window.onerror = (msg, src, line, col, err) => { ... } DevTools: enable “Pause on exceptions” and break on caught exceptions during debugging. Tests & CI: unit tests + linting in CI stop regressions before they hit users. Error monitoring: Sentry/Rollbar/Bugsnag to surface production silent failures. Quick habits that pay off Log meaningful errors (include stack + context). Fail fast — prefer throwing or returning explicit errors instead of hiding failures. Small focused functions: easier to test and reason about. Code reviews: a second pair of eyes spots “weird but not crashing” issues. Wrap-up Silent errors are the worst because they’re invisible — make noise for them. Add linting + strict mode + promise handling + some basic monitoring and you’ll catch 90% of them early. #codecraftbyaderemi #webdevelopment #javascripterrors #learnJS #javascript

Ever heard of _Time Travel Debugging_? It's no sci-fi gimmick—this technique is revolutionizing how we track down bugs in complex applications, especially in JavaScript and web dev! Imagine being able to “rewind” your code execution, inspect variables, step back and forth through each line, and understand exactly what went wrong and why—rather than guessing or relying on countless console.logs. Time Travel Debugging lets you do just that. Here’s why this matters: 1. **Faster Bug Fixes** No more wild goose chases. You can step through code execution history like a video, identifying the exact moment a variable changed unexpectedly. 2. **Better State Management Insights** For apps with complex state flows (think React, Vue, or Angular), this helps you pinpoint when and where state mutations happen, drastically easing debugging pain. 3. **Improved Collaboration** Sharing a “bug replay” with teammates means everyone sees exactly what you did, making discussion and fixes smoother. **How to Try It?** Microsoft’s Visual Studio Code has introduced built-in Time Travel Debugging for JavaScript and Node.js via its JS Debugger. You can start a debug session, hit a special “rewind” button, and voilà — history unfolds. Here’s a quick snippet showing a minimal setup for Node.js debugging with VS Code: ```json // .vscode/launch.json { "version": "0.2.0", "configurations": [ { "type": "pwa-node", "request": "launch", "name": "Debug with Time Travel", "program": "${workspaceFolder}/app.js", "trace": true, "enableTimeTravel": true } ] } ``` Once you launch this config, you get access to stepping back in time alongside regular stepping forward. **Pro Tip:** Time Travel Debugging is especially powerful for async-heavy code where understanding event order can be a nightmare. In a world where software complexity grows daily, tools like this help us reclaim sanity and become more efficient problem solvers. If you haven’t tried it yet, definitely give it a spin — time travel really is a developer superpower. Have you experimented with time travel debugging? What’s your favorite tool or tip? Let’s chat in the comments! #Debugging #JavaScript #SoftwareEngineering #WebDevelopment #VSCode #DeveloperTools #Coding #Productivity

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

Ever feel like debugging asynchronous JavaScript code is like chasing ghosts? Promise chains, callbacks, async/await—it’s powerful but can get messy quickly when errors happen or flows go unexpected. Here’s a practical little trick that changed the way I debug async code and helped me catch issues FAST: **using the “top-level await” for quick, readable testing and debugging inside Node.js!** What’s that? If you’ve used async/await inside functions, great. But did you know Node.js (since v14.8) supports top-level await in ES modules? This means you can write neat async code *outside* of functions in your scripts—perfect for quick experiments or debugging sessions. Imagine you want to test an async function that fetches data or processes something but hate setting up noisy boilerplate or immediately invoking async IIFEs. Here’s a quick snippet demonstrating top-level await in an ES module: ```js // Save as fetchUserData.mjs (for Node.js) import fetch from 'node-fetch'; async function fetchUser(userId) { const res = await fetch(`https://lnkd.in/daQmd2Bx); if (!res.ok) throw new Error('Failed to fetch user'); const user = await res.json(); return user; } // No wrapper functions needed! try { const user = await fetchUser(1); console.log('User fetched:', user.name); } catch (error) { console.error('Oops:', error.message); } ``` Why this rocks: - No need to wrap logic inside an async function or pollute code with `.then()` chains. - Easier to read & reason about during iterative debugging. - Immediate, straightforward error handling with try/catch. - Great for prototyping snippets or validating async flows on the fly. If you’re still using callbacks or cumbersome promise chains to test async functions locally, give top-level await a shot. You’ll write clearer, cleaner debugging code—and streamline your workflow. Bonus tip: Just remember to run Node.js with `--experimental-modules` flag or ensure your file has `.mjs` extension or `"type": "module"` in package.json, so top-level await works smoothly. What’s your favorite async debugging trick? Drop it below! #JavaScript #NodeJS #AsyncProgramming #DebuggingTips #WebDevelopment #CodingBestPractices #TechTrends #SoftwareEngineering

Optional chaining is one of JavaScript's most useful features. But what's the performance impact? TL;DR it's massive. I recently collaborated with Simone Sanfratello on detailed benchmarks comparing noop functions to optional chaining, and the results were revealing: noop functions are 5.5x to 8.8x faster. Running 5 million iterations clearly showed the differences. Noop functions achieved 939M ops/sec as the baseline. Optional chaining with empty objects ran at 134M ops/sec (7x slower). Optional chaining with an existing method reached 149M ops/sec (6.3x slower). Deep optional chaining was the slowest, at 106M ops/sec (8.8x slower). The explanation comes down to what V8 must do. Noop functions are inlined by V8, making them essentially zero-overhead. The function call vanishes in optimized code. Optional chaining requires property lookup and null/undefined checks at runtime. V8 can't optimize these away because the checks must occur each time. This is why Fastify uses the abstract-logging module. Instead of checking logger?.info?.() throughout the code, Fastify provides a noop logger object with all logging methods as noop functions. The key is to provide noops upfront rather than checking for existence later. When logging is disabled, V8 inlines these noop functions at almost zero cost. With optional chaining, runtime checks are required every time. One reason for excessive optional chaining is TypeScript's type system encourages defensive coding. Properties are marked as potentially undefined even when runtime guarantees they exist, causing developers to add ?. everywhere to satisfy the type checker. The solution is better type modeling. Fix your interfaces to match reality, or use noop fallbacks like "const onRequest = config.hooks.onRequest || noop" and call it directly. Don't let TypeScript's cautious type system trick you into unnecessary defensive code. Context matters, though. Even "slow" optional chaining executes at 106+ million operations per second, which is negligible for most applications. Use optional chaining for external data or APIs where the structure isn't controlled, in normal business logic prioritizing readability and safety, and to reduce defensive clutter. Use noop functions in performance-critical paths, when code runs thousands of times per request, in high-frequency operations where every microsecond counts, and when you control the code and can guarantee function existence. Even a few thousand calls per request make the performance difference significant. My advice: don't optimize prematurely. Write your code with optional chaining where it enhances safety and clarity. For most applications, the safety benefits outweigh the performance costs. If profiling reveals a bottleneck, consider switching to noop functions. Profile first, optimize second. Remember: readable, maintainable code often surpasses micro-optimizations. But when those microseconds matter, now you understand the cost.

What is The Event Loop in JavaScript? Event loop is responsible for Managing the execution of Code, collecting and processing events, and execute queued tasks. Components of Event Loop: 1. Call Stack: it keep track the function call when the function invoked it is pushed onto the stack. When the function finished it is popped it off. 2. Web APIs: Provides Browser feature like setTimeout, DOM events, and HTTP requests. These are Asynchronous operations. 3. Task Queue (Callback Queue): Stores tasks waiting to be executed after the call stack is empty. These tasks are queued by setTimeout, setInterval or other APIs. 4. Microtask Queue: A higher-priority queue for promises and MutationObserver callbacks. Microtasks are executed before tasks in the task queue. 5. Event Loop: Continuously checks if the call stack is empty and pushes tasks from the microtask queue or task queue to the call stack for execution. Your Main Task: JavaScript executes code line by line in a single thread (like following a recipe). This is called the call stack. Waiting Tasks (Events): Some tasks take time (e.g., fetching data from the internet, timers). Instead of blocking progress, these tasks are sent to “wait in line” in a queue (known as the event queue). The Manager (Event Loop): The event loop constantly checks: Is the main task (call stack) empty? Are there any tasks waiting in the queue? If yes, it picks a task from the queue and moves it to the stack for execution.

How JavaScript Really Works: The Truth About Hoisting Most developers have heard of “hoisting” — the idea that variables and functions magically float to the top of their scope. Sounds simple. But dive into the ECMAScript specification, and you’ll find something surprising: there is no such thing as hoisting in the spec. Instead, JavaScript follows a well-defined three-phase execution model — and only certain declarations are truly “hoisted.” 🧠 The Three Phases of JavaScript Execution Static Semantics This phase analyzes code structure for validity. It runs only once before anything executes. EvaluateBody (Preparation phase) The engine sets up variables and function bindings based on declarations. This is where hoistable declarations come into play. Evaluation (Runtime execution) The actual running of code — now that everything is initialized. 🚫 Is “Hoisting” a Myth? The spec defines HoistableDeclaration, but it applies only to: function declarations, async function, generator function, async generator function. However, let, const, and class are not hoisted. Worse — they enter the temporal dead zone (TDZ), where accessing them before initialization throws a ReferenceError. 📌 Example (() => { "use strict"; console.log(hoistedFunc()); // OK // console.log(notHoisted); // ReferenceError function hoistedFunc() { return 'I am hoisted!'; } let notHoisted = 'I am NOT hoisted'; })(); 💡 Takeaway Hoisting isn’t magic. It’s the outcome of the EvaluateBody phase, where only certain declarations are pre-initialized. Understanding this deeper model helps avoid bugs — especially in strict mode.

🌟 Day 56 of JavaScript 🌟 🔹 Topic: Error Handling Best Practices 📌 1. Why Error Handling Matters? Errors are inevitable — but crashing apps aren’t. Good developers don’t avoid errors, they handle them gracefully ✨ Error handling ensures your app stays stable, predictable, and user-friendly even when something breaks. ⸻ 📌 2. Using try...catch try { const data = JSON.parse('{"name":"Pavan"}'); console.log(data.name); } catch (error) { console.error("Invalid JSON format!", error.message); } ✅ Safely runs code that might fail ✅ Prevents complete program crashes ⸻ 📌 3. Always Handle Async Errors async function fetchData() { try { const res = await fetch("https://lnkd.in/gXUzR2fM"); if (!res.ok) throw new Error("Network issue!"); const data = await res.json(); console.log(data); } catch (err) { console.error("Fetch failed:", err.message); } } 💡 Always check for .ok before using res.json(). ⸻ 📌 4. Custom Error Messages throw new Error("User not authorized!"); ✅ Be specific and meaningful ✅ Avoid generic messages like “Something went wrong” ⸻ 📌 5. Logging & Monitoring Use tools like: • 🪵 console.error() for dev logs • 🧠 Sentry, LogRocket, or Datadog for real-time production tracking ⸻ 📌 6. Don’t Hide Errors Avoid empty catch blocks 🚫 try { riskyFunction(); } catch (e) { // ❌ silently ignores problem } Always log or handle them properly. ⸻ 📌 7. Graceful UI Feedback When an error happens, show users a helpful message like: “Something went wrong. Please try again.” Not just a blank screen 🪦 ⸻ 💡 In short: Error handling isn’t just about fixing bugs — it’s about building resilience 🧱 A good developer makes sure their code fails smartly, not silently 💪 ⸻ #JavaScript #100DaysOfCode #ErrorHandling #TryCatch #FrontendDevelopment #WebDevelopment #CodingJourney #JavaScriptLearning #CleanCode #DevCommunity #CodeNewbie #WebDev #BestPractices

⚡️ 𝗪𝗿𝗶𝘁𝗲 𝗖𝗹𝗲𝗮𝗻𝗲𝗿 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗜𝗻𝘀𝘁𝗮𝗻𝘁𝗹𝘆 — 𝗠𝗮𝘀𝘁𝗲𝗿 𝗘𝗦𝗟𝗶𝗻𝘁 𝗶𝗻 𝗠𝗶𝗻𝘂𝘁𝗲𝘀! Maintaining clean, consistent, and bug-free JavaScript code is easier with 𝗘𝗦𝗟𝗶𝗻𝘁 — a powerful tool that analyzes your code for potential errors and enforces best practices. 💡 𝗪𝗵𝗮𝘁 𝗶𝘀 𝗘𝗦𝗟𝗶𝗻𝘁? 𝗘𝗦𝗟𝗶𝗻𝘁 is a static code analysis tool that scans your JavaScript (or TypeScript) code and highlights issues related to syntax, style, and potential runtime errors — before they even reach production. 🎯 𝗪𝗵𝘆 𝗨𝘀𝗲 𝗘𝗦𝗟𝗶𝗻𝘁? ✅ Consistency – Keeps your code style uniform across teams. ✅ Error Prevention – Detects bugs and syntax errors early. ✅ Best Practices – Enforces proven coding standards. ✅ Customizable – Lets you tweak rules as per your project’s needs. ⚙️ 𝗖𝗼𝗺𝗺𝗼𝗻 𝗘𝗦𝗟𝗶𝗻𝘁 𝗥𝘂𝗹𝗲𝘀 𝗨𝘀𝗲𝗱 𝗶𝗻 𝗥𝗲𝗮𝗹 𝗣𝗿𝗼𝗷𝗲𝗰𝘁𝘀 Here are some widely used in-built ESLint rules that help maintain code quality: {  "𝗿𝘂𝗹𝗲𝘀": {   "no-unused-vars": "𝘄𝗮𝗿𝗻",    // Warns if a variable is declared but never used   "eqeqeq": "𝗲𝗿𝗿𝗼𝗿",       // Enforces use of === and !== instead of == and !=   "curly": "𝗲𝗿𝗿𝗼𝗿",        // Requires curly braces for all control statements   "no-console": "𝘄𝗮𝗿𝗻",      // Warns about console.log statements in code   "semi": ["𝗲𝗿𝗿𝗼𝗿", "𝗮𝗹𝘄𝗮𝘆𝘀"],  // Requires semicolons at the end of statements   "quotes": ["𝗲𝗿𝗿𝗼𝗿", "𝗱𝗼𝘂𝗯𝗹𝗲"], // Enforces double quotes for strings   "indent": ["𝗲𝗿𝗿𝗼𝗿", 𝟮],     // Ensures consistent 2-space indentation   "no-debugger": "𝗲𝗿𝗿𝗼𝗿",     // Disallows use of debugger   "comma-dangle": ["𝗲𝗿𝗿𝗼𝗿", "𝗻𝗲𝘃𝗲𝗿"], // Prevents trailing commas in objects/arrays   "no-trailing-spaces": "𝗲𝗿𝗿𝗼𝗿"  // Prevents unnecessary spaces at the end of lines  } } 💬 What’s your go-to ESLint rule that helps keep your codebase clean? Drop it in the comments 👇 #javaScript #Frontend #CleanCode #ESLint #WebDevelopment #DevCommunity #developer #js #fresher #Coding #job