Async JavaScript Fundamentals & Node.js Practice

Exploring JavaScript fundamentals! As part of my learning journey, I explored different ways to run JavaScript code in real-world environments. Understanding how and where your code executes is an important step for every developer. Here are 3 simple and commonly used ways to run JavaScript code: ✔️ Browser Console – great for quick testing and debugging ✔️ Node.js Terminal – useful for running JavaScript outside the browser ✔️ VS Code Terminal – efficient for development and project-based coding Each method has its own purpose, and learning all three helps build a strong foundation in JavaScript. #JavaScript #NodeJS #WebDevelopment #Coding #MERNStack #LearningJourney

Day 13 of My JavaScript Journey 🚀 Today’s lesson was different and very important. I learned how to effectively use tools like Google and Stack Overflow to solve problems, and I was introduced to debugging. Debugging is the process of identifying and fixing errors (bugs) in code. The process can be summarized as: • Find the problem • Fix the issue • Prevent it from happening again I also learned that bugs are a normal part of programming every developer deals with them. One key insight: Being a good developer is not about knowing everything, but about knowing how to find solutions. Key takeaway: Problem-solving and debugging are core skills in programming. I’m documenting my journey daily as I grow in JavaScript. #JavaScript #WebDevelopment #LearningInPublic #100DaysOfCode

🚀 Functions changed how I think about writing JavaScript code. While learning JavaScript, I realized something simple but powerful: 👉 Functions prevent repetition and make code reusable. Today I explored functions in depth and covered: • Different ways to create functions • Modern arrow functions • Rest vs Spread operators and how they differ • Callback functions and how functions can be passed as arguments One thing that stood out to me is how functions are not just reusable blocks — they are first-class citizens in JavaScript, meaning they can be stored, passed, and returned like any other value. This opens the door to more advanced patterns and cleaner code structure. Detailed Notes below provided by CoderArmy Channel. Course Instructor: Rohit Negi | Youtube Channel: Coder Army #JavaScript #WebDevelopment #BuildInPublic #FullStackDevelopment

🚀 Learning Update | JavaScript Internals & Async Mastery Here’s what I worked on recently: 🔹 Core Concepts (MDN Deep Dive) Studied the JavaScript Event Loop and Promises to build a strong conceptual foundation. 🔹 Custom Promise Implementation Implemented a Promise from scratch, including: • Constructor & executor • resolve/reject handling • Promise chaining 🔹 Utility Methods Built custom implementations of: • Promise.all() • Promise.race() • Promise.allSettled() 🔹 Testing & Edge Cases Wrote comprehensive test cases covering: • Promise chaining • Error handling • Race conditions 🔹 Learning by Teaching 🎥 Recorded a video explaining Promises & Event Loop with practical code examples. 🔹 Code Sharing Pushed the complete implementation to GitHub with detailed comments for better readability and understanding. 🔹 Communication Improvement Continued reading The Power of Subconscious Mind to enhance clarity and communication 🧠 Diving deeper into fundamentals to build stronger systems thinking. #JavaScript #AsyncProgramming #NodeJS #WebDevelopment #LearningInPublic #GrowthMindset

🚀 Building Strong Foundations in JavaScript 💻✨ ✨Continuing my journey of improving core JavaScript skills through hands-on coding 👇 🔹 Loops Practice ✅ Printed numbers from 1–50 using: • for loop • while loop • do...while loop 🔹 Logic Building ✅ Generated multiplication table dynamically using user input 🔹 Iteration Techniques ✅ Used for...of for arrays and for...in for objects 🔹 Functions Practice ✅ Built a function to check Prime or Non-Prime numbers ✅ Implemented a Callback Function to calculate square of a number ✅ Practiced IIFE (Immediately Invoked Function Expression) to print today’s date 💡 Key Learnings: • Better understanding of loops and iteration • Clear idea of callback & higher-order functions • Debugged a real issue with IIFE and semicolons 😄 📌 Step by step, improving logic and confidence in JavaScript! #JavaScript #CodingJourney #LearningByDoing #FrontendDeveloper #WebDevelopment #KeepGrowing 🚀

A small thing surprised me while learning asynchronous programming in JavaScript and FastAPI. In JavaScript (especially while working with Node.js), I spent time understanding: • Callbacks • Promises • async / await • The Event Loop At one point, async programming felt powerful… but also a little confusing. Especially when multiple API calls and timing behavior started interacting together. Then I started learning FastAPI. And suddenly async felt calmer. Writing async routes in FastAPI felt more readable and structured compared to what I experienced earlier while working with asynchronous flows in Node.js. It wasn’t that JavaScript async is difficult. In fact, learning async in Node.js helped me understand how asynchronous systems actually work behind the scenes. But FastAPI showed me how a framework can reduce the mental load and let you focus more on building logic instead of managing flow. That comparison helped me appreciate both ecosystems differently. Right now I’m continuing to explore async behavior deeper in both Node.js and FastAPI. Curious to know from other developers here — Which one felt more natural to you when you first learned async programming? #JavaScript #NodeJS #FastAPI #BackendDevelopment #AsyncProgramming #LearningInPublic

Understanding JavaScript arrays changed how I think as a developer. Coming from a teaching background I thought coding was memorizing syntax. Feeling a level of guilt when I pulled out my cheat sheet. But working with arrays like .map( ) and .reduce( ) helped me make a lasting connection. It’s not about memorizing code. It’s about solving problems efficiently. Instead of looping manually, I can transform and analyze data in a much cleaner way. If you’re learning JavaScript, stick with it until it clicks! Now I focus less on memorizing and more on understanding patterns. #SoftwareDeveloper #Tech #FullStack #JavaScript #SoftwareEngineer #WebDevelopment #MERNStack

🚀 Day 5 of My JavaScript Learning Journey Today I learned about Type Casting in JavaScript, which is the process of converting a value from one data type to another. 📌 Key concepts I explored: 🔹 Implicit Type Casting • Automatically done by the JavaScript engine • Happens when different data types are used together • Example: '5' + 10 → '510' (number becomes string) 🔹 Explicit Type Casting • Done manually by the developer • Using built-in functions like Number() and String() • Example: Number('42') → 42 String(100) → '100' ⚙️ Understanding type casting is important to avoid unexpected results and write more predictable and clean code. Step by step, I’m improving my JavaScript fundamentals and problem-solving skills. 💻✨ #JavaScript #WebDevelopment #FrontendDevelopment #CodingJourney #LearningInPublic #DeveloperJourney #ProgrammingBasics

🚀 Learning Update | Deep Dive into JavaScript & Problem Solving Today was highly productive with a mix of DSA, core concepts, and practical implementation: 🔹 Solved 2 medium-level LeetCode problems using JavaScript • LC-49: Group Anagrams • LC-238: Product of Array Except Self 🔹 Strengthened JavaScript fundamentals • Completed closures, lexical scope, and variable scope • Implemented 5 closure examples in Replit 🔹 HackerRank Progress • Finished JavaScript Introduction domain (5 problems) 🔹 Hands-on Implementation • Built a closure-based counter (increment, decrement, reset) with proper documentation 🔹 Learning by Teaching • Recorded and reviewed a 1-minute Loom video explaining closures and their use cases in React Consistent effort every day is building strong fundamentals. #JavaScript #DSA #WebDevelopment #LearningInPublic #GrowthMindset

🚀 Day 4 of my JavaScript Coding Practice Today’s problem: Two Sum var twoSum = function(nums, target) { const map = new Map(); // Store: { value : index } for (let i = 0; i < nums.length; i++) { const complement = target - nums[i]; // If the needed number is already in our map, we found the pair! if (map.has(complement)) { return [map.get(complement), i]; } // Otherwise, save the current number and its index map.set(nums[i], i); } return []; // Return empty if no pair is found }; 💡 Instead of using brute force (O(n²)), I used a HashMap approach to solve it in O(n) time. Key takeaway: Understanding how to trade space for time can significantly optimize performance. Small steps every day → Big improvements over time 📈 #JavaScript #DSA #CodingPractice #100DaysOfCode #FrontendDevelopment