async/await explained: Promises + Event Loop

𝟵𝟵% 𝗼𝗳 𝗝𝗦 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀 𝘄𝗿𝗶𝘁𝗲 𝗮𝘀𝘆𝗻𝗰 𝗰𝗼𝗱𝗲 𝗱𝗮𝗶𝗹𝘆. 𝗕𝘂𝘁 𝗺𝗼𝘀𝘁 𝗰𝗮𝗻'𝘁 𝗲𝘅𝗽𝗹𝗮𝗶𝗻 𝘄𝗵𝘆 𝗶𝘁 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝘄𝗼𝗿𝗸𝘀. 👇 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

🚀 Async/Await in JavaScript — Write Asynchronous Code Like Synchronous! If Promises made async code cleaner, async/await made it beautiful. Let’s break it down 👇 🔹 What is async/await? • async makes a function return a Promise • await pauses execution until the Promise resolves 👉 It helps you write async code that looks and behaves like synchronous code. 🔹 Basic Example function fetchData() { return new Promise((resolve) => { setTimeout(() => resolve("Data received"), 2000); }); } async function getData() { const data = await fetchData(); console.log(data); } getData(); 🧠 Instead of chaining .then(), you write it step-by-step. 🔹 Error Handling Made Easy async function getData() { try { const data = await fetchData(); console.log(data); } catch (error) { console.error("Error:", error); } } ✅ No more messy .catch() chains ✅ Clean and readable error handling 🔹 Sequential vs Parallel Execution 👉 Sequential (waits one after another) await task1(); await task2(); 👉 Parallel (runs together) const [res1, res2] = await Promise.all([task1(), task2()]); ⚡ Use parallel execution for better performance when tasks are independent. 🔹 Common Mistakes to Avoid ❌ Using await outside async function ❌ Blocking loops with await unnecessarily ❌ Forgetting error handling 💡 Pro Tip: Async/await is just syntactic sugar over Promises — understanding Promises deeply makes async/await even more powerful. 🔥 Interview Question: What will be the output? async function test() { console.log("Start"); await Promise.resolve(); console.log("End"); } test(); console.log("Outside"); 👉 Comment your answer 👇 #JavaScript #AsyncAwait #WebDevelopment #Frontend #Coding #InterviewPrep

Most bugs in production don’t come from complex systems... 💻 They come from simple misunderstandings. Here’s one that even experienced developers occasionally get wrong 👇 🧠 Three snippets. Same intention. Different behavior. // 1 function logValue(value) { if (value === 2) return; console.log(value) } for (let i = 1; i < 5; i++) { logValue(i) } // 2 for (let i = 1; i < 5; i++) { if (i === 2) return; console.log(i) } // 3 [1,2,3,4].forEach((num) => { if (num === 2) return console.log(num) }) 🔍 What’s actually happening? Snippet 1 → Safe abstraction return exits only the function Loop continues Output: 1, 3, 4 Snippet 2 → Dangerous assumption return exits the entire enclosing function Loop stops completely at 2 Output: 1 👉 If this is inside a React component or handler → you just aborted execution. Snippet 3 → Misleading familiarity return exits only the callback, not the loop forEach keeps iterating Output: 1, 3, 4 💡 Takeaway Control flow is not about syntax - it's about execution boundaries. Ask yourself: “What exactly am I returning from?” Function? Loop? Callback? Component? Because JavaScript won’t warn you. It will just… behave correctly in a way you didn’t expect. 🧩 Rule of thumb return in functions → exits function return in forEach → skips current iteration return in loops (top-level) → exits enclosing function (not just loop) The code looks similar. The runtime behavior is not. And that difference is where real-world bugs live. #javascript #reactjs #webdevelopment #softwareengineering #frontend #cleanCode

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

🚀 **𝐃𝐚𝐲 5 – 𝐇𝐨𝐢𝐬𝐭𝐢𝐧𝐠 𝐢𝐧 𝐉𝐚𝐯𝐚𝐒𝐜𝐫𝐢𝐩𝐭 (𝐂𝐥𝐞𝐚𝐫 & 𝐏𝐫𝐚𝐜𝐭𝐢𝐜𝐚𝐥 𝐄𝐱𝐩𝐥𝐚𝐧𝐚𝐭𝐢𝐨𝐧)** You might have seen this 👇 👉 Using a variable before declaring it But why does this work? 🤔 --- 💡 **What is Hoisting?** Hoisting means: 👉 Before execution, JavaScript **allocates memory for variables and functions** 👉 In simple words: **Declarations are processed before code runs** --- 💡 **Example:** ```js id="d5pro1" console.log(a); var a = 10; ``` 👉 Output: `undefined` --- 💡 **What actually happens behind the scenes?** Before execution (Memory Phase): * `a` → undefined Then execution starts: * `console.log(a)` → prints undefined * `a = 10` --- 💡 **Important Rule** 👉 JavaScript only hoists **declarations**, not values --- 💡 **var vs let vs const** 👉 **var** * Hoisted * initialized as `undefined` * can be accessed before declaration 👉 **let & const** * Hoisted * BUT not initialized --- ⚠️ **Temporal Dead Zone (TDZ)** This is the time between: 👉 variable declared 👉 and initialized During this: ❌ Accessing variable → **ReferenceError** --- 💡 **Example:** ```js id="d5pro2" console.log(a); let a = 10; ``` 👉 Output: **ReferenceError** --- ⚡ **Key Insight (Very Important)** 👉 Hoisting is NOT moving code 👉 It’s just **memory allocation before execution** --- 💡 **Why this matters?** Because it helps you understand: * unexpected `undefined` values * ReferenceErrors * how JavaScript actually runs code --- 👨💻 Continuing my JavaScript fundamentals series 👉 Next: **JavaScript Runtime & Event Loop** 👀 #JavaScript #WebDevelopment #FrontendDevelopment #Coding #SoftwareEngineer #Tech

JavaScript isn’t asynchronous… the environment is. After diving deep into asynchronous JavaScript, I realized something that completely changed how I think about writing code: We don’t “wait” for data… we design what happens when it arrives. 💡 Most developers use fetch and Promises daily, but very few truly understand what happens under the hood. Here’s the real mental model: 🔹 JavaScript is single-threaded 🔹 Heavy operations (API calls, timers) are offloaded to Web APIs 🔹 fetch() returns a Promise immediately (not the data!) 🔹 .then() doesn’t execute your function… it registers it for later 🔥 The game changer? There are actually two queues, not one: Microtask Queue (Promises) → HIGH PRIORITY Callback Queue (setTimeout, etc.) And the Event Loop always prioritizes microtasks. 💥 Example: console.log("1"); setTimeout(() => console.log("2"), 0); Promise.resolve().then(() => console.log("3")); console.log("4"); 👉 Output: 1 . 4 . 3 . 2 🧠 Why this matters: Explains unexpected execution order Makes debugging async code 10x easier Helps avoid common interview pitfalls Builds a strong foundation for React & modern frontend ⚡ Key Insight: Promises are not about cleaner syntax… They are about controlling time and execution order in a non-blocking environment. 📌 Once you truly understand: Event Loop Microtask vs Callback Queue Promise lifecycle You stop guessing… and start predicting behavior. #JavaScript #Frontend #WebDevelopment #AsyncJS #Promises #EventLoop #React #Programming

Small JavaScript bugs keep escaping to production and breaking critical user flows. Debugging inconsistent runtime behavior steals time from feature delivery. ────────────────────────────── Unlocking JavaScript with Proxy and Reflect API Explore the powerful Proxy and Reflect APIs in JavaScript that can elevate your coding skills. #javascript #proxy #reflect #webdevelopment ────────────────────────────── Core Concept Have you ever wished you could intercept and customize operations on objects in JavaScript? The Proxy and Reflect APIs allow you to do just that, making your code more flexible and powerful. Key Rules • Use Proxy to define custom behavior for fundamental operations (e.g., property lookup, assignment). • Reflect provides methods for interceptable JavaScript operations, acting as a companion to Proxy. • Remember to keep your use cases clear; these tools can add complexity if not applied thoughtfully. 💡 Try This const target = {}; const handler = { get: (obj, prop) => prop in obj ? obj[prop] : 'Property not found!' }; const proxy = new Proxy(target, handler); console.log(proxy.someProperty); ❓ Quick Quiz Q: What does the Proxy API allow you to do? A: Intercept and customize operations on objects. 🔑 Key Takeaway Embrace Proxy and Reflect to enhance your JavaScript code's functionality and behavior!

🚀 JavaScript Promise Static Methods — (Part: 2) 🔹 What are Promise Static Methods? These are built-in methods available on the Promise object , used to handle multiple promises efficiently. 🔹 1. Promise.all() — “All or Nothing” 👉 Runs multiple promises in parallel and waits for all to succeed Promise.all([p1, p2, p3]) .then(results => console.log(results)) .catch(error => console.log(error)); >> Returns all results in an array >> Fails immediately if any one promise fails Use Case: When all results are required 👉 Example: Fetching user data + posts + comments together 🔹 2. Promise.allSettled() — “I Want Everything” 👉 Waits for all promises (success + failure) Promise.allSettled([p1, p2, p3]) .then(results => console.log(results)); >> Returns status of each promise >> Never fails Use Case: When you want all results, even failed ones 👉 Example: Showing multiple API results with partial failures 🔹 3. Promise.race() — “Fastest Wins” 👉 Returns the first promise that completes (success or failure) Promise.race([p1, p2, p3]) .then(result => console.log(result)) .catch(err => console.log(err)); 👉 Example: API call vs timeout promise 🔹 4. Promise.any() — “First Success Wins” 👉 Returns the first successful promise Promise.any([p1, p2, p3]) .then(result => console.log(result)) .catch(err => console.log(err)); >> Ignores failed promises >> Fails only if all promises fail Use Case: Multiple APIs, take fastest successful response 🔹 Key Takeaways ✔️ These methods help manage multiple async operations ✔️ Improve performance with parallel execution ✔️ Avoid complex callback structures ✔️ Widely used in real-world applications #JavaScript #Promises #AsyncProgramming #WebDevelopment #Frontend #Coding #Developers #Tech #Learning

Only 2% of developers use Full-stack TypeScript with tRPC for true end-to-end type safety. Have you ever wondered why, despite the evolution in tooling and frameworks, bugs still crawl into your codebase after every release? As a developer who's spent countless late nights debugging mysteriously broken interfaces, I’ve turned to Full-stack TypeScript with tRPC for a solution. Type safety isn't just a buzzword; it translates to real-world stability and confidence in code. TypeScript ensures your data contracts remain intact across your entire stack. But here's the kicker: tRPC elevates this synergy to a level where type errors become almost a non-issue. By generating API types directly from your server-side logic, every part of your application - backend to frontend - remains synchronized automatically. Imagine making a server-side change and your editor flagging exactly where you need to adjust your client logic. It's not just time-saving; it's transformative. I remember using vibe coding to quickly prototype features, and it was liberating to see real-time type validations catch potential runtime errors before they became problems. Here's a quick example of how simple it is to define a type-safe API with tRPC: ```typescript import { initTRPC } from '@trpc/server'; const t = initTRPC.create(); export const appRouter = t.router({ greeting: t.procedure .input((val: string) => val.trim()) .query(({ input }) => `Hello ${input}`), }); export type AppRouter = typeof appRouter; ``` This isn't just about using TypeScript; it's about leveraging its full potential to enhance our development workflow. What are your thoughts on adopting full-stack type safety? Are you already using something like tRPC, or is there another framework you find indispensable? Let’s dive into the discussion! #WebDevelopment #TypeScript #Frontend #JavaScript