Osvaldo Felices’ Post

Impressed by the simplicity and brilliance behind this open-source project. Pulse is built around a very clean idea: making complex things in JavaScript easier to manage and reason about. Even if you’re not deep into development, it’s interesting to see how a clear concept can shape an entire tool.

🔄 Day 163 of #200DaysOfCode After exploring advanced topics in JavaScript, I decided to slow down and revisit one of the most timeless logic challenges — reversing an array without using the built-in reverse() method. 🌱 It might seem like a simple exercise, but it teaches you something very powerful — how data moves in memory, how to swap values efficiently, and how small logic patterns build the foundation for solving complex problems later on. In JavaScript, it’s easy to rely on built-in functions, but when you write logic manually, you begin to understand the real mechanics behind how things work — and that’s what makes you a stronger developer. 💡 Problems like these remind me that mastery isn’t about how many advanced concepts you know, but how deeply you understand the basics. 🔁 Even experienced developers revisit their roots from time to time — because fundamentals never go out of style. Keep learning. Keep building. Keep evolving. #JavaScript #CodingChallenge #BackToBasics #163DaysOfCode #LearnInPublic #WebDevelopment #DeveloperMindset #ProblemSolving #CodingJourney

Diving into a core concept in JavaScript today: undefined and the Global Execution Context! Ever wondered why a newly declared variable in JS initially holds the value undefined? It's not magic, it's the meticulous work of the JavaScript engine! When your script first runs, the engine sets up the Global Execution Context. Think of this as the main environment for your code. It has two crucial phases: -Memory Creation Phase: Here, the engine scans your code for variable and function declarations. For every variable it finds, it allocates space in the memory component and automatically assigns the value undefined as a placeholder. -Code Execution Phase: Only then does the engine start running your code line by line, finally assigning actual values to your variables. So, undefined isn't just a random state; it's a deliberate signal from the engine that a variable exists but hasn't yet received its defined value during the execution flow. Understanding this helps demystify a lot of common JS behaviors! What are your thoughts on how JavaScript handles undefined? #JavaScript #WebDevelopment #Programming #ExecutionContext #Undefined #Memory #Code

🔄 Day 164 of #200DaysOfCode Today, I revisited another classic JavaScript problem — removing duplicates from an array without using Set() or advanced methods. 💡 While there are modern one-liners that can handle this task in seconds, manually writing the logic helps build a deeper understanding of how arrays, loops, and conditions work together. This small challenge reinforced two key lessons: 1️⃣ Efficiency matters — Writing logic by hand makes you think about time complexity and performance. 2️⃣ Simplicity is strength — The most effective solutions are often the ones built from fundamental principles. 🔁 As developers, it’s not just about knowing shortcuts — it’s about understanding the why behind every concept. Revisiting such basic problems sharpens logical thinking and improves our ability to write cleaner, more optimized code. 🌱 Mastering the basics is not a step backward — it’s the foundation for everything advanced. #JavaScript #CodingChallenge #BackToBasics #164DaysOfCode #LearnInPublic #DeveloperMindset #WebDevelopment #ProblemSolving #CodingJourney

Building a Basic Calculator in JavaScript 🔹 Ever wondered how to evaluate a math expression like '1 + (4 + 5 + 2) - 3' in JavaScript without using eval()? Here's a clean way to do it using stacks. Key Concepts: Stack for previous results and signs: Keeps track of nested parentheses. Sign management: Helps handle + and - correctly. Iterative parsing: Converts string digits into numbers. Avoids the dangers of eval(). Can handle nested parentheses. Shows how stack-based algorithms can solve real-world problems elegantly.

8 JavaScript topics that actually matter Been coding for a while now, these keep coming up: → Closures Functions that remember their context. Used everywhere in React hooks and callbacks. → Promises & Async/Await Writing code that waits without freezing. Essential for API calls. → Array Methods map(), filter(), reduce(). Clean data manipulation. → Event Loop How JavaScript handles async ops. Makes everything click once you get it. → Destructuring Cleaner way to pull values from objects and arrays. Saves a lot of lines. → Spread/Rest Operators Copy arrays, merge objects, handle function params. Super useful. → Prototypes & Inheritance How objects actually work under the hood. Important for interviews. → Module Systems Import/export between files. Keeps code organized. These aren't flashy. But knowing them makes everything easier. What topic gave you the most trouble when learning JS? #JavaScript #Coding #WebDevelopment #100DaysOfCode #LearnToCode #FrontendDevelopment #MERNStack #DeveloperTips

Day 4 of #30DaysOfJavaScript: Mastering Array Transformations Without .map() 🚀 Today’s task was about thinking beyond built-in methods by writing a custom function to transform every element of an array, similar to how .map() works in JavaScript — but doing it all manually! My solution involved iterating over the input array and applying a transformation function to each element, building up a new array with the results: What I learned today: Reinforced fundamentals of array traversal and callback functions. Understood how helpful built-in methods like .map() are—and exactly how they work under the hood. Practiced writing cleaner, modular, and reusable code. Challenging myself with these basics is already making my JavaScript much stronger! On to Day 5 🔥 Are you also on a coding challenge journey? Let’s connect and learn together! #JavaScript #CodingChallenge #WebDevelopment #LearningByDoing #LeetCode #ProblemSolving #TechCommunity

🚀 Day 4 of My 30 Days of JavaScript Challenge 🧩 Problem: Create Counter II (LeetCode #2665) Write a function createCounter(init) that returns an object with three functions: increment() → increases the current value by 1 and returns it decrement() → decreases the current value by 1 and returns it reset() → resets the value back to init and returns it 💻 Language: JavaScript ❓ Question: https://lnkd.in/eupkr-a3 💡 Solution: https://lnkd.in/eq3BEsn2 🧠 Concepts Used: Closures for maintaining private state across function calls Object methods to encapsulate multiple related actions State management inside functions 📚 Takeaway: This challenge reinforces closures and encapsulation — two powerful ideas that make JavaScript functions behave like real objects with memory and behavior. #Day4 #JavaScript #30DaysOfCode #LeetCode #CodingChallenge #WebDevelopment #FrontendDevelopment #100DaysOfCode

✨ Day 10 — How JavaScript Code Works Behind The Scenes! ✨ Today, I went beyond the syntax to understand how JavaScript actually executes code behind the scenes — the hidden engine that makes everything run! ⚙️💻 I began by learning about the Execution Context — the environment where JavaScript code runs — and how it’s created in two key phases: Memory Allocation and Execution. 🧠 Then, I explored how Function Call Execution Contexts are formed and managed using the Call Stack and Heap, helping me visualize how JavaScript handles both primitive values and objects in memory. 📚 I also dived deep into Hoisting, understanding why variables declared with var show up as undefined, and how let & const behave differently due to the Temporal Dead Zone. ⚡ Finally, I wrapped up by studying Function Expressions, Hoisting mechanics, and how the JavaScript Interpreter runs code step by step — truly connecting all the dots behind execution! 🚀 This session gave me a crystal-clear understanding of what happens before a single line of JavaScript runs — the real “magic” behind the language! ✨ #Day10 #JavaScript #WebDevelopment #100DaysOfCode #LearningEveryday #CodingJourney #FrontendDevelopment #Hoisting #ExecutionContext #JSBehindTheScenes

✨Day 6/28 Consistency Challenge ✨ 🚀 Today’s Lesson: Escaping Callback Hell in JavaScript! **Ever found yourself nesting callbacks inside callbacks… until your code starts looking like a staircase to chaos? **Yeah, that’s callback hell — where your code becomes so deeply nested it’s hard to read, debug, or maintain. 💡 What I learned today: Callback hell happens when multiple async functions depend on each other, and everything’s chained inside one another. Callback nesting -> Callback hell. ✅ How to prevent it: ✍️Use Promises to flatten the chain ✍️Switch to async/await for cleaner, more readable code ✍️Keep functions modular and avoid deeply nested logic ✨ Lesson of the day: Clean code isn’t just about making it work — it’s about making it make sense. #JavaScript #CodingJourney #Webdevelopment #EverydayLearning