Understanding JavaScript Promises with Namaste JavaScript

This week, I revisited a foundational JavaScript concept that deserves more respect: asynchronicity and Promises. I firmly believe that strong engineering stems from a deep understanding of the small details, particularly in areas that are easy to use but can be easily misunderstood. To clarify this concept, I wrote a structured learning note that explains the following: - How JavaScript continues to operate while certain tasks complete at their own pace. - The true representation of a Promise. - How we can confidently handle results and failures. This exploration reinforces the importance of mastering the intricacies of asynchronicity in JavaScript.

Day 47/100 – Understanding JavaScript Scope (Global vs Local) 🧠 Today I spent time understanding one of the most important JavaScript concepts: scope. Scope defines where a variable can be accessed in your code. At first, this topic felt confusing. But once I slowed down and practiced, it started to make sense. There are mainly two types of scope I focused on: 🔹 Global Scope Variables declared outside any function. They can be accessed anywhere in the program. 🔹 Local (Function) Scope Variables declared inside a function. They can only be used inside that function. Why this matters so much: ✔️ Helps avoid unexpected errors ✔️ Prevents variable name conflicts ✔️ Makes code more predictable ✔️ Improves readability and maintenance One big lesson: Just because code works doesn’t mean it’s written well. Good code is: Readable. Predictable. Easy to understand. I’m learning that becoming a better developer isn’t about memorizing syntax. It’s about understanding how things work behind the scenes. Still learning. Still practicing. Still showing up. Day 47 complete ✅ On to Day 48 🚀 #100DaysOfCode #JavaScript #LearningInPublic #WebDevelopment #FrontendDevelopment #CodingJourney #Consistency

𝐉𝐚𝐯𝐚𝐒𝐜𝐫𝐢𝐩𝐭 𝐯𝐬 𝐓𝐲𝐩𝐞𝐒𝐜𝐫𝐢𝐩𝐭 🤔 JavaScript is fast, flexible, and easy to start with. You can build things quickly, and it runs pretty much everywhere ⚡ But as projects grow, I’ve noticed how runtime errors can slow things down and make debugging stressful 😅 That’s where TypeScript really stands out. Adding static typing, catching errors at compile time, and getting better tooling just makes development feel more controlled and scalable 🛡️ For me: 👉 JavaScript gives speed 👉 TypeScript gives safety and scalability Both have their place — it’s all about choosing the right tool for the right stage of the project. Still learning. Still improving. 🚀 #JavaScript #TypeScript #WebDevelopment #DeveloperJourney #LearningInPublic #Upskilling #TechJourney

Learning JavaScript often feels slow. You read about closures. You revisit this. You debug the same async bug again. It feels like nothing is moving. Then one day, you read code and understand it. Not because you memorized it — but because your brain finally built the connections. That delay isn’t wasted time. It’s the cost of depth. Most developers quit when things stop feeling fast. The ones who stay… compound. If JavaScript feels slow right now, keep going. 👉 What JavaScript concept took you the longest to understand? #JavaScript #WebDevelopment #SoftwareEngineering #LearningToCode #DeveloperJourney #GrowthMindset #DeepWork #CareerGrowth

🚀 JavaScript Basics – var vs let vs const While revising core concepts, I refreshed my understanding of variable declarations in JavaScript. Here’s a quick breakdown: 🔹 var • Function scoped • Can be redeclared • Can be updated 🔹 let • Block scoped • Cannot be redeclared in the same scope • Can be updated 🔹 const • Block scoped • Cannot be redeclared • Cannot be reassigned 💡 Best Practice: Use const by default. Use let when the value needs to change. Avoid using var in modern JavaScript. Strong fundamentals = Strong development skills. #javascript #webdevelopment #frontenddeveloper #coding #learninginpublic #100DaysOfCode

Day 66 — JavaScript Learning 🚀 Today I cleared one of the most confusing topics in JavaScript: null vs undefined They look similar… but they mean very different things. undefined A variable exists, but no value has been assigned yet. let name; console.log(name); // undefined JavaScript saying: “I know this variable, but it has no value.” null A value intentionally set to empty. let user = null; Developer saying: “This variable should have nothing.” 📌 Simple way to remember: undefined → system empty null → developer empty Understanding this prevents many bugs in APIs & forms. #Day66 #JavaScript #WebDevelopment #LearningInPublic #CodingTips

🚀 How JavaScript Actually Executes Code (And Why It Matters) Spent time breaking down JavaScript internals to improve debugging and async understanding. Here’s the mental model that changed everything 👇 🧠 Core Concepts: • Execution Context (Creation → Execution) • Call Stack (LIFO execution flow) • Lexical Scope & Scope Chain • Hoisting (var vs let behavior) • Closures (reference-based memory) • Event Loop (Microtasks > Macrotasks priority) 💡 Key Insight: JavaScript isn’t unpredictable — it follows a strict execution flow: Execution Context → Call Stack → Event Loop Understanding this made async code, promises, and debugging much more intuitive. 🧩 Problem Solving (Pattern-Oriented Approach) Worked on: • Two Sum → HashMap pattern (O(n)) • Best Time to Buy/Sell Stock → Greedy (min tracking) • Move Zeroes → Two Pointers (in-place) • Contains Duplicate → Hashing / Set Instead of jumping into code, focused on identifying patterns first. 💡 Takeaway: Strong problem-solving comes from recognizing patterns — not memorizing solutions. Building stronger fundamentals to write better, more predictable code. 💪 #JavaScript #DSA #WebDevelopment #ProblemSolving #FrontendDeveloper #MERNStack Visualizing how JavaScript executes code helped everything click 👇

One JavaScript habit that improved my code instantly Earlier, my JavaScript files were long and confusing. Everything was written in one place… and debugging was painful. Then I started using small reusable functions instead of writing everything in one block. Now my code is: 1- easier to read 2-ceasier to understand 3- easier to test 4- easier to reuse Instead of repeating logic, I write it once and call it when needed. This one habit saved me time and reduced bugs in my projects. It reminded me of one thing: Clean code is not about writing more code. It’s about writing better code. Still learning and improving every day 🚀 What coding habit helped you the most? #JavaScript #CleanCode #WebDevelopment #FrontendDeveloper #LearningJourney #CodeTips

🚀 Day 910 of #1000DaysOfCode ✨ Understanding `setTimeout` in JavaScript `setTimeout` looks simple — but it plays a powerful role in how JavaScript handles asynchronous behavior. In today’s post, I’ve explained how `setTimeout` actually works, how it interacts with the event loop, and why timing in JavaScript isn’t always as straightforward as it seems. If you’ve ever been confused about execution order, delays, or async behavior in JS, this post will help you build a much clearer mental model. 👇 Have you ever been surprised by how `setTimeout` behaves? Let’s discuss in the comments! #Day910 #learningoftheday #1000daysofcodingchallenge #FrontendDevelopment #WebDevelopment #JavaScript #React #Next #CodingCommunity #AsyncJavaScript

📚 Back to the Core: Strengthening My JavaScript Foundations Lately, I’ve been dedicating focused time to revisiting the core concepts of JavaScript — not just skimming through tutorials, but truly understanding how things work under the hood. Instead of rushing toward frameworks, I decided to slow down and strengthen my fundamentals: ✅ Scope & Closures ✅ Hoisting ✅ Execution Context & Call Stack ✅ Prototypes & Inheritance ✅ Asynchronous JavaScript (Promises, Async/Await, Event Loop) ✅ “this” keyword behavior One thing that has made a huge difference? ✍️ Taking structured notes while studying 💻 Practicing side by side as I learn Writing notes forces clarity. Practicing immediately reinforces understanding. When theory meets implementation, concepts stick. I’ve realized that strong fundamentals make everything else easier — debugging, reading code, learning frameworks, and even system design. It’s tempting to jump straight into tools and libraries, but mastering the basics builds long-term confidence. If you're learning JavaScript (or any skill), my advice: 👉 Don’t skip the core concepts. 👉 Take notes like you’ll teach someone else. 👉 Practice while you study. Growth happens when learning is intentional. #JavaScript #WebDevelopment #LearningJourney #100DaysOfCode #FrontendDevelopment #SoftwareDevelopment #ContinuousLearning