Emmanuel Edafe’s Post

Hii Folks 🙂 Yesterday, while discussing the JavaScript Event Loop with a senior, I realized something important. Most of us explain the Event Loop using queues and the call stack. That explanation is correct, but it’s incomplete. It answers how things run, not why they behave the way they do. The deeper question came up: Before the Event Loop even starts scheduling tasks, how does JavaScript know what those tasks are allowed to access? That’s where concepts like the compiler and lexical scope quietly enter the picture. JavaScript first reads the code and builds an understanding of it. Variable scope, function boundaries, and memory references are decided before execution begins. This is not the Event Loop’s responsibility. The Event Loop only works with what already exists. Lexical scope determines which variables belong to which functions. Closures decide what stays in memory even after a function finishes. None of this is created by the Event Loop, but all of it affects how async code behaves later. Data structures play a similar hidden role. The call stack is just a stack. Task queues are just queues. The scope chain behaves like a linked structure. The Event Loop doesn’t interpret logic. It simply moves execution between these structures based on a few strict rules. That discussion made one thing clear to me: If we don’t understand compiler behavior, lexical scoping, and basic data structures, the Event Loop will always feel confusing or “magical”. Async issues are rarely caused by the Event Loop itself. They usually come from misunderstanding scope, memory, or execution order. Once you see the Event Loop as a coordinator rather than a decision-maker, a lot of confusion disappears. #JavaScript #EventLoop #LexicalScope #Closures #AsyncProgramming #WebDevelopment #FrontendDevelopment #BackendDevelopment #FullStackDeveloper #SoftwareEngineering #ComputerScience #ProgrammingConcepts #DataStructures #DeveloperLearning #LearningInPublic #TechDiscussions #DeveloperCommunity #CodingLife #Debugging #EngineeringMindset #TechCareers

🚀Day 82 of Cohort2.0 Today's class was about More on Backend with Ankur Prajapati at Sheryians Coding School In This session, we broke down REST APIs and how they enable communication between clients and servers. we learned the core REST principles, proper use of HTTP methods, status codes, and resource-based URLs, and why sloppy API design causes long-term pain. This session focused on building a clean mental model of API interaction, not just hitting endpoints. #responsiveness #responsivedesig #css #scss #html #Cohort2 #webdevelopment #Javascript #react #DOM #frontend

Call, apply, and bind solve one problem: borrowing functions between objects. Have a method on one object but need it on another? Instead of writing it again, just borrow it: ``` let user1 = { name: "John" }; let user2 = { name: "Sarah" }; function greet(greeting) {  console.log(`${greeting}, ${this.name}`); } greet.call(user1, "Hello"); // Hello, John greet.call(user2, "Hi");   // Hi, Sarah ``` One function. Works with any object. No repetition. The difference between all three is simple: - call() - runs immediately, arguments one by one apply() - runs immediately, arguments as array bind() - doesn't run, returns a new function for later ``` greet.call(user, "Hello");      // Runs now greet.apply(user, ["Hello"]);    // Runs now let boundGreet = greet.bind(user, "Hello"); boundGreet();            // Runs later ``` bind() is especially useful when you need to pass a method somewhere but don't want it to lose its context: ``` // Without bind - loses context setTimeout(user.greet, 1000); // undefined // With bind - context preserved setTimeout(user.greet.bind(user), 1000); // Works! ``` Documented all three with real examples: https://lnkd.in/dTh6_VV8 Thanks to Akshay Saini 🚀 for breaking this down clearly. Which one do you use most? Let me know if I missed anything, happy to improve it. #JavaScript #WebDev #Coding #100DaysOfCode #LearningInPublic

🚀Day 81 of Cohort2.0 Today's class was about More on Backend with Ankur Prajapati at Sheryians Coding School In This session, we introduce APIs and why they exist in modern softwere systems. This session explained what APls are, how they work, and how different systems communicate through them. we understood concepts like requests, responses, endpoints, and data exchange formats, without jumping straight into tools. #responsiveness #responsivedesig #css #scss #html #Cohort2 #webdevelopment #Javascript #react #DOM #frontend

🚀Day 71 of Cohort2.0 Today's class was about More on Local storage with Sarthak Sharma at Sheryians Coding School In This session we go beyond basics and focus on practical use csess of LocalStorage in al applications. we Implemented patterns like persisting user preferences, saving form state, and syncing data with React state. This session also covers limitations, performance concerns, and cleanup strategies so you don't misuse storage. #responsiveness #responsivedesig #css #scss #html #Cohort2 #webdevelopment #Javascript #react #DOM #frontend #LocalStorage

The hell of parsers. One day, you think you’ve written a simple unit test. The next day, you realize you’ve opened a crack in the geometry of JavaScript. I was testing what felt like a safe invariant: source code → structure → source code. No transformation. No creativity. Just fidelity. And yet, something vanished. No error. No crash. No warning. Just a quiet absence. That’s when you learn the hard lesson: in JavaScript, structure is not always where you expect it to be. Some constructs don’t live inside what they initialize. They orbit it. Parsers rarely fail loudly. They fail silently and structurally. And once you see it, you can’t unsee it. Welcome to the hell of parsers. #Programming #JavaScript #Parsing #AST #Compilers #SoftwareEngineering #SystemsThinking #DeveloperLife #DeepTech #UnderTheHood

I built a small tool called MultiJSON to simplify working with JSON. https://www.multijson.com 🙌 It helps you format, validate, and manage multiple JSON files in one place, and makes sharing clean JSON easy. The tool is fully client-side, so your data never leaves the browser. Built it to scratch a personal itch — sharing in case it helps others too. #JSON #WebDevelopment #SoftwareEngineering #DeveloperTools #PrivacyFirst #Coding #DataScience #JavaScript #WebDev

𝐈𝐟 𝐲𝐨𝐮𝐫 𝐓𝐲𝐩𝐞𝐒𝐜𝐫𝐢𝐩𝐭 𝐠𝐞𝐧𝐞𝐫𝐢𝐜𝐬 𝐟𝐞𝐞𝐥 𝐥𝐢𝐤𝐞 𝐠𝐥𝐨𝐫𝐢𝐟𝐢𝐞𝐝 𝐚𝐧𝐲𝐬, 𝐲𝐨𝐮'𝐫𝐞 𝐦𝐢𝐬𝐬𝐢𝐧𝐠 𝐚 𝐭𝐫𝐢𝐜𝐤. Writing reusable functions with generics is powerful, but leaving your type parameters too broad can defeat the purpose of TypeScript. How often do you find yourself writing obj[key as any] or obj[key as keyof T] to appease the compiler, feeling like you've lost type safety? The fix is often simple: constrain your generic type parameter to enforce type safety at compile time. Instead of: ```typescript function getPropertyBad<T>(obj: T, key: string) { return obj[key as keyof T]; // 'as keyof T' is an assertion, not a guarantee } ``` Do this: ```typescript function getPropertyGood<T, K extends keyof T>(obj: T, key: K): T[K] { return obj[key]; // Type-safe! K is guaranteed to be a key of T } interface Product { id: string; name: string; price: number; } const product: Product = { id: 'p1', name: 'Widget', price: 29.99 }; const productName = getPropertyGood(product, 'name'); // productName is string const productPrice = getPropertyGood(product, 'price'); // productPrice is number // getPropertyGood(product, 'description'); // Argument of type '"description"' is not assignable to parameter of type '"id" | "name" | "price"'. // The compiler catches typos or non-existent keys immediately! ``` This pattern is a game-changer for building robust utility functions, custom React hooks, or any helper that needs to access object properties dynamically without sacrificing type safety. You get auto-completion and compile-time error checking, making your code much more maintainable and refactor-friendly. Are there specific generic constraints you find yourself using repeatedly in your projects? #TypeScript #FrontendDevelopment #React #WebDevelopment #SoftwareEngineering

Minimizing Maximum Pair Sum in Arrays 👉 Day 75 / Day 93 👈 23🔥 The idea: Sort the array Pair smallest with largest, second smallest with second largest, and so on Track the maximum sum among all pairs Example: nums = [3, 5, 2, 3] Sorted: [2, 3, 3, 5] Pairs: (2, 5) = 7, (3, 3) = 6 Maximum pair sum = 7 👉 This is the minimized maximum pair sum. #Coding #Algorithms #DataStructures #JavaScript #TypeScript #CleanCode #ProblemSolving #LeetCode #InterviewPrep