Manas Mishra’s Post

Understanding asynchronous JavaScript is essential for real-world applications. Practiced working with: • Creating custom Promises • Handling success & failure using then() and catch() • Using async/await for cleaner asynchronous code • Fetching API data with fetch() • Error handling with try...catch Mastering these concepts makes handling APIs and backend communication much more structured and readable. #JavaScript #AsyncAwait #Promises #WebDevelopment #FrontendDevelopment #APIs #CodingJourney #LearnInPublic #MERNStack #SoftwareEngineering #100DaysOfCode #TechLearning

🚀 30 Days — 30 Coding Mistakes Beginners Make Day 13/30 I copied an object… and the original data changed 😐 const newUser = user Then I updated newUser… and user also changed. Because objects in JavaScript are stored by reference, not value. Both variables pointed to the same memory. Fix 👇 const newUser = { ...user } Now a new object is created. This concept is very important in React state updates and debugging strange UI behavior. Day 14 tomorrow 👀 #30DaysOfCode #javascript #reactjs #frontend #webdevelopment #codeinuse

🚨 JavaScript Closures: A Tiny Detail, A Big Source of Bugs Sometimes JavaScript doesn’t fail because code is wrong. It fails because our mental model of scope is wrong. 🧠 Closures don’t capture values. They capture references. Because var is function-scoped, every callback shares the same binding. Result? Expected: 0, 1, 2 Actual: 3, 3, 3 No errors. No warnings. Just perfectly valid — yet misleading — behavior. ✅ Two reliable fixes • Explicit scope (closure pattern) • Block scope with let (preferred) 🎯 Why this still matters Closure-related issues quietly surface in: • Async logic • Event handlers • React hooks • Deferred execution • State management patterns These bugs rarely crash. They silently produce wrong behavior. 💡 Takeaway Closures aren’t an academic concept. They’re fundamental to writing predictable JavaScript. #JavaScript #FrontendDevelopment #WebDevelopment #SoftwareEngineering #CleanCode #ReactJS #Closures

🚀 Understanding Async/Await in JavaScript One of the most powerful features introduced in modern JavaScript (ES8) is async/await. It makes asynchronous code look and behave like synchronous code — cleaner, readable, and easier to debug. 🔹 The Problem (Before async/await) Handling asynchronous operations with callbacks or promises often led to messy code. 🔹 The Solution → async/await function fetchData() { return new Promise((resolve) => { setTimeout(() => { resolve("Data received"); }, 2000); }); } async function getData() { const result = await fetchData(); console.log(result); } getData(); 💡 What’s happening here? • async makes a function return a Promise • await pauses execution until the Promise resolves • The code looks synchronous but runs asynchronously 🔥 Why It Matters ✅ Cleaner code ✅ Better error handling with try/catch ✅ Avoids callback hell ✅ Easier to read and maintain If you're learning JavaScript, don’t just use async/await — understand how Promises work underneath. Strong fundamentals → Strong developer. #JavaScript #AsyncAwait #WebDevelopment #Frontend #Programming

JavaScript Execution Demystified: The 3 Phases That Make Your Code Run 🚀.............. Before a single line executes, JavaScript performs a carefully orchestrated three‑phase journey. Parsing Phase scans your code for syntax errors and builds an Abstract Syntax Tree (AST)—if there's a typo, execution never starts.  Creation Phase (memory allocation) hoists functions entirely, initializes var with undefined, and registers let/const in the Temporal Dead Zone (TDZ) while setting up scope chains and this. Finally, Execution Phase runs code line‑by‑line, assigns values, invokes functions, and hands off asynchronous tasks to the event loop. This three‑stage process repeats for every function call, with the call stack tracking execution and the event loop managing async operations. Master these phases to truly understand hoisting, closures, and why let throws errors before declaration! #javascript #webdev #coding #programming #executioncontext #parsing #hoisting #eventloop #js #frontend #backend #developer #tech #softwareengineering

V8 rewrote JSON.stringify from scratch. The result: more than 2x faster, and you didn't change a single line of code. The old implementation was recursive, scanned strings character-by-character, and reallocated its output buffer every time it ran out of space. The new one? Iterative traversal, SIMD hardware acceleration for string escaping, and a hidden class caching system that makes serialising arrays of same-shape objects absurdly fast. The wildest part: writing clean, consistent object shapes (same keys, same order) literally unlocks a fast path at the engine level. Good code practices = free performance. Which of these 6 optimisations surprised you the most? Deep dive into JavaScript fundamentals from closures to the event loop with questions written by ex-FAANG interviewers: 👇 https://lnkd.in/d5UWncbS #JavaScript #V8 #Performance #WebDevelopment #FrontEndDevelopment #GreatFrontEnd #NodeJS

After working with JavaScript arrays for a while, I’ve realised something simple —clean code > complex logic. Two small but powerful tools I use often: 1) reduce() When you want to turn an entire array into a single result, reduce() is a game changer. Instead of writing loops and extra variables, you can accumulate values in one clean line. It’s not just for sums. You can use it for counting, grouping, transforming data — almost anything that needs accumulation logic. 2) Set() Handling duplicate values? No need for complex checks. Simple. Readable. Efficient. What I like most about these methods is this: They make code expressive. Still learning. Still building. 🚀 #JavaScript #WebDevelopment #Frontend #MERNStack

JAVASCRIPT NOTES — PART 5 Some JavaScript bugs aren’t about logic — they’re about understanding how the language behaves internally. This post covers: • Stack vs Heap (how memory is handled) • Shallow vs Deep copy • The real behavior of the `this` keyword • Garbage collection basics • Debouncing & Throttling for UI performance These are the concepts that explain why code behaves the way it does. Once memory and execution flow are clear, JavaScript becomes far more predictable. #JavaScript #WebDevelopment #FrontendDeveloper #InterviewPrep #LearningInPublic #Debouncing #Prototypes #Consistency

Average developer: I know this is confusing. Advanced developer: I know exactly what this will be before the code runs. Because they evaluate: • Is it a method call? • Is it strict mode? • Is it an arrow function? • Is it bound explicitly? • Is it called with new? this is not confusing. It’s just contextual. And once you master context, you master JavaScript. It’s one of the biggest mindset shifts in the language. #JavaScript #ThisKeyword #JSInternals #FrontendEngineer #ProgrammingFundamentals #DeveloperGrowth #SoftwareDesign

If you're writing JavaScript in 2025 without TypeScript, you're debugging in hard mode. ━━━━━━━━━━━━━━━━ JS → error shows up at RUNTIME         (your users see it) 😨 TS → error shows up while TYPING         (only you see it) ✅ ━━━━━━━━━━━━━━━━ Same language. Just smarter. You don't rewrite your code. You just add types, and your editor starts catching mistakes for you. Free bug detection. Why would you say no? 🤷 #TypeScript #JavaScript #WebDev #LearnToCode