LinkedList Solves Array Memory Issues

🚀 𝐍𝐞𝐰 𝐕𝐢𝐝𝐞𝐨 𝐎𝐮𝐭 — 𝐖𝐡𝐲 𝐀𝐫𝐫𝐚𝐲 𝐈𝐧𝐝𝐞𝐱 𝐒𝐭𝐚𝐫𝐭𝐬 𝐟𝐫𝐨𝐦 𝟎? (Beginner Friendly) Ever wondered why arrays in Java start from 0 instead of 1? 🤔 This is one of the most common questions beginners have — and understanding this will level up your programming fundamentals. In this video, I’ve explained the concept in a simple and practical way — not just theory, but the real reason behind it. 🎬 𝐓𝐨𝐩𝐢𝐜: Why Index Starts at 0 in Arrays 💡 𝐈𝐧 𝐭𝐡𝐢𝐬 𝐯𝐢𝐝𝐞𝐨 𝐲𝐨𝐮’𝐥𝐥 𝐥𝐞𝐚𝐫𝐧: ✅ What is an Array & what is Index ✅ Why indexing starts from 0 (core concept) ✅ Memory concept behind arrays (important 🔥) ✅ How JVM calculates element position ✅ Formula: base_address + (index * size) ✅ Why starting from 0 makes access faster 💡 I’ve explained this using a simple memory visualization: • First element → base address (index 0) • Next elements → calculated using offset • No extra calculation needed → more efficient ⚡ This helps you understand how things work internally, not just remember syntax. 📺 Watch Video 👇 https://lnkd.in/ga3iaUNN 💬 Did you know this before, or did you think arrays should start from 1? 🔁 Share this with someone learning Java — this concept clears a lot of confusion 🚀 #Java #JavaCourse #LearnJava #Programming #SoftwareEngineering #Developers #Coding #Arrays #DataStructures #CodingJourney #NVerse

𝗠𝗮𝘀𝘁𝗲𝗿𝗶𝗻𝗴 𝗝𝗮𝘃𝗮’𝘀 𝘃𝗮𝗿 Recently, I explored how Java introduced Local Variable Type Inference (var) in Java 10 and how it transformed the way developers write cleaner and more expressive code. Java has traditionally been known for its verbosity. With the introduction of var through Project Amber, the language took a major step toward modern programming practices—balancing conciseness with strong static typing. 𝗪𝗵𝗮𝘁 𝗜 𝗹𝗲𝗮𝗿𝗻𝗲𝗱: • var allows the compiler to infer types from initializers, reducing boilerplate without losing type safety. • It is not a keyword, but a reserved type name, ensuring backward compatibility. • Works only for local variables, not for fields, method parameters, or return types. • The inferred type is always static and compile-time resolved—no runtime overhead. • Powerful in handling non-denotable types, including anonymous classes and intersection types. Must be used carefully: • Avoid when the type is unclear from the initializer • Prefer when the initializer clearly reveals the type (e.g., constructors or factory methods) • Enhances readability only when the initializer clearly conveys the type. 𝗞𝗲𝘆 𝘁𝗮𝗸𝗲𝗮𝘄𝗮𝘆: var is not just about writing less code—it’s about writing clearer, more maintainable code when used correctly. The real skill lies in knowing when to use it and when not to. A special thanks to Syed Zabi Ulla sir at PW Institute of Innovation for their clear explanations and continuous guidance throughout this topic. #Java #Programming #SoftwareDevelopment #CleanCode #Java10 #Developers #LearningJourney

When I first started learning C++, I learned that data structures in the STL, like vector, stack, queue, etc., use heap memory internally. But when I wrote: vector<int> vec; …it clearly looked like it lived on the stack. No object creation or destruction was visible (coming from Java, I was used to seeing the new keyword everywhere an object is created). So where exactly was this “heap magic” happening? Turns out, the vector object itself does live on the stack when declared normally. But internally, it maintains a pointer to dynamically allocated memory on the heap where the elements are stored. When the object goes out of scope, its destructor is automatically called, and that destructor is responsible for freeing the heap memory. So the cleanup also happens kind of automatically, if we understand what’s going on under the hood. This pattern follows a design principle called RAII (Resource Acquisition Is Initialisation) (more on that in the next post). What advantage does this approach provide? • You get the performance of stack allocation • You get the flexibility of heap allocation • And you still maintain control… woww Also, in C++, we can explicitly create objects on the heap when needed. For example: • to enable runtime polymorphism • to extend the lifetime of an object beyond a specific scope I guess complete resource control wasn’t that bad after all XD. Happy Coding :) #Cpp #LearningInPublic #SoftwareDevelopment #Coding #Algorithms #Programming

Most developers are not slowed down by bad code. They are slowed down by bad thinking. Not syntax. Not framework choice. Not whether the project uses Java, Go, or Python. The real damage usually comes earlier: - no clear boundaries - too many dependencies in one request path - retries added without thinking - APIs designed around convenience instead of failure - teams optimizing for feature speed over system clarity That’s why some codebases feel heavy even before they get big. The problem is not always technical debt. Sometimes it’s decision debt. And that is much harder to fix. Debate: What does more long-term damage to software teams? A) bad code B) bad architecture C) bad product decisions D) bad debugging habits My vote: B first, C second. What’s yours? #Java #SoftwareArchitecture #Microservices #DistributedSystems #BackendEngineering

Every time I opened a new Java project in VS Code, I had to set it up from scratch. I work across multiple Java repositories. IntelliJ is my main IDE, but I use VS Code and Cursor for quick navigation and AI-first coding. Lighter. Always ready. But it doesn't pick up IntelliJ configs automatically. So every new project meant: - Mapping source folders manually - Fixing JAR paths - Setting the JDK again Same steps every time. So I tried something different. Instead of writing a script, I wrote a Markdown file. Step-by-step instructions telling the AI exactly what to do. A small snippet from the file: - Check .idea at root only (ignore subdirs) - Extract source roots from .iml files - Map them to java.project.sourcePaths Now I just type /java-vscode-setup in VS Code or Cursor Agent. The AI scans the project. Generates the correct settings.json. Confirms changes before applying them. No scripts. No extra tools. Just clear instructions. This changed how I think about automation. Instead of writing scripts to do the work, you write instructions that guide the AI to do it. Same result. Less hassle. Works across every repo. Could I have done this with a Python script? Yes. But I'm already in Claude or Cursor anyway. So I built it where I work. Still experimenting with this approach. Curious - what task have you turned into a slash command? #AI #Cursor #Claude #VSCode #DevTools

📅 Date: April 27, 2026 Day 6 of my LeetCode Journey 🚀 ✅ Problem Solved: 14. Longest Common Prefix 🧠 Approach & Smart Solution: To solve this problem, I used a highly efficient Horizontal Scanning technique. Instead of comparing characters index by index across all strings, I assumed the very first string was the common prefix. Then, I iteratively compared it with the next strings, shaving off characters from the end until a match was found. By leveraging Java's built-in startsWith() method, the logic is kept clean and readable! • Pseudo-code: Assume the first string in the array is the initial 'prefix'. Loop through the rest of the strings in the array: While the current string does not start with the 'prefix': Shorten the 'prefix' by removing its last character. If the 'prefix' becomes completely empty, return "" (no common prefix exists). Return the final 'prefix' after checking all strings. This step-by-step reduction ensures we only do as much work as absolutely necessary. ⏱️ Time Complexity: O(S) (where S is the sum of all characters in all strings) 📦 Space Complexity: O(1) (Only modifying the prefix string, no extra arrays used) 📊 Progress Update: • Streak: 5 Days 🔥 • Difficulty: Easy • Pattern: String / Horizontal Scanning 🔗 LeetCode Profile: https://lnkd.in/gBcDQwtb (@Hari312004) Smartly utilizing built-in string methods like startsWith and substring can drastically reduce code complexity! 💡 #LeetCode #DSA #Strings #Java #CodingJourney #ProblemSolving #InterviewPrep #Consistency #BackendDevelopment

Leveling up my DSA skills with Stacks! 🥞 Just finished writing a custom, array-based Stack implementation in Java. Instead of relying on built-in collections, I wanted to manually map out the exact LIFO (Last-In, First-Out) behavior from scratch. Here’s a breakdown of how I structured the code: 🔹 The Core State: Initialized a fixed-size integer array (size 6) along with a top pointer set to -1 to act as the index tracker for the current topmost element. 🔹 The push() Logic: Built to check boundaries first. If top < size - 1, it safely increments the pointer and adds the new value (array[++top] = value). If full, it catches the error and alerts that the stack is overflowing. 🔹 The pop() Logic: Verifies the stack isn't empty (top > -1), then dynamically retrieves the topmost value while decrementing the pointer (array[top--]), effectively "removing" the element. Testing edge cases is the best part. Purposefully pushing a 7th element (nums.push(22)) into my size-6 stack and seeing my custom "the stack is overflowing..." text pop up in the terminal proves the boundary validations are rock solid! Nothing beats the feeling of a bug-free terminal run! Onward to the next coding challenge. 🚀 #Java #Programming #DataStructures #Algorithms #ComputerScience #StudentDeveloper #LIFO

📘 Day 24 – Diving Deeper into Java OOP Today, I dove into Polymorphism, a core OOP principle, and explored the super keyword, an essential concept in Java 💡 ❶ Polymorphism lets methods behave differently based on context, making code more flexible, maintainable, and adaptable for future changes. ❷ super gives a child class direct access to parent constructors, methods, and variables, enabling clear constructor chaining and method reuse. 📚 Hands-On Practice: → Method Overloading (Compile-Time Polymorphism) → Method Overriding & Dynamic Method Dispatch (Run-Time Polymorphism) → Calling parent constructors/methods via super() and super.method() 💡 Why It Matters: → Polymorphism makes code adaptable to future changes → super ensures parent–child relationships are used properly Step by step, turning OOP fundamentals into real coding power! #Java #OOP #Polymorphism #SuperKeyword #CodingJourney #LearningInPublic #SoftwareEngineering

When two systems communicate over the internet, they often use different programming languages. For example: Frontend → JavaScript Backend → Python / Go / Rust / Java But these languages all have different data structures and types. So how do they actually understand each other? The answer is serialization and deserialization. In this article, I explain this concept from first principles: • How clients and servers exchange data • Why systems need a common format • What serialization and deserialization actually mean • Why JSON became the standard format for APIs • Where serialization fits in the network communication flow If you're learning backend engineering or system design, this is one of those foundational concepts that makes many other things easier to understand. 📖 Read the article: Serialization & Deserialization https://lnkd.in/g4GXncHj I’m also documenting my learning journey in these playlists: Backend Engineering from First Principles https://lnkd.in/g7MJ6TnP System Design from First Principles (HLD + LLD) https://lnkd.in/gateH6Jz #BackendEngineering #SystemDesign #APIDesign #SoftwareEngineering #WebDevelopment