Avoiding Race Conditions with Async/Await in JavaScript

𝟵𝟵% 𝗼𝗳 𝗝𝗦 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀 𝘄𝗿𝗶𝘁𝗲 𝗮𝘀𝘆𝗻𝗰 𝗰𝗼𝗱𝗲 𝗱𝗮𝗶𝗹𝘆. 𝗕𝘂𝘁 𝗺𝗼𝘀𝘁 𝗰𝗮𝗻'𝘁 𝗲𝘅𝗽𝗹𝗮𝗶𝗻 𝘄𝗵𝘆 𝗶𝘁 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝘄𝗼𝗿𝗸𝘀. 👇 I didn't either until I learned about the JavaScript Runtime Environment. Here's the mental model that changed everything for me: JavaScript by itself is just a language. Runtime = Engine + APIs + Event Loop 🔥 What's actually running under the hood: ⚙️ JS Engine (V8) → converts code to machine code 📞 Call Stack → runs functions one by one 🌐 Web APIs → setTimeout, DOM, fetch (NOT part of JS itself!) 📬 Callback Queue → stores async callbacks ⚡ Microtask Queue → Promises, higher priority 🔄 Event Loop → the brain connecting everything The flow: Code → Call Stack → Web APIs → Queue → Event Loop → Call Stack Right now, try this 👇 console.log("Start"); setTimeout(() => console.log("Async"), 0); console.log("End"); Output → Start, End, Async 🤯 Even with 0 ms delay, "Async" prints LAST. That's the Event Loop doing its job. 🧠 Interview tip: Q: Why can JS handle async if it's single-threaded? A: The Runtime provides Web APIs + Event Loop + Queues — not the language. If this helped, repost ♻️ to help another developer. Follow Amit Prasad for daily updates on JavaScript and DSA 🔔 💬 Comment: Did you know that setTimeout 0ms still runs last? #JavaScript #WebDevelopment #Frontend #NodeJS #100DaysOfCode #DSA #Developer #CodingLife #TechLearning

⚡ Mastering Async/Await in Node.js – Write Cleaner, Smarter CodeTired of callback hell? 😵 Nested .then() chains confusing your logic?👉 Async/Await is the game-changer you need.🧠 What is Async/Await? It’s a modern way to handle asynchronous operations in JavaScript, built on top of Promises.async → makes a function return a Promiseawait → pauses execution until the Promise resolves🔧 Before (Promises):getUser() .then(user => getOrders(user.id)) .then(orders => console.log(orders)) .catch(err => console.error(err));✨ After (Async/Await):async function fetchOrders() { try { const user = await getUser(); const orders = await getOrders(user.id); console.log(orders); } catch (err) { console.error(err); } }💡 Why Developers Love It:Cleaner & more readable code 🧹Easier error handling with try/catchLooks like synchronous code, but runs async ⚡Reduces bugs in complex workflows🚀 Pro Tips:Use Promise.all() for parallel executionAvoid blocking loops with await inside for (use wisely)Always handle errors ❗🔥 Real-World Use Cases:API calls 🌐Database queries 🗄️File handling 📂Background jobs ⏳💬 One Line Summary: Async/Await turns messy async code into clean, readable logic.#NodeJS #JavaScript #AsyncAwait #CleanCode #WebDevelopment #BackendDevelopment

Day 5 ⚡ Async/Await in JavaScript — The Clean Way to Handle Async Code If you’ve struggled with .then() chains, async/await is your best friend 🚀 --- 🧠 What is async? 👉 Makes a function always return a Promise async function greet(){ return "Hello"; } greet().then(console.log); // Hello --- ⏳ What is await? 👉 Pauses execution until a Promise resolves function delay(){ return new Promise(res => setTimeout(() => res("Done"), 1000)); } async function run(){ const result = await delay(); console.log(result); } --- ⚡ Why use async/await? ✔ Cleaner than .then() chaining ✔ Looks like synchronous code ✔ Easier error handling --- ❌ Sequential vs ⚡ Parallel // ❌ Sequential (slow) const a = await fetchUser(); const b = await fetchPosts(); // ⚡ Parallel (fast) const [a, b] = await Promise.all([ fetchUser(), fetchPosts() ]); --- ⚠️ Error Handling try { const data = await fetchData(); } catch (err) { console.log("Error handled"); } --- 💡 One-line takeaway 👉 async/await = cleaner + readable way to handle Promises #JavaScript #AsyncAwait #WebDevelopment #Frontend #Coding #100DaysOfCode

𝗟𝗲𝘁’𝘀 𝘁𝗮𝗹𝗸 𝗮 𝗹𝗶𝘁𝘁𝗹𝗲 𝗯𝗶𝘁 𝗮𝗯𝗼𝘂𝘁 𝗡𝗼𝗱𝗲.𝗷𝘀! 𝐓𝐨𝐩𝐢𝐜 𝟏: 𝐓𝐡𝐞 𝐍𝐨𝐝𝐞.𝐣𝐬 𝐄𝐯𝐞𝐧𝐭 𝐋𝐨𝐨𝐩 It’s a meticulously ordered cycle of 6 steps - and most developers have never seen the part that goes between each one. ⚙️ 𝘛𝘩𝘦 6 𝘚𝘵𝘦𝘱𝘴: 1️⃣ 𝘛𝘪𝘮𝘦𝘳𝘴: Recalls setTimeout / setInterval whose delay has passed 2️⃣ 𝘈𝘸𝘢𝘪𝘵𝘪𝘯𝘨 callbacks: Recalls I/O errors that were rejected from the previous iteration 3️⃣ 𝘗𝘰𝘭𝘭𝘪𝘯𝘨: Retrieves new I/O events. This is where Node.js waits when idle. 4️⃣ 𝘊𝘩𝘦𝘤𝘬: setImmediate callbacks, always after Poll 5️⃣ 𝘊𝘭𝘰𝘴𝘦 𝘊𝘢𝘭𝘭𝘣𝘢𝘤𝘬𝘴: socket.on('close'), cleanup handlers 💠The hidden layer: microtasks Between each step, before the loop progresses, Node.js completely empties the microtask queue. Two subqueues, processed in exact order: ➡️ process.nextTick() callbacks - always first ➡️ Promise resolution callbacks - second This means that microtasks have a higher priority than any step of the Event Loop. 📌 𝘛𝘩𝘦 𝘳𝘶𝘭𝘦𝘴 𝘰𝘧 𝘵𝘩𝘶𝘮𝘣: ➡️ process.nextTick() is fired before Promises, even if Promise resolved first. ➡️ setImmediate() is always fired after I/O callbacks in the same iteration. ➡️ The order of setTimeout(fn, 0) and setImmediate() is not deterministic outside of I/O callbacks. ➡️ Never use nextTick() recursively in production code. The event loop is why Node.js can handle thousands of simultaneous connections on a single thread. Controlling its execution order is the difference between writing asynchronous code and understanding it. #nodejs #javascript #backend #eventloop #softwareengineering #webdevelopment

For years, sorting an array in JavaScript has been a source of subtle bugs. The `.sort()` method, while functional, mutates the original array in place. This often leads developers to create a copy first, usually with the spread operator `[...]`, before sorting. This "copy-then-sort" pattern is verbose and easily forgotten, especially in complex applications where arrays are passed around. If you forget the copy, you inadvertently modify data in other parts of your program, leading to hard-to-trace bugs and unexpected side effects that can really tank your productivity. Enter `Array.toSorted()`. This modern, immutable alternative returns a new sorted array without touching the original. It's cleaner, safer, and exactly what developers have needed for handling data integrity. It prevents accidental data corruption and makes your code much more predictable. Are you still writing it the old way? #javascript #webdevelopment #frontend #cleancode #js

🚀 𝗗𝗮𝘆 𝟭: 𝗧𝘆𝗽𝗲𝗦𝗰𝗿𝗶𝗽𝘁 𝗙𝘂𝗻𝗱𝗮𝗺𝗲𝗻𝘁𝗮𝗹𝘀 👉 Build a Strong Base TypeScript isn’t just “JavaScript with types”. It’s about writing code that is: ✔ Predictable ✔ Maintainable ✔ Bug-resistant 🔹 What problem does TypeScript solve? JavaScript → Dynamic → Errors at runtime ❌ TypeScript → Static → Errors during development ✅ 👉 Catch issues before your app runs. 🔹 Core Types You Must Know • string, number, boolean → basics • any → disables safety (avoid) • unknown → safe alternative • void → no return • never → never completes 🔹 Functions with Type Safety function add(a: number, b: number): number { return a + b; } 👉 Prevents invalid usage like passing strings. 🔹 Interfaces vs Types interface User { id: number; name: string; } type Status = "active" | "inactive"; ✔ Interface → object structure ✔ Type → unions & flexibility 🔹 Union Types (Real-world) type ApiStatus = "loading" | "success" | "error"; 👉 Perfect for handling UI states cleanly. 🔹 Strict Mode (Must Enable) "strict": true ✔ Prevents null errors ✔ Enforces better coding discipline 💡 Final Thought You can skip fundamentals… But your code won’t scale without them. ⏭️ Tomorrow: Generics, Utility Types & Real Power of TypeScript 🔥 #TypeScript #Frontend #Angular #CleanCode #SoftwareEngineering

JavaScript is easy. Until it isn't. 😅 Every developer has been there. You're confident. Your code looks clean. You hit run. And then: " Cannot read properties of undefined (reading 'map') " The classic JavaScript wall. Here are 7 JavaScript mistakes I see developers make constantly and how to fix them: 1. Not understanding async/await ⚡ → Wrong: | const data = fetch('https://lnkd.in/dMDBzbsK'); console.log(data); // Promise {pending} | → Right: | const data = await fetch('https://lnkd.in/dMDBzbsK'); | 2. Using var instead of let/const → var is function scoped and causes weird bugs → Always use const by default. let when you need to reassign. Never var. 3. == instead of === → 0 == "0" is true in JavaScript 😱 → Always use === for comparisons. Always. 4. Mutating state directly in React → Wrong: user.name = "Shoaib" → Right: setUser({...user, name: "Shoaib"}) 5. Forgetting to handle errors in async functions → Always wrap await calls in try/catch → Silent failures are the hardest bugs to track down 6. Not cleaning up useEffect in React → Memory leaks are real → Always return a cleanup function when subscribing to events 7. Treating arrays and objects as primitives → [] === [] is false in JavaScript → Reference types don't compare like numbers — learn this early JavaScript rewards the developers who understand its quirks. 💡 Which of these caught YOU off guard when you first learned it? 👇 #JavaScript #WebDevelopment #Frontend #FullStackDeveloper #React #Programming #CodingTips #Developer #Tech #Pakistan #LearnToCode #JS #SoftwareEngineering #100DaysOfCode #PakistaniDeveloper

𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 𝗺𝗼𝗱𝘂𝗹𝗲 𝗳𝗼𝗿𝗺𝗮𝘁𝘀 𝗰𝗮𝗻 𝗯𝗲 𝗰𝗼𝗻𝗳𝘂𝘀𝗶𝗻𝗴 — 𝗲𝘀𝗽𝗲𝗰𝗶𝗮𝗹𝗹𝘆 𝘄𝗵𝗲𝗻 𝘆𝗼𝘂 𝗿𝘂𝗻 𝗶𝗻𝘁𝗼 𝗱𝗶𝗳𝗳𝗲𝗿𝗲𝗻𝘁 𝗼𝗻𝗲𝘀 𝗮𝗰𝗿𝗼𝘀𝘀 𝗽𝗿𝗼𝗷𝗲𝗰𝘁𝘀. Here’s a quick mental model 👇 𝗖𝗼𝗺𝗺𝗼𝗻𝗝𝗦 Used in classic Node.js backends const lib = require('lib'); Simple and synchronous. Still widely used, but gradually being replaced. 𝗘𝗦 𝗠𝗼𝗱𝘂𝗹𝗲𝘀 (𝗘𝗦𝟮𝟬𝟭𝟱+) Modern standard for browsers and Node.js import lib from 'lib'; Tree-shakable, static, and the future of JavaScript. 𝗔𝗠𝗗 Designed for browsers before native modules existed (RequireJS era) define(['dep'], function(dep) { ... }); Now mostly legacy. SystemJS Dynamic module loader System.register([...], function(...) { ... }); Used in specific cases like plugin systems or legacy apps. 𝗨𝗠𝗗 "Write once, run anywhere" format Works in both browser and Node.js if (typeof define === 'function') { ... } Common in older libraries that needed maximum compatibility. 💡 Key takeaway: Use 𝗘𝗦 𝗠𝗼𝗱𝘂𝗹𝗲𝘀 for modern apps Expect 𝗖𝗼𝗺𝗺𝗼𝗻𝗝𝗦 in backend or legacy code Treat 𝗔𝗠𝗗 / 𝗦𝘆𝘀𝘁𝗲𝗺𝗝𝗦 / 𝗨𝗠𝗗 as historical or niche Understanding these formats makes debugging build issues much easier. #JavaScript #Frontend #WebDevelopment #NodeJS #SoftwareEngineering #DevTips #Programming

🤔 Wait… shouldn’t variables be deleted? How is it possible that a function still remembers a variable…even after the function where it was created has already finished executing? 😳 👉 Sounds impossible, right? 🚀 JavaScript’s one of the most powerful concepts: Closures 🧠 What is a Closure? A closure is created when a function is defined inside another function, and the inner function can access variables from its parent scope — even after the parent function has finished execution. ⚡Shouldn’t variables be deleted? Normally, yes ✅ 👉 Once a function finishes, its local variables are removed from memory (thanks to garbage collection) But closures change the game 👇 👉 If an inner function is still using those variables, JavaScript keeps them alive in memory 🔍 What’s really happening? The inner function “closes over” its parent’s variables 💡 That’s why it’s called a closure Even though the outer function is done… the inner function still has access to its scope 😮 🔐 Why Closures Matter (Real Use Cases) Closures aren’t just theory — they’re used everywhere: 👉 Encapsulation (Private Variables) Keep data hidden from global scope 👉 Debouncing & Throttling Control function execution (very common in React apps) 👉 State management patterns Maintain data across function calls 💡 Real Developer Insight Closures are powerful… but can be tricky 👉They can also hold memory longer than expected 👉 Misuse can lead to memory leaks 🚀 Final Thought: Most developers use closures unknowingly… But great developers understand how and why they work. #JavaScript #FrontendDevelopment #WebDevelopment #Closures #CodingTips #LearnJavaScript #BuildInPublic #100DaysOfCode #LearnInPublic

𝐃𝐚𝐲 1/30 – 𝐍𝐨𝐝𝐞.𝐣𝐬 𝐒𝐞𝐫𝐢𝐞𝐬: 𝐖𝐡𝐚𝐭 𝐍𝐨𝐝𝐞.𝐣𝐬 𝐫𝐞𝐚𝐥𝐥𝐲 𝐢𝐬 (𝐛𝐞𝐲𝐨𝐧𝐝 𝐭𝐡𝐞 𝐝𝐞𝐟𝐢𝐧𝐢𝐭𝐢𝐨𝐧) Most people say: 👉 “Node.js is a JavaScript runtime built on Chrome’s V8 engine.” That’s correct… but honestly, it’s not useful in real-world discussions. Let’s understand it like an engineer 💡 𝐍𝐨𝐝𝐞.𝐣𝐬 𝐢𝐬 𝐍𝐎𝐓 𝐣𝐮𝐬𝐭 𝐚 𝐫𝐮𝐧𝐭𝐢𝐦𝐞 — 𝐢𝐭’𝐬 𝐚𝐧 𝐞𝐯𝐞𝐧𝐭-𝐝𝐫𝐢𝐯𝐞𝐧, 𝐧𝐨𝐧-𝐛𝐥𝐨𝐜𝐤𝐢𝐧𝐠 𝐬𝐲𝐬𝐭𝐞𝐦 𝐝𝐞𝐬𝐢𝐠𝐧𝐞𝐝 𝐟𝐨𝐫 𝐡𝐚𝐧𝐝𝐥𝐢𝐧𝐠 𝐜𝐨𝐧𝐜𝐮𝐫𝐫𝐞𝐧𝐭 𝐨𝐩𝐞𝐫𝐚𝐭𝐢𝐨𝐧𝐬 𝐞𝐟𝐟𝐢𝐜𝐢𝐞𝐧𝐭𝐥𝐲. What does that mean? 1. It uses a 𝐬𝐢𝐧𝐠𝐥𝐞-𝐭𝐡𝐫𝐞𝐚𝐝𝐞𝐝 𝐞𝐯𝐞𝐧𝐭 𝐥𝐨𝐨𝐩 2. It delegates heavy tasks (I/O, network, file operations) to the system 3. It doesn’t wait… it keeps moving 🔁 𝐑𝐞𝐚𝐥-𝐰𝐨𝐫𝐥𝐝 𝐞𝐱𝐚𝐦𝐩𝐥𝐞: Imagine your backend API is: 1. Reading files 2. Calling external APIs 3. Querying databases In traditional blocking systems: ➡ One request waits for another In Node.js: ➡ Multiple requests are handled 𝐰𝐢𝐭𝐡𝐨𝐮𝐭 𝐰𝐚𝐢𝐭𝐢𝐧𝐠 🧠 𝐒𝐢𝐦𝐩𝐥𝐞 𝐚𝐧𝐚𝐥𝐨𝐠𝐲: Node.js is like a smart manager: Assigns tasks to workers Doesn’t sit idle Keeps taking new tasks ⚠️ 𝐁𝐮𝐭 𝐡𝐞𝐫𝐞’𝐬 𝐭𝐡𝐞 𝐭𝐫𝐮𝐭𝐡 𝐦𝐨𝐬𝐭 𝐭𝐮𝐭𝐨𝐫𝐢𝐚𝐥𝐬 𝐬𝐤𝐢𝐩: Node.js is NOT always the best choice. ❌ CPU-heavy tasks (like image processing, large calculations) can block the event loop ❌ Poor async handling can still cause performance issues 🔥 𝐅𝐫𝐨𝐦 𝐦𝐲 𝐞𝐱𝐩𝐞𝐫𝐢𝐞𝐧𝐜𝐞: In one of my projects, instead of processing everything synchronously, we used 𝐪𝐮𝐞𝐮𝐞-𝐛𝐚𝐬𝐞𝐝 𝐚𝐬𝐲𝐧𝐜 𝐩𝐫𝐨𝐜𝐞𝐬𝐬𝐢𝐧𝐠 (similar to Service Bus pattern). This helped us: ✔ Avoid API timeouts ✔ Handle large workloads ✔ Improve system scalability ✅ 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲: Node.js shines when: ✔ You have I/O-heavy applications ✔ You need high concurrency ✔ You design it with async patterns correctly 📌 Tomorrow (Day 2): 𝐃𝐞𝐞𝐩 𝐝𝐢𝐯𝐞 𝐢𝐧𝐭𝐨 𝐄𝐯𝐞𝐧𝐭 𝐋𝐨𝐨𝐩 (𝐭𝐡𝐞 𝐡𝐞𝐚𝐫𝐭 𝐨𝐟 𝐍𝐨𝐝𝐞.𝐣𝐬) #NodeJS #BackendDevelopment #JavaScript #FullStack #SoftwareEngineering #SystemDesign