Sankalp Mishra’s Post

Day 5 of #LearnInPublic — Starting Again After a Long Break After being inconsistent with coding for quite some time, today I finally sat down and restarted my learning journey. No perfect plan. No motivation spike. Just the decision to begin again. Today I focused on strengthening my JavaScript fundamentals — and concepts that once felt confusing started making real sense. What I learned today: 1. Scope Understanding where variables can be accessed: • Global scope • Function scope • Block scope This changed how I read and reason about code. 2. Execution Context Every JavaScript program runs in two phases: • Memory Creation Phase • Execution Phase JavaScript prepares memory before executing code — something happening behind the scenes every time a function runs. 3. Lexical Scope JavaScript follows lexical scoping, meaning variable access depends on where a function is defined, not where it is called. This cleared one of my long-standing confusions. 4. Closures (Key Learning) Functions can remember variables even after the parent function has finished execution. I practiced this by building: • Private counters • Click limiter • Encapsulated logic using closures Closures finally felt practical instead of theoretical. 5. Mini Project — Toast Notification System Applied closures to build a reusable toaster with: • Configurable position (top/right/bottom/left) • Theme support (dark/light) • Auto-dismiss timer • Multiple stacked notifications Building something small but real made the concepts stick. Biggest takeaway: Progress is not about never stopping — it’s about starting again. Back to consistency. One day at a time. #JavaScript #LearnInPublic #WebDevelopment #CodingJourney #FrontendDevelopment #100DaysOfCode

Does your JavaScript code look like spaghetti? 🍝 Even the best coders can get tangled in a web of complexity. At Cyberdime, we've seen it firsthand. Hours piled onto hours, digging through code, trying to fix the unfixable. Believe us when we say - it doesn't have to be that way. 👉 Simplified, streamlined code isn't just a dream. It's achievable, and here's how: 1. Implement consistent style and formatting rules (ESLint is your friend). 2. Break giant functions into smaller, manageable bits. 3. Document everything. Yes, EVERYTHING. The payoff? Huge. We're talking: ⏱ 50% less time debugging 💰 Lower maintenance costs 🚀 Faster feature rollouts Simply put, your developers are happier, and your bottom line is healthier. But, taming spaghetti code is just one aspect of operations optimization. There's more to it. We're curious—What's your biggest coding struggle? Let us know in the comments. Together, we can unscramble the digital spaghetti. #OperationsOptimization #WebDevelopment #ROI #FieldService #DigitalTransformation

“My  VS Code has more character than my entire desk, and it starts with 5 must-have extensions.” Top 5 VS Code Extensions I rely on as a Full‑Stack Developer: 🥇ESLint Keeps my JavaScript and TypeScript in check. It gently nags me in real time when my code is messy, so I catch issues before they even make it to a PR. 🥈Prettier No more endless debates over formatting. I hit save, it cleans everything up, and we get back to talking about architecture or features instead of tabs vs spaces. 🥉Live Server / Live Preview Instant browser reloads make front-end experiments a breeze. Perfect for testing HTML, CSS, or JS tweaks on the fly. 🔍 GitLens Turns git history into my secret weapon. I can see who changed what, why it happened, and trace bugs, all without leaving VS Code. 🤖 AI code assistant I use AI tools like Copilot to speed up routine coding tasks like boilerplate, tests, and refactoring, while carefully reviewing everything myself to make sure it’s solid. #VSCode #WebDevelopment #FullStackDeveloper #CodingLife #FrontendDevelopment #BackendDevelopment #DevTools #CleanCode

𝗠𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗖𝗼𝗻𝘁𝗿𝗼𝗹 𝗙𝗹𝗼𝘄 𝗶𝗻 𝗝𝗮𝘃𝗮𝗦𝗰𝗿𝗶𝗽𝘁 Every decision has a path. You make choices every day. If it's raining, you take an umbrella. If it's not raining, you walk normally. This is how programming works. A program without decision-making is just a sequence of instructions. Control flow determines the order in which statements execute. It includes conditional branching, loops, and function execution. By default, JavaScript executes code top to bottom. But using control flow statements, you can: - Skip parts of code - Execute specific blocks based on conditions - Choose between multiple paths Control flow is how your program decides what to run and when. You use if, else if, and else statements to make decisions. The if statement runs a block of code only if the condition is true. The if-else statement gives you an alternative path. The else if statement helps you give multiple conditions. You can also use switch statements when comparing one variable to many exact values. The ternary operator is a shorthand for if-else. It returns a value based on the condition. Mastering control flow is foundational. It transforms JavaScript from a passive script into an intelligent decision-maker. You can use control flow to make your code react and become powerful. Source: https://lnkd.in/gm5J36X3

Clean code isn’t just about formatting—it’s about deleting the right things!. Recently came across this tool called knip, surprised by how much unused stuff was lying around—dependencies, exports, even files. Over time, projects just grow cluttered. We add things, refactor, forget to clean up. Knip basically tells you: this is dead, you can safely delete it. It reminded me that: Clean code is not about writing more code. It’s about removing the unnecessary parts. If you maintain a large codebase, this is a pretty useful tool. https://knip.dev/ PS : It also improves overall test coverage and reduce bundle size as a side effect.

I’ve decided to stop just "watching" and start "doing." Today was all about getting deep into the JavaScript fundamentals that actually make a difference in real-world projects. It’s one thing to see a tutorial, but it’s another thing to actually write the logic and see it work! Here is what my practice session looked like today: ✅ Modernizing my Code: Switched to const and let for better safety and started using Arrow Functions to keep my logic concise and readable. ✅ The Power of Clean Data: I finally grasped how Object & Array Destructuring saves so much time when pulling out specific data. No more repetitive code! ✅ The Magic of Three Dots (...): Used the Spread Operator to handle arrays and pass parameters into functions effortlessly. ✅ Object Control: Explored how to manage objects using Keys, Values, and Entries. I also learned about Object.freeze and Object.seal—essential for keeping data secure. ✅ Bug Prevention: Started using Optional Chaining (?.). This is a total game-changer for avoiding those annoying "cannot read property" errors when dealing with nested data. ✅ Smart Looping: Practiced the difference between for...in and for...of to make sure I’m always using the right tool for the job. Every line of code I write feels like I'm building a stronger bridge toward becoming a Full-Stack Developer. Consistency is the key! 🔑 #JavaScript #WebDev #CodingJourney #LearningToCode #Frontend #Programming

𝗠𝘆 𝗰𝗼𝗱𝗲 𝘄𝗮𝘀𝗻’𝘁 𝘀𝗹𝗼𝘄. 𝗜 𝗷𝘂𝘀𝘁 𝗱𝗶𝗱𝗻’𝘁 𝘂𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱 𝘁𝗵𝗲 𝗲𝘃𝗲𝗻𝘁 𝗹𝗼𝗼𝗽. For a long time, I treated JavaScript as “single-threaded, runs top to bottom.” Technically true. Practically incomplete. When async functions, Promises, and callbacks started interacting, the execution order stopped matching what I saw on the screen. The issue wasn’t syntax. It was scheduling. JavaScript doesn’t execute everything immediately. It pushes tasks into queues. Synchronous code runs first. Then the microtask queue (Promises). Then the callback queue. That ordering matters more than most tutorials explain. I once had a Promise resolve before a setTimeout, even though the timeout delay was zero. That’s when it clicked. 0ms doesn’t mean immediate. It means “after the current call stack clears.” The event loop decides the real order. Now, when debugging async issues, I don’t just read the code. I visualize: Call stack Microtasks Macrotasks Once you see execution as scheduling instead of lines on a screen, a lot of “random” behavior becomes predictable.

🔁 One of the simplest refactors that made me a better developer. I used to write a brand new function every time requirements changed. Copy. Paste. Tweak. Repeat. It worked - but it didn’t scale. At some point I started asking a different question: “What’s actually changing here?” Most of the time, it wasn’t the structure — just the operation. So instead of rewriting logic, I abstracted it. One function. Different behavior passed in when needed. (In JavaScript terms, the outer function becomes a higher-order function, and the behavior we pass in is a callback.) That shift - from hardcoding logic to designing flexibility - was where clean code started making sense to me. Once it clicks, you begin noticing it everywhere: how libraries are designed, how experienced engineers structure systems, and why good code survives changing requirements. #JavaScript #WebDevelopment #CleanCode #Programming #SoftwareEngineering

Built a reusable React data structure project under the guidance of Error Makes Clever Academy. Instead of hardcoding UI components, I structured my data using an array of objects and dynamically rendered character cards using map(). Implemented: • Unique IDs for proper rendering • Dynamic image imports • Clean title & description structure • Reusable and scalable component design This approach improves maintainability and follows real-world React development practices. Grateful for the structured guidance that helped me understand data-driven UI the right way. #ReactJS #MERNStack #FrontendDevelopment #JavaScript #ErrorMakesClever

🚀 Day 26 of JavaScript: From Static Lists to Dynamic Apps! Day26 assignment at TAP Academy was a deep dive into JavaScript events and DOM manipulation to build a functional To-Do List. 📝✨ While I used AI as a "coding partner" to explore different approaches, I made sure to manually type every line of code. It was important to me to understand exactly how the logic flow works—from capturing input to dynamically updating the UI. Key Technical Wins: Dynamic Task Counter: Implemented logic to track total tasks, using classList to change styles when the list is empty. Flexbox Layout: Mastered justify-content: space-between to create clean task rows with aligned delete buttons. Event Logic: Handled task additions and deletions while ensuring the UI stays in sync with the data. There’s something so satisfying about seeing a project come to life, one line of code at a time! 💻🔥 #TapAcademy #JavaScript #WebDevelopment #CodingJourney #Frontend #LogicFirst