Strengthening JavaScript Fundamentals with Core Concepts

Recently I decided to stop memorizing JavaScript and start understanding how it actually works." 😎 💪 Over the past few days, I’ve been diving deeper into how JavaScript actually works behind the scenes. Instead of just writing code, I started learning what really happens inside the JavaScript engine when our code runs. Here are some of the key concepts I’ve been learning: 🔹 Execution Context Every time JavaScript runs code or a function, it creates an execution context that contains the environment needed to run that code. 🔹 Global Memory vs Local Memory Variables declared globally live in global memory, while variables inside functions live in their own local memory. 🔹 Call Stack JavaScript uses a call stack to keep track of which function is currently running and where execution should return after a function finishes. 🔹 Scope & Variable Lookup When JavaScript looks for a variable, it first checks the current scope, then moves outward to outer scopes until it finds it. 🔹 Closures One of the most interesting concepts so far. A function can remember the variables from the environment where it was created, even after that outer function has finished executing. Understanding these concepts made me realize something important: Writing JavaScript is one thing. Understanding how JavaScript thinks is a completely different level. Still learning, still exploring, and enjoying the process. 🚀 If you're learning JavaScript too, what concept took you the longest to understand? #JavaScript #WebDevelopment #Programming #LearnInPublic #FrontendDevelopment

⭐ Learning JavaScript by Building Projects Recently, I’ve been focusing on strengthening my JavaScript fundamentals, and I built a simple Bat Ball Stump game to practice core concepts. Instead of just watching tutorials, I wanted to apply what I learned in a small working project. Through this project, I practiced: 🔹 Variables and data types 🔹 Functions and function calls 🔹 Conditional statements (if–else logic) 🔹 Random number generation 🔹 Objects to manage score 🔹 DOM manipulation to update results dynamically 🔹 LocalStorage to persist data One interesting part was managing and updating the score object correctly and resetting it without breaking the logic — small bugs there taught me a lot about how JavaScript actually behaves. This project reminded me that mastering basics is powerful. Clean logic > complex code. Currently continuing to explore deeper concepts and building more small projects alongside.⭐ #JavaScript #WebDevelopment #LearningJourney #FrontendBasics #CodingPractice

🚀 Just launched a small project to demonstrate JavaScript library usage and practical examples for developers. While learning or working with JavaScript libraries, one common challenge is finding clear and simple usage examples. Many developers spend time searching documentation just to understand how to integrate a library. So I built a simple demo site that shows how to use JavaScript libraries with real examples. 👉 Explore the project: https://lnkd.in/gg_fU8EB What this project focuses on • Practical examples of using JavaScript libraries • Simple and easy-to-understand implementation • Developer-friendly structure for experimentation • A quick reference for integrating libraries into web projects JavaScript libraries play a huge role in modern web development by helping developers build features faster and reuse tested functionality rather than writing everything from scratch. (arXiv) This project is part of my effort to build useful developer tools and learning resources while exploring new ideas around automation, testing, and developer productivity. If you're a developer, student, or someone exploring JavaScript libraries, I’d love your feedback. Let me know what libraries or examples you would like to see added next. #JavaScript #WebDevelopment #DeveloperTools #Frontend #Programming #Coding #OpenSource #LearningInPublic #BuildInPublic

My JavaScript Learning Journey Focused on one of the most powerful parts of JavaScript: Functions & Array Methods Here’s what I learned : ✅ Function Fundamentals Understanding parameters, arguments, and how functions help create reusable code. ✅ Arrow Functions (ES6) A cleaner and modern way to write functions in JavaScript. ✅ Methods vs Functions Learning how methods are tied to objects like arrays and strings. ✅ Higher-Order Functions Functions that can take other functions as arguments or return them. ✅ Essential Array Methods • map() → Transform data • filter() → Select specific elements • reduce() → Convert an array into a single value These methods are widely used in modern JavaScript and React development, and mastering them makes code cleaner and more efficient. Consistency > Perfection. If you're also learning JavaScript, let's connect and grow together! 🚀 #JavaScript #WebDevelopment #CodingJourney #LearningInPublic #FullStackDeveloper #100DaysOfCode

🚨 JavaScript Array Methods look simple… until they don’t. Most developers learn map(), filter(), and reduce() early. But when you actually practice them deeply, you start noticing small behaviors that can easily trip you up in interviews or real projects. Today I spent time revisiting these core methods, and a few surprisingly tricky edge cases stood out. Here are some that caught my attention 👇 ⚠️ 1️⃣ map() without a return [1,2,3].map(x => { x * 2 }) Output: [undefined, undefined, undefined] Why? Because when you use {} in arrow functions, you must explicitly return the value. ⚠️ 2️⃣ Thinking filter(x => x % 2) returns even numbers [1,2,3,4].filter(x => x % 2) Output: [1,3] Because: odd % 2 → 1 → true even % 2 → 0 → false So this actually returns odd numbers, not even ones. ⚠️ 3️⃣ Using map() when filter() is needed [1,2,3,4].map(x => { if(x % 2 === 0) return x; }) Output: [undefined, 2, undefined, 4] Because map() always keeps the same array length, even when nothing is returned. ⚠️ 4️⃣ The famous parseInt trap [1,2,3].map(parseInt) Output: [1, NaN, NaN] Why this happens: map() passes (element, index) to the callback. So it becomes: parseInt(1,0) parseInt(2,1) parseInt(3,2) Which leads to unexpected results. 💡 Big takeaway: Knowing JavaScript syntax is useful. But understanding how JavaScript actually behaves internally is what makes you a better developer. Small details like these often separate surface knowledge from real mastery. If you're learning JavaScript right now, try experimenting with these methods yourself. You’ll be surprised how much depth there is. 🚀 💬 Which JavaScript behavior confused you the most when you were learning? Let’s share and learn together. #javascript #webdevelopment #frontenddevelopment #softwareengineering #coding #programming #developers #100daysofcode #learninpublic #techcommunity #codingtips #javascriptdeveloper

When I first started learning #JavaScript, I made a lot of mistakes. Not because JavaScript is hard — but because I was learning it the wrong way. If you’re starting your JavaScript journey, try to avoid🛑 these 3 common mistakes: 1️⃣. Jumping straight into frameworks** Many beginners start with #React, #Next.js, or other frameworks without understanding core JavaScript. Frameworks are built **on top of JavaScript**. If your basics are weak, everything will feel confusing. Start with fundamentals: Variables, Functions, Arrays, Objects, Closures, Promises, and the DOM. 2️⃣. Watching videos tutorials without mentorship ** Watching 10 hours of tutorials feels productive… but it’s not the same as practising Real learning happens when you: * write code * break things * debug errors * build small projects Code along. Then try building the same thing 3️⃣. Trying to memorize everything** You don’t need to remember every method or syntax. Great developers don’t memorize everything. They understand concepts and know **how to find answers**. Focus on understanding *why things work*, not just *how to write them*. If you avoid these three mistakes early, your JavaScript journey becomes much easier. What mistake did you make when learning JavaScript? #javascript #webdevelopment #coding #programming #frontend #learnjavascript

📌 JavaScript Learning Resource – Cheat Sheet While revising JavaScript, I found a helpful cheat sheet that summarizes core concepts like variables, operators, control flow, functions, arrays, DOM basics, and async ideas. Sharing it here for anyone who is refreshing JS fundamentals like me. Found this while learning and thought it might help others, too. Follow Nikhil Tiwari for more useful content w3schools.com JavaScript Mastery #JavaScript #LearningJourney #WebDevelopment #StudentsInTech

Over the past few days, I’ve been learning more about 𝐎𝐛𝐣𝐞𝐜𝐭-𝐎𝐫𝐢𝐞𝐧𝐭𝐞𝐝 𝐏𝐫𝐨𝐠𝐫𝐚𝐦𝐦𝐢𝐧𝐠 (𝐎𝐎𝐏) in JavaScript, and some concepts are finally sticking. One new thing I’ve learned is the difference between instance methods and static methods. Instance methods belong to objects created from a class, while static methods belong to the class itself and are usually used for utility or general operations. I also came across getters and setters, which honestly changed how I think about working with object properties. They allow us to control how values are accessed or modified, making our code safer and more structured. Another concept that stood out was Object.create(). I got to know it creates a new object and links it to a prototype, I also understand now that JavaScript doesn’t copy methods between objects. Instead, objects are linked together, and JavaScript searches through this connection using the prototype chain. That delegation process is honestly one of the most interesting things I’ve learned about how JavaScript works internally. Still learning. Still building. #JavaScript #WebDevelopment #LearningInPublic #Growth #TechJourney

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