Node.js CLI Output with styleText

Understanding the Node.js event loop finally made async JavaScript click for me. Here’s a simple example that confused me earlier: console.log("Start"); setTimeout(() => console.log("Timeout"), 0); Promise.resolve().then(() => console.log("Promise")); console.log("End"); Many beginners expect: Start → Timeout → Promise → End But the actual output is: Start → End → Promise → Timeout Why? Because Promises (microtasks) run before timer callbacks in the event loop. That one concept explains a lot of async behavior in Node.js. Once I understood this, debugging async issues became much easier. What JavaScript concept took you the longest to understand? #nodejs #javascript #backend #webdevelopment #softwareengineering

🌱 Going back to basics "Uncontrolled Components" Yesterday I wrote about "Controlled Components". Today, let’s talk about the other side "Uncontrolled Components". Not everything needs to be controlled by state. Sometimes, the input can manage its own value, and we just read it when needed. Using "ref", we can directly access the input value without syncing every change with React state. A "ref" gives us direct access to the DOM element. Instead of storing every keystroke in state, we simply read the value when we actually need it like "on submit". Less wiring. Less state management. Sometimes less headache Uncontrolled components are useful when: - You don’t need instant validation - You only need the value on submit - The form logic is simple "Controlled components" give clarity. "Uncontrolled components" give simplicity. Going back to basics is also about knowing when to control and when to let go. Both have their place. #ReactJS #Frontend #JavaScript #GoingBackToBasics #LearningInPublic

⏳ “JavaScript is single-threaded.” I used to hear this everywhere. But then I had one question: If JavaScript is single-threaded… How does async code work? That’s when I learned about the Event Loop. Here’s the simple idea 👇 🧠 JavaScript has: • Call Stack • Web APIs • Callback Queue • Event Loop When async code runs (like setTimeout or fetch): 1️⃣ It moves to Web APIs 2️⃣ Once completed, it goes to the Callback Queue 3️⃣ The Event Loop checks if the call stack is empty 4️⃣ Then pushes it back to execute That’s why: console.log(1) setTimeout(() => console.log(2), 0) console.log(3) Output is: 1 3 2 Understanding this made debugging async bugs much easier. Frameworks don’t hide this. They rely on it. #JavaScript #EventLoop #WebDevelopment #FrontendDeveloper #NodeJS #SheryiansCodingSchool

Today I learned about JSX in React. JSX stands for JavaScript XML. It lets us write HTML-like code inside JavaScript. For example: Instead of using createElement() manually, we can write code that looks like HTML — and React converts it behind the scenes. JSX makes UI code: * Cleaner * More readable * Easier to maintain It may look like HTML, but it’s actually JavaScript under the hood. Up Next: Understanding Components 👀 React Series – Day 2 🚀 #ReactJS #LearningInPublic #WebDevelopment #FrontendDeveloper

🚀 React+Typescript Practice: Random User Card with Loading State Today I worked on a small React practice project where I: ✅ Fetched data from Random User API ✅ Implemented loading state inside the card UI ✅ Handled conditional rendering properly ✅ Followed correct key usage in map() ✅ Added a refresh button with disabled state during loading This helped me reinforce important React concepts like: useState & useEffect Async/Await data fetching Clean component structure UI-friendly loading handling Small practices like these really help in writing production-ready UI code 💡 Always learning, always improving 🚀 Demo Link- https://lnkd.in/gMQczeKB #ReactJS #FrontendDevelopment #UIDeveloper #JavaScript #WebDevelopment #LearningByDoing

Day 5 – Node.js Understanding Promises Today’s topic: Promises in Node.js. Promises are used to handle asynchronous operations in a structured way and avoid callback nesting. A Promise has three states: • Pending • Fulfilled (Resolved) • Rejected .then() is used for success handling. .catch() is used for error handling. Promises make asynchronous code more readable and maintainable compared to callbacks. Next: async/await – a cleaner way to write asynchronous code. #NodeJS #BackendDevelopment #JavaScript #AsyncProgramming #SoftwareEngineering

🚀 How JavaScript Works Behind the Scenes (Short Version) JavaScript looks simple, but internally a lot is happening. • V8 Engine (Chrome & Node.js) It converts JS into machine code and runs it. Uses: Call Stack → Executes synchronous code Heap → Stores objects & memory • Web APIs + Event Loop Async tasks like setTimeout, fetch, and DOM events go to Web APIs. After completion: Promises → Microtask Queue Timers/Events → Callback Queue The Event Loop moves them to the Call Stack when it's empty. • Garbage Collection V8 uses Mark & Sweep to remove unused memory. Poor reference handling can cause memory leaks. Client vs Server Browser → V8 + Web APIs Node.js → V8 + libuv (async I/O, worker threads) Understanding this helps in writing optimized, scalable, and industry-ready JavaScript. #JavaScript #V8 #EventLoop #WebDevelopment Vikas Kumar Pratyush Mishra

Day 12 – Node.js Handling Routes Without Express Today I implemented basic routing using the built-in http module. By checking req.url, we can manually handle different routes and send appropriate responses. This helps understand how routing works internally before using frameworks like Express. Next: Understanding HTTP methods (GET, POST, etc.) #NodeJS #BackendDevelopment #JavaScript #WebServer #SoftwareEngineering

Node.js is single-threaded... but still handles thousands of requests. How? Understanding how Node.js really works helped me write more efficient, non-blocking backend code. Here’s a high-level breakdown of what powers Node behind the scenes: V8 compiles your JavaScript to machine code Node bindings handle OS-level tasks (like file & network) libuv manages the Event Loop and async operations Worker threads pick up blocking tasks in the background The result? A fast, non-blocking system that can scale even with a single thread. I used to treat Node.js like a black box. But once I understood this flow, debugging async code got a lot easier. Have you explored how the Node.js event loop works behind the scenes? #NodeJS #BackendDevelopment #JavaScript #WebPerformance #AsyncProgramming