Cracking the Logic: Finding the First Occurrence! I’ve always believed that the best way to master a programming language is by building your own logic from scratch before jumping into built-in methods. Today, I worked on a classic problem: Finding the starting index of a substring within a string. The Task: Given two strings, identify the index where the second string first appears in the first one. For example: Input: ("sadbutsad", "sad") ➔ Output: 0 My Approach: Array Transformation: Split the strings into arrays to iterate through each character. Filtering Logic: Used the .filter() method to check if the main string's characters exist in the target substring using .includes(). Index Tracking: Pushed the matching indices into a temporary array. Result Extraction: Sliced the first element to get the exact starting point. The Code: JavaScript function findIdStr(a, b) { const repetArrId = [] const y = a.split('') const x = b.split('') y.filter((v, idx) => { if (x.includes(v)) { repetArrId.push(idx) } }) const result = repetArrId.slice(0, 1) console.log("Starting Index:", result[0]) } findIdStr("sadbutsad", "sad") // Output: 0 While JavaScript offers built-in tools like .indexOf(), breaking it down manually helps in understanding how data flows and how loops work under the hood. I’m curious—how would you optimize this logic? Let’s discuss in the comments! #JavaScript #WebDevelopment #ProblemSolving #CodingJourney #SoftwareEngineering #LogicBuilding #JSIndex

Today was one of those days where things finally clicked While working on one of my ongoing projects, I built a VS Code–like File Explorer from scratch in React — and it turned out to be a great learning experience. Here’s what I explored 🔹 Built a recursive tree structure to handle nested folders & files 🔹 Understood how recursion actually works in real UI problems 🔹 Implemented core features: → Create file / folder → Delete (with full nested structure) → Dynamic rendering 🔹 Learned an important pattern: 🔹filter + map + recursion = tree operations 🔹 Got deeper clarity on handling nested data: → Managing deeply nested state → Updating tree efficiently → Thinking recursively instead of flat logic Biggest takeaway: If you truly understand recursion, you can solve complex UI problems much more cleanly. Building real features inside projects hits very different than just watching tutorials #React #FrontendDevelopment #WebDevelopment #LearningInPublic #JavaScript #BuildInPublic

🚀 Excited to share my project: Book Collection Tracker 📚 A Flask-based web application designed to help users manage their personal book collections a smooth user experience. 🔐 Key Features: • Add, update, delete, and manage books • Quick search functionality 🔍 • Responsive and modern UI 🎨 • Deployment-ready setup ⚡ 🛠️ Tech Stack: • Backend: Python, Flask • Frontend: HTML, CSS, JavaScript • Database: MySQL • Deployment: Render, GitHub 📂 This project focuses on building a real-world, scalable application with clean structure and deployment support. 🌐 Live Demo: https://lnkd.in/gbaMWdWZ 💻 GitHub Repository: https://lnkd.in/gYa5tWt4 🎯 I built this project to strengthen my full-stack development skills and gain hands-on experience with Flask-based applications. I’d love to hear your feedback and suggestions! 😊 #Python #Flask #WebDevelopment #FullStackDeveloper #PythonFullStack #Projects #SoftwareDevelopment #Coding #GitHub #LearningJourney

hi connections Day 29 of 30: Unlocking Type Coercion with LeetCode 2695 🚀 Today’s challenge, Array Wrapper, was a fascinating dive into the "behind-the-scenes" mechanics of JavaScript objects. It’s all about how the engine handles Type Coercion—the process of converting an object into a primitive value (like a number or string). The Concept Usually, when you try to add two objects together in JavaScript, you get a messy string result like "[object Object][object Object]". However, by using a Class and overriding specific prototype methods, we can change that behavior entirely. What I Implemented: valueOf (The Math Hook): I implemented this method to return the sum of the array. Now, when I use the addition operator (obj1 + obj2), JavaScript automatically calls valueOf and sums the numbers instead of merging strings. toString (The Display Hook): I overrode this to return a formatted string (e.g., "[1,2,3]"). This ensures that when the object is logged or converted to a string, it remains readable and useful. Why This Matters for Developers In a MERN stack environment, we often build custom classes or data models. Understanding coercion allows us to: ✅ Create more intuitive data structures. ✅ Simplify debugging by providing clear string representations of objects. ✅ Write cleaner code by allowing objects to interact naturally with mathematical operators. Only 1 day left! Tomorrow marks the completion of this 30-day coding sprint. The consistency has been the greatest reward. 💻✨ #JavaScript #LeetCode

This simple HTML app has a drag-and-drop canvas, 20+ text effects, 3D extrusion, and perspective transforms for your 'text behind image'. 😎 Crazy part: The ML backend is ~50 lines of Python Built with gradio.Server ➡️ bring any frontend you want! 😎 Built with gradio.Server — bring any frontend you want 👍 Gradio handles queuing, high performance, scaling, ZeroGPU, and the API end-points Full blog post + play with the live app on Hugging Face: https://lnkd.in/g9FEVsha

🚀 For...Of Loop — which many developers don’t know! Most developers use for or forEach()… but often overlook one of the cleanest loops in JavaScript 👇 🔹 for Loop (Traditional) ✔ Full control (index, conditions, steps) ✔ Best for complex logic 🔹 for...of Loop (Often Overlooked ⭐) ✔ Direct access to values ✔ Cleaner & more readable ✔ Works with arrays, strings, maps, sets 🔹 forEach() Loop ✔ Simple & functional style ✔ Great for quick operations ⚠️ Cannot use break or continue 💡 Quick Tip: Need control? → for Need clean value iteration? → for...of Need simple function execution? → forEach() 🔥 Start using for...of more — it makes your code cleaner and easier to read! #JavaScript #WebDevelopment #Coding #Frontend #Programming #Developers #LearnToCode

🚀 Day 6/7 — Building a Decision-Based Game Engine with Django As part of my 7-day Django challenge, I wanted to build something beyond typical CRUD apps — something that focuses on system design and backend logic. So I built a Decision Maze / Story Engine 👇 🎮 What it does: • Each scenario is a node • Each choice leads to another node • Different decisions → different paths → different endings 🧠 Key Features: ✔ Graph-based architecture (node → choice → node) ✔ Player progress tracking (stateful system) ✔ RPG elements (health, inventory, damage) ✔ Admin-powered story creation ✔ Typing animation & dynamic backgrounds ✔ Sound effects & smooth transitions ✔ 🗺️ Interactive graph map visualization 💡 What I learned: • Designing self-referencing models in Django • Managing user state & progression • Building backend systems like a game engine • Visualizing relational data as a graph This project really helped me shift from building “apps” to building systems. GITHUB => https://lnkd.in/gSgnUVs9 👉 Day 7 coming next — going even more advanced 💪 Would love feedback or suggestions! 🙌 #Django #Python #BackendDevelopment #WebDevelopment #Projects #LearningInPublic #100DaysOfCode #FullStack #ComputerScience

I was tired of copying long, ugly links… So I built my own URL shortener — SnapURL. Not just a backend. A real product. With UI. With logic. With actual users in mind. In the last few days, I stopped consuming tutorials…and started building. This is what came out of it is, 🔗 SnapURL using FastAPI. -------------------------------- Where you can: • Paste any link • Instantly get a short URL • Copy it • Open it • And it just works. -------------------------------- But here’s what this project actually taught me: Building is not about writing code. It’s about: • Debugging errors for hours • Fixing things that don’t make sense • Connecting frontend + backend • And still making it feel simple to the user This is just Version 1. Next → deploying it live. GITHUB LINK: https://lnkd.in/gH8JFzMc If you’re learning development… Stop watching. Start building. #buildinpublic #fastapi #python #webdevelopment #studentdeveloper

Stop Guessing, Start Coding: The 3 Levels of JavaScript Functions Most of us start by writing functions to solve a single task. However, to build scalable systems, we must begin thinking like architects. In my latest blog, I break down the Function Evolution using real-world analogies: - The Vending Machine (Basics): Input data, get a result. This is where we all start—building reliable, saved logic. - The Professional Kitchen (Scope): Why the "Chef" (Function) can see the dining room, but the "Customer" (Global Scope) can’t see the secret spices. - The Manager Machine (HOF): Moving from manual labor to orchestration. This is how you build modular, "Boss Level" code. The Shift: It’s the journey from writing code that just "works" to architecting logic that is private, predictable and clean. Full guide to mastering the JS Engine below! https://lnkd.in/dMsHZA5j #JavaScript #CleanCode #SoftwareEngineering #CareerGrowth

LeetCode Day 19 : Problem 167 (Two Sum II - Input Array Is Sorted) Just solved my LeetCode problem for today. It was "Two Sum II", sorted array, constant space, find two numbers that add up to a target. Sounds like a simple two-pointer problem, right? But here's what I actually learned: My first instinct was to write three separate while loops, each moving a different pointer in a different direction, thinking I was covering all the cases. I wasn't. The bugs were layered. The first loop only moved the right pointer. The second only moved the left. The third moved both but only toward the center. No single loop ever explored the full space of valid pairs. There was also a check I wrote: if (arr !== undefined) return arr. Looked like a guard. Did absolutely nothing. An empty array is never undefined in JavaScript. The condition was always true and I never noticed. The real fix wasn't patching the loops. It was understanding why the sorted order makes three loops completely unnecessary. The two-pointer solution: start left at index 0, right at the last index. If the sum is too small, move left forward. If the sum is too big, move right backward. One loop, every pair covered, O(n) time, O(1) space. The sorted order is the key insight. It guarantees you never need to backtrack, which is exactly why one clean loop beats three broken ones. The real lesson? When your instinct is to add more loops to cover more cases, stop. Ask whether the structure of the data already tells you which direction to move. Sometimes the constraint in the problem is the solution. #DSA #LeetCode #JavaScript #CodingJourney #Programming