Rohan Paramane’s Post

𝐓𝐡𝐞 𝐜𝐚𝐥𝐥 𝐬𝐭𝐚𝐜𝐤 𝐡𝐚𝐬 𝐧𝐨 𝐩𝐚𝐭𝐢𝐞𝐧𝐜𝐞. 𝐈𝐭 𝐞𝐱𝐞𝐜𝐮𝐭𝐞𝐬 𝐞𝐯𝐞𝐫𝐲𝐭𝐡𝐢𝐧𝐠 — 𝐢𝐧𝐬𝐭𝐚𝐧𝐭𝐥𝐲, 𝐫𝐮𝐭𝐡𝐥𝐞𝐬𝐬𝐥𝐲, 𝐢𝐧 𝐨𝐫𝐝𝐞𝐫. So what happens when you need a 𝐝𝐞𝐥𝐚𝐲? That's where I hit a wall. If JavaScript is single-threaded and the call stack never pauses — how does '𝐬𝐞𝐭𝐓𝐢𝐦𝐞𝐨𝐮𝐭' even work? Turns out, it doesn't live in JavaScript at all. 𝐖𝐞𝐛 𝐀𝐏𝐈𝐬 — 𝐬𝐞𝐭𝐓𝐢𝐦𝐞𝐨𝐮𝐭, 𝐟𝐞𝐭𝐜𝐡( ), 𝐃𝐎𝐌 𝐞𝐯𝐞𝐧𝐭𝐬, 𝐥𝐨𝐜𝐚𝐥𝐒𝐭𝐨𝐫𝐚𝐠𝐞 — are gifts from the browser, not the language. The browser quietly hands them off, runs them in the background, then places the result into a 𝐂𝐚𝐥𝐥𝐛𝐚𝐜𝐤 𝐐𝐮𝐞𝐮𝐞 . And here's the elegant part: The 𝐄𝐯𝐞𝐧𝐭 𝐋𝐨𝐨𝐩 sits there, watching. The moment the call stack is empty, it picks up the waiting callback functions and pushes it in. That's it. No magic. Just a disciplined handoff between three moving parts. JavaScript doesn't wait — but the browser builds the patience "around" it. 𝐓𝐚𝐤𝐞𝐚𝐰𝐚𝐲𝐬 : → 𝐓𝐡𝐞 𝐜𝐚𝐥𝐥 𝐬𝐭𝐚𝐜𝐤 𝐞𝐱𝐞𝐜𝐮𝐭𝐞𝐬 𝐟𝐚𝐬𝐭. 𝐍𝐞𝐯𝐞𝐫 𝐚𝐬𝐬𝐮𝐦𝐞 𝐢𝐭 𝐰𝐚𝐢𝐭𝐬. → 𝐖𝐞𝐛 𝐀𝐏𝐈𝐬 𝐚𝐫𝐞 𝐛𝐫𝐨𝐰𝐬𝐞𝐫-𝐩𝐨𝐰𝐞𝐫𝐞𝐝, 𝐚𝐜𝐜𝐞𝐬𝐬𝐞𝐝 𝐯𝐢𝐚 𝐭𝐡𝐞 𝐠𝐥𝐨𝐛𝐚𝐥 "𝐰𝐢𝐧𝐝𝐨𝐰" 𝐨𝐛𝐣𝐞𝐜𝐭. → 𝐓𝐡𝐞 𝐞𝐯𝐞𝐧𝐭 𝐥𝐨𝐨𝐩 𝐨𝐧𝐥𝐲 𝐚𝐜𝐭𝐬 𝐰𝐡𝐞𝐧 𝐭𝐡𝐞 𝐜𝐚𝐥𝐥 𝐬𝐭𝐚𝐜𝐤 𝐢𝐬 𝐜𝐥𝐞𝐚𝐫. #JavaScript #SoftwareEngineering #DeveloperJourney #LearningInPublic #Programming #TechCommunity #WebDevelopment

🚀 𝐃𝐚𝐲 𝟓/𝟏𝟓 𝐨𝐟 𝐌𝐲 𝐉𝐚𝐯𝐚𝐒𝐜𝐫𝐢𝐩𝐭 𝐋𝐞𝐚𝐫𝐧𝐢𝐧𝐠 𝐒𝐞𝐫𝐢𝐞𝐬 Today I learned about Loops in JavaScript 🔁 👉 Loops are used to run a block of code multiple times. 📌 Types of Loops: 1️⃣ for loop for (let i = 0; i < 5; i++) { console.log(i); } 2️⃣ while loop let i = 0; while (i < 5) { console.log(i); i++; } 👉 Both loops do the same thing, but the use depends on the situation. 📌 Key Difference: for loop → when you know how many times to run while loop → when condition-based looping is needed Loops make coding faster and more efficient 💻✨ 💬 Question: Which loop do you find easier — for or while? Let’s learn together 🚀 #JavaScript #WebDevelopment #LearningInPublic #Day5 #FrontendDevelopment

Published My New Blog on Hashnode! Understanding JavaScript can feel confusing at first—especially when it comes to Synchronous vs Asynchronous behavior. So I decided to break it down in the simplest way possible. 🧠 In this blog, I explained: What synchronous code really means (step-by-step execution) What asynchronous code is (doing things without waiting) Why JavaScript needs async behavior Real-life examples like API calls & timers Problems with blocking code (why apps freeze ) Easy diagrams to visualize everything link :- [https://lnkd.in/gkdRbW56] #JavaScript #WebDevelopment #CodingForBeginners #AsyncJavaScript #LearnToCode #FrontendDevelopment

Every function you call in JavaScript gets pushed onto a structure called the call stack. That's how JS knows where to go back. Whatever sits on top of the stack is where execution is right now. When the function returns, it gets popped off - and the item below it is back on top, telling JS exactly where to return to. Without this, calling a function from the middle of another function would leave JS completely lost. There would be no "go back to where you were." One side effect: the call stack has limited space. If a function calls itself infinitely with no stopping condition, you get a stack overflow. The name makes perfect sense once you know what it actually is. Next: JS borrows the browser's timer and network - but the browser doesn't hand results back through the call stack. How does it communicate? #JavaScript #WebDevelopment #Programming #SoftwareEngineering

Day 2 of #111DaysOfLearningForChange – Code for Change Today I explored the basics of React and how it helps in building modern user interfaces using React. ✨Core concepts in React 🔹 Components – The building blocks of React.They are reusable and can be created using functions. 🔹 JSX – Allows writing HTML-like syntax inside JavaScript, making code more readable. 🔹 Props – Used to pass data from parent to child components (read-only). 🔹 State – Stores dynamic data inside a component. When state changes, the UI updates automatically. 🔹 Events – React uses camelCase for events like onClick, onChange. 🔹 Hooks – Functions like useState and useEffect that let us use powerful React features in functional components. 🔹 Virtual DOM – React updates only the changed parts of the UI, making applications faster and efficient ⚡ #111DaysOfLearningForChange #CodeForChange #Day2Of111LearningReactJS

PEP TASK-7 🚀 Built a Digital Clock using JavaScript I created a real-time clock application using pure JavaScript, focusing on how time-based functions work behind the scenes. 🔹 What this project demonstrates: • Real-time clock updates using setInterval() • Fetching current time with the JavaScript Date object • Formatting time (HH:MM:SS) dynamically • DOM manipulation to update UI instantly JavaScript makes it possible to build live, interactive features like clocks by continuously updating values every second using functions like setInterval() (Stack Overflow) This project helped me understand how real-time applications work and improved my skills in handling dynamic data in the browser. 💻 Check out the project here: 👉 https://lnkd.in/gWm4YYA5 Would love your feedback! 🙌 #JavaScript #WebDevelopment #Frontend #Coding #StudentDeveloper #Projects #LearningJourney

Here is the golden rule: Use .forEach() when you want to DO something. (Like logging to the console or pushing to an external array). It returns undefined. Use .map() when you want to CREATE something new. It returns a brand new array of the same length. JavaScript const numbers = [1, 2, 3]; // ❌ Bad: Using map just to loop (creates an unused array in memory) numbers.map(num => console.log(num)); // ✅ Good: Using map in React to create an array of JSX elements const UI = numbers.map(num => <li key={num}>{num}</li>); Understanding this difference is crucial for writing clean, bug-free components! #JavaScript #ReactJS #CodingLife #WebDevelopment #Programming #LearnToCode

hi connections Day 22 of 30: Extending the Prototype with LeetCode 2619 🚀 Today’s challenge, Array Prototype Last, dives into one of JavaScript’s most powerful features: Prototypal Inheritance. Instead of writing a standard function, the task was to enhance the global Array object so that every array can call .last() to retrieve its final element. The Logic By adding a method to Array.prototype, we make it available to every array instance. Inside the function, the this keyword refers to the array itself, allowing us to access its length and indices. Key Takeaways: The "this" Context: Understanding how this refers to the calling object is crucial for building custom utilities. Edge Case Handling: In this problem, returning -1 for empty arrays is a specific requirement that differs from the usual undefined. Efficiency: Accessing an element by index is O(1), making this a lightning-fast operation regardless of array size. Customizing prototypes is a common practice in library development, and mastering it helps in writing cleaner, more intuitive code for complex applications. One more day down, more logic mastered! 💻✨ #JavaScript #LeetCode

I used to believe that JavaScript operated with some hidden “thread algorithm” behind the scenes. However, I learned that it doesn't function that way. JavaScript is single-threaded, yet it effectively manages multiple tasks simultaneously through the event loop, not threads. Here's a simplified breakdown: - There’s one main worker (the call stack). - There’s a waiting area (task queues). - There’s a loop that continuously checks what to run next. The core flow looks like this: while (true) { run sync code first if nothing is running: run all microtasks (Promises) then pick one macrotask (timers, I/O) } What surprised me the most is the priority system: Promises always execute before timers. Even a setTimeout(..., 0) has to wait its turn. As for the “threading” aspect? It exists, but not in the way you might expect. The engine (like V8) runs your code in a single thread, while the environment (browser or Node.js) utilizes multiple threads for tasks like network calls and timers. In essence, JavaScript doesn’t schedule threads; it schedules tasks. This shift in perspective can significantly change your understanding of asynchronous code. #javascript #learning #webdevelopment #programming #codewithishwar

Ever felt like your functions could be more flexible and reusable? 🤔 That’s where currying in JavaScript comes in! Instead of passing all arguments at once, currying transforms a function into a sequence of functions — each taking a single argument. ✨ Why it matters: • Improves code reusability • Encourages cleaner, modular design • Makes function composition easier 🔍 Example: const add = a => b => a + b; Now you can do: const add5 = add(5); add5(3); // 8 Small change, big impact 💡 If you're diving deeper into functional programming, currying is definitely a concept worth mastering. #JavaScript #WebDevelopment #FunctionalProgramming #CleanCode #100DaysOfCode