I’ve stopped just learning syntax and started understanding the logic behind JavaScript. This week, I focused only on core fundamentals. No frameworks. No shortcuts. Just pure JavaScript practice to make my base stronger. It’s easy to watch tutorials. It’s different when you solve problems on your own and truly understand why the code works. Here is what my practice session looked like today: ✅ Deep Dive into Types: Cleared up the confusion between Primitive vs. Non-Primitive types and finally mastered the difference between Null vs. Undefined. ✅ Logic & Comparison: Practiced Truthy vs. Falsy values and why I should almost always prefer Triple Equal (===) over Double Equal (==) to avoid weird bugs. ✅ Scoping & Hoisting: Got my head around Global, Local, and Block scope. Understanding Hoisting and Closures felt like unlocking a secret level in JS—it makes debugging so much easier! ✅ Functional Power: Spent time with Callback functions and high-order methods like Map, Filter, Find, and Reduce. Seeing how Reduce can transform an entire array into a single value. ✅ Memory & Reference: Learned how JavaScript handles Pass by Value vs. Pass by Reference. This is huge for avoiding accidental data mutations in objects and arrays. ✅ The Little Things: Refined my use of Increment/Decrement operators and how to write cleaner loops using forEach. What I realized from this journey is simple; Strong fundamentals make advanced topics easier. Now when I write code, I feel more confident. I don’t just copy solutions — I understand them. Step by step, building my foundation stronger every day. 🚀 #JavaScript #WebDevelopment #CodingJourney #LearningToCode #Frontend #Programming

Over past week, I’ve been diving deeper into JavaScript fundamentals and I decided to practice everything together in one big script to truly test my understanding. So far, I’ve worked through: • Variables (let, const) • Data types & typeof • Mathematical, assignment & comparison operators • Operator precedence • Template literals • If/else statements • Type conversion vs type coercion • Strict (===) vs loose (==) equality • Basic user input handling Instead of just watching tutorials, I combined multiple lessons into one large practice file to see how everything connects. That exercise alone helped me understand how JavaScript actually behaves especially with tricky coercion cases like: '23' - '10' - 3 Learning JavaScript is less about memorizing syntax and more about understanding how the engine thinks. Still building. Still refining. #JavaScript #WebDevelopment #Frontend #LearningInPublic

I haven’t been posting consistently, but I’ve been learning consistently. Today’s session was a serious deep dive into core JavaScript concepts. We worked in detail on array methods and properties, focusing on logic and real usage: • map() • filter() • reduce() • forEach() The goal was not just to use them, but to understand how they help write cleaner and more functional code. Then we moved into powerful function concepts: • Higher-Order Functions • IIFE (Immediately Invoked Function Expressions) • Closures and lexical scope Closures were the biggest breakthrough. Understanding how a function retains access to its outer variables even after execution completely changed how I see scope and state in JavaScript. Strong foundations first. Speed later. Building depth step by step. #JavaScript #FrontendDeveloper #LearningInPublic #WebDevelopment #DevJourney

🚀 Day 31–36 of #100DaysOfCode (Catch-up Update) Over the last few days I focused on strengthening my JavaScript fundamentals and problem-solving skills. Topics Covered JavaScript Core Concepts 🔹 this keyword 🔹 Try & Catch (Error Handling) 🔹 Arrow Functions & Implicit Return 🔹 setTimeout() and setInterval() 🔹 Function Expressions 🔹 Higher Order Functions Functions & Scope 🔹 Functions with Arguments 🔹 Return Keyword 🔹 Scope (Block & Lexical Scope) Objects in JavaScript 🔹 Object Literals 🔹 Nested Objects 🔹 Array of Objects 🔹 Math Object 🔹 Random Number Generation 🔹 Built a small Guessing Game Loops & Logic Building 🔹 for loops & while loops 🔹 Nested loops 🔹 break keyword 🔹 Loops with arrays Arrays & Methods 🔹 Array Data Structure 🔹 Array Methods 🔹 indexOf() & includes() 🔹 slice(), splice() 🔹 Concatenation & Reverse Mini Project 🔹 Built a simple Todo App using JavaScript Missed posting updates for a few days, but the learning continued. Still moving forward with the challenge and keeping the momentum. Consistency over perfection. 💻🔥 #100DaysOfCode #JavaScript #WebDevelopment #LearningInPublic #CodingJourney

Day 23 – JavaScript 🚀 Shallow Copy vs Deep Copy Understanding how data is copied in JavaScript is important to avoid unexpected bugs, especially when working with objects and arrays. In this post, I’ve covered: • What is a shallow copy • What is a deep copy • Differences between shallow and deep copy • Common methods like spread operator, Object.assign, and JSON methods 📌 Day 23 of my JavaScript learning series. #JavaScript #WebDevelopment #FrontendDevelopment #BackendDevelopment #LearningInPublic #100DaysOfCode #JavaScriptBasics #Developers #CodingJourney

Revisiting Advanced JavaScript Fundamentals Today I spent some time revising a few important JavaScript concepts that every developer should master: ✅ Functions – the core building block of JavaScript ✅ Closures – understanding how functions remember their lexical scope ✅ Objects – structuring and organizing data effectively ✅ Object Destructuring – extracting values cleanly from objects ✅ Array Destructuring – writing cleaner and more readable code Sometimes the best way to improve as a developer is simply revisiting the fundamentals. Every time I review these concepts, I notice patterns and details I missed before.

Today I dove deeper into JavaScript Objects — and honestly… everything in JavaScript starts making more sense now. Objects are like real life. We all have properties. JavaScript let me = { role: "Developer in progress", skills: ["JavaScript", "Problem Solving"], currentlyLearning: "Objects", coffeeLevel: "High ☕" }; What I learned today: Objects store data in key–value pairs They can contain functions (methods) You can dynamically add, update, and delete properties Almost everything in JavaScript is an object The coolest part? You’re not just writing code — you’re modeling real-world concepts. For experienced developers here: 👉 What was your “aha” moment when learning JavaScript? For beginners: 👉 What concept are you currently learning? Let’s grow together. 🚀 #JavaScript #WebDevelopment #LearningInPublic #100DaysOfCode

🚨 Ever seen JavaScript code that looks like a staircase? 💡 In JavaScript, a callback is a function that runs after a task finishes. For example, after fetching data from an API. Sounds easy… until multiple tasks depend on each other. Then the code starts looking like this: ➡️ Get users ➡️ Then get their posts ➡️ Then get comments ➡️ Then get the comment author Every step waits for the previous one. And suddenly code becomes a deep pyramid of nested functions, often called the “Pyramid of Doom” or "Sideways Triangle." ⚠️ Why developers avoid it: 🔴 Hard to read 🔴 Hard to debug 🔴 Hard to maintain ✨ Modern JavaScript solves this with: ✅ Promises ✅ async / await Both make asynchronous code cleaner and easier to understand. What JavaScript concept confused you the most when you started learning? 👇 Let’s discuss. #JavaScript #WebDevelopment #CodingJourney #AsyncProgramming #LearnInPublic

I thought I understood map(), filter(), and reduce() in JavaScript. Individually, they made sense. But then one small doubt confused me: “If I can use filter() to count employees under 30… why can’t I use it to count how many employees belong to each age group?” That question forced me to stop memorizing definitions and actually understand what these methods do. Here’s what finally made it click for me: • map() → transforms each element (same length output) • filter() → selects a subset (smaller array) • reduce() → builds something new (you decide the final shape) The real shift happened when I stopped asking: “Which method should I use?” And started asking: “What does my final result look like?” Array → Array (same length)? → map() Array → Smaller array? → filter() Array → Object / Number / Anything else? → reduce() I’ve written a short article explaining the full journey — including the exact confusion and how I got clarity 👇 🔗 https://lnkd.in/gbJg9aYt #JavaScript #WebDevelopment #FrontendDevelopment #LearningInPublic