How Encapsulation and Polymorphism Organize JavaScript Code

𝗗𝗮𝘆 𝟯𝟵: From Object Internals & this Keyword to Asynchronous JavaScript! 🤯 Today's session at the AI Powered Cohort was one of the most critical yet. We tackled some of the most powerful (and notoriously tricky) concepts in JavaScript. A huge thank you to Harsh Vandana Sharma and Sheryians Coding School for navigating us through this! Here's a breakdown of what we covered: 𝗢𝗯𝗷𝗲𝗰𝘁 𝗜𝗻𝘁𝗲𝗿𝗻𝗮𝗹𝘀: We went beyond just using objects and learned how they truly work 𝗦𝘁𝗼𝗿𝗮𝗴𝗲: How objects are stored by reference in memory (unlike primitive types). 𝗜𝘁𝗲𝗿𝗮𝘁𝗶𝗼𝗻: How to traverse the keys of an object (e.g., using for...in). Arrays as Objects: The "aha!" moment that arrays are just a special type of object with numbered keys. 𝗔𝘀𝘆𝗻𝗰𝗵𝗿𝗼𝗻𝗼𝘂𝘀 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 (𝗧𝗶𝗺𝗶𝗻𝗴 𝗘𝘃𝗲𝗻𝘁𝘀): We took our first step into async programming! 𝘀𝗲𝘁𝗧𝗶𝗺𝗲𝗼𝘂𝘁(): To delay the execution of a function. 𝘀𝗲𝘁𝗜𝗻𝘁𝗲𝗿𝘃𝗮𝗹(): To run a function repeatedly at a specific interval. 𝗰𝗹𝗲𝗮𝗿𝗧𝗶𝗺𝗲𝗼𝘂𝘁() & 𝗰𝗹𝗲𝗮𝗿𝗜𝗻𝘁𝗲𝗿𝘃𝗮𝗹(): The crucial methods for stopping our timers and preventing memory leaks. 𝗔𝗱𝘃𝗮𝗻𝗰𝗲𝗱 𝗢𝗯𝗷𝗲𝗰𝘁 𝗢𝗽𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝘀: We learned how to control and manipulate objects with precision. 𝗢𝗯𝗷𝗲𝗰𝘁.𝗳𝗿𝗲𝗲𝘇𝗲() & 𝗢𝗯𝗷𝗲𝗰𝘁.𝘀𝗲𝗮𝗹(): To make objects immutable or prevent new properties. 𝗗𝗲𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗶𝗻𝗴: The modern, clean syntax for extracting properties from objects and arrays. 𝗢𝗯𝗷𝗲𝗰𝘁 𝗠𝗲𝘁𝗵𝗼𝗱𝘀 & 𝘁𝗵𝗶𝘀 𝗞𝗲𝘆𝘄𝗼𝗿𝗱: We tackled the infamous this keyword, understanding how its value is determined by the context in which a function is called. 𝗣𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹 𝗔𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻: We didn't just learn theory! We immediately applied all these concepts by solving a long list of practical questions (as seen in the screenshot!). This really helped solidify everything from object creation to setTimeout. Understanding the this keyword and timing events feels like unlocking a new level in development. #Day39 #CodingJourney #AIpoweredCohort #JavaScript #AsyncJS #setTimeout #thisKeyword #Objects #WebDevelopment #Programming #SheryiansCodingSchool #HarshVandanSharma

🌳 Visualizing Recursion Through Code 🚀 Recursion has always fascinated me — a function calling itself, building complexity from simplicity. It’s at the core of so many DSA problems — tree traversals, backtracking, divide & conquer, and dynamic programming — all rely on recursive thinking. Recently, I tried to visualize recursion using p5.js and ended up creating this 3D fractal tree 🌲 💡 How it works: • The branch() function draws a single branch. • It then recursively calls itself to create smaller branches at different angles. • As the branches shorten, the recursion reaches its base case — forming leaves 🍃 Each level of recursion builds on the previous one, forming an entire structure from a simple rule. This project reminded me how deeply recursion connects logic and creativity — not just solving problems, but visualizing the process itself. Tags : Rohit Negi Aditya Tandon CoderArmy #coding #p5js #javascript #recursion #creativecoding #dsa #visualization #funwithcode

🚀Today I learned: How JavaScript executes inside the browser! We all write JavaScript every day — but have you ever wondered what actually happens behind the scenes when we run our code? Here’s what I learned👇 🔹Step-by-step explanation: 1️⃣Source Code → We write JavaScript in a .js file — just plain text that browsers can’t execute directly. 2️⃣Parsing → The JavaScript engine reads the code, checks for syntax errors, and prepares it for further processing. 3️⃣AST (Abstract Syntax Tree) → The code is converted into an AST, a structured tree that represents the program logic in a machine-understandable format.🌳 4️⃣Interpreter → The AST is passed to the interpreter, which converts it into bytecode for quick startup and execution. 5️⃣Execution & Profiling → While executing bytecode, the engine tracks which parts of the code run most frequently — known as “hot” code. 6️⃣Optimizing Compiler (JIT) → The JIT (Just-In-Time) compiler takes that hot code and compiles it into machine code, making it much faster.⚡ 7️⃣Machine Code Execution → Finally, this optimized machine code runs directly on the CPU, giving JavaScript near-native speed and efficiency. 🧠In simple words: JavaScript uses both an Interpreter (for quick startup) and a JIT Compiler (for optimized performance). Really fascinating to see how much happens behind the scenes every time we run a simple JS file!✨ #TodayILearned #JavaScript #WebDevelopment #Frontend #Programming #V8Engine #LearningEveryday #10000coders #SudheerVelpula Special thanks to Sudheer Velpula Sir and @10000 Coders for the amazing learning journey and constant guidance🙌

One of the most valuable features of functional programming is the ability to work with lazy sequences. Today, nearly every programming language supports generics, functions as values, and iterators. These are essential building blocks for operators that work with lazy sequences. In the next series of posts, we will build my JavaScript library, powerseq, from scratch. https://lnkd.in/dTdM5snr

JavaScript Learning – Today's Topic : Understanding Closures Have you ever seen a function “remember” variables even after its parent function has finished running? 🤔 That’s not magic — it’s called a Closure ✨ 🔍 What is a Closure? A closure is formed when an inner function “remembers” the variables of its outer function, even after that outer function has completed execution. In short: Functions remember the environment they were created in. Example 1: Simple Closure Javascript function outer() { let name = "Venkatesh"; function inner() { console.log("Hello, " + name); } return inner; } const greet = outer(); greet(); // Output: Hello, Venkatesh Explanation: • The outer() function returns inner(). • Even though outer() is done executing, the inner function still remembers the name — that’s closure! Example 2: Private Variables (Real-life Use) Javascript function counter() { let count = 0; return { increment: function() { count++; console.log(count); }, decrement: function() { count--; console.log(count); } }; } const myCounter = counter(); myCounter.increment(); // 1 myCounter.increment(); // 2 myCounter.decrement(); // 1 ✅ Here, count is private — you can’t access it directly from outside! Closures help in data hiding and encapsulation (like private variables in OOP). 🧠 Why Closures Are Useful ✅ Maintain state between function calls ✅ Implement data privacy ✅ Used in callbacks and event listeners ✅ Help create factory functions and module patterns In Simple Words A closure is like a backpack 🎒 — when a function travels, it carries the variables it needs from its home environment. #JavaScript #Closures #WebDevelopment #Coding #FrontendDevelopment #LearnToCode #JSConcepts #WebDev #Programming #Developer #CodeNewbie #100DaysOfCode #SoftwareEngineering #JavaScriptTips #CodeWithVenkatesh #WebTech #AsyncJS #TechLearning #InterviewPrep

I used to think JavaScript was an asynchronous language. Turns out, it’s actually synchronous by design. It executes one line at a time in a single thread. But here’s where it gets cool. Thanks to the event loop and features like callbacks, promises, and async/await, JavaScript can handle asynchronous tasks without freezing the page. So while one task runs, another can wait in line without blocking the main thread. In other words, JavaScript behaves synchronously but can act asynchronously. That balance is what makes it so powerful on the web. Other languages: Python and Ruby are mostly synchronous. Go and Rust support true parallelism. C++ and Java use multithreading. But JavaScript is unique. It doesn’t just run code, it choreographs it. These complex dynamics are what make picking JavaScript as my first language worth it. Behind every smooth animation, instant search result, or real-time notification, there’s a little async magic doing the heavy lifting. And once you understand the event loop, it honestly feels like you’ve unlocked one of programming’s secret cheat codes. #JavaScript #WebDevelopment #Coding #AsyncJS #SoftwareEngineering #ProgrammingHumor #TechMindset #WTFC25

Dr. James McCaffrey presents a complete end-to-end demonstration of ANOVA (analysis of variance) using JavaScript. ANOVA is a classical statistical technique where the goal is to determine if the unknown means (averages) of three or more groups are likely to all be equal or not, based on the variances of samples from the groups. Get the code download here ➡️ https://lnkd.in/e8Sb8jcF #ANOVA #JavaScript #Dev #CodingHelp

Day 35 of #100DaysOfCode – Functions, Recursion & Do-While Loop in JavaScript Today’s learning focused on some of the most important programming fundamentals in JavaScript: Key Learnings: Do-While Loop → Understanding how it executes the block at least once before checking the condition Functions in JavaScript → Structure, reusability, and clean code Arguments vs Parameters → How data is passed and handled Rest Parameters → Efficient way to work with variable number of inputs Recursion → Calling functions within themselves to solve repeating subproblems Hoisting → Variable Hoisting — behavior differences between var, let, and const Function Hoisting — how JavaScript moves function declarations to the top during execution Takeaway: Functions and recursion unlock powerful logic possibilities, and understanding hoisting helps avoid unexpected bugs. These concepts form the backbone of writing optimized and predictable JavaScript code. A big thanks to Harsh Vandana Sharma from Sheryians Coding School and Sheryians Coding School Community for making function mechanics and hoisting concepts easy to understand with practical examples. #100DaysOfCode #JavaScript #Functions #Recursion #WebDevelopment #CodingJourney #Frontend

Day 37 of #100DaysOfCode – Exploring Arrays, Functions & Objects in JavaScript Today’s session was packed with essential JavaScript concepts that strengthen how data is handled, accessed, and manipulated in programs. Key Learnings: Revisited Pure and Impure Functions to understand how side effects impact predictability in code. Deepened understanding of scoping in JavaScript especially global and function scope  and how closures retain access to outer variables. Worked with arrays and explored key methods: push(), pop(), filter(), reverse(), sort(), map(), slice(), join(), toString(), and using the spread operator for copying and merging arrays. Practiced accessing arrays using both for and forEach loops. Introduced to objects in JavaScript understanding key-value pairs, creation, deletion, and nested objects for structured data representation. Takeaway: Mastering arrays, objects, and closures builds a strong foundation for working with real world data structures and functional programming in JavaScript. Grateful to Harsh Vandana Sharma from Sheryians Coding School and Sheryians Coding School Community for the detailed explanation and practical exercises that made these concepts easy to grasp. #100DaysOfCode #JavaScript #WebDevelopment #Frontend #CodingJourney #LogicBuilding #DataStructures