Ekta Sahu’s Post

I was debugging a backend issue recently in a Java service. At first nothing looked wrong. No errors, no obvious problems. But something was off. After checking a bit more, it turned out to be a small mismatch between the data model and the repository. The code worked fine in most cases, but not with certain data. Fixing it was simple. Finding it was not. Sometimes the problem is not complex. It’s just hidden in small details. #Java #BackendEngineering #Debugging #SpringBoot

Let’s break the code step by step: int x = 4; int y = 11; x += y >> 1; System.out.println(x); 🔹 Step 1 — Understand the operator precedence In Java, the right-shift operator >> has higher precedence than the compound assignment +=. So this line: x += y >> 1; is evaluated as: x = x + (y >> 1); 🔹 Step 2 — Evaluate the shift operation y >> 1 Right shift means: divide by 2 (for positive integers). 11 in binary = 00001011 Right shift 1 = 00000101 That equals 5. 🔹 Step 3 — Add to x Copy code x = 4 + 5 x = 9 🔹 Step 4 — Print System.out.println(x); // 9 🧠 ✅ Correct Answer: B) 9 #Java #SpringBoot #FullStackDeveloper

🏗️ I built a distributed file system in Java. Six weeks ago I barely knew what a thread-safe map was. Today I shipped a distributed file system in Java. From scratch. HealFS splits files into 64MB chunks, distributes them across DataNodes, and coordinates everything through a Master — all over raw HTTP. No frameworks. No shortcuts. But the real story is what broke along the way... 🐛 Bug #1: I stored "dn-1" as a node address. DFSClient dutifully tried to connect to http://dn-1 and got nothing. Fixed it to store "localhost:9001" — the actual address. One word. Thirty minutes of confusion. 🐛 Bug #2: I cast a long to an int for chunk size. Works fine. Until a file exceeds 2.1GB and the cast silently wraps to a negative number. Swapped to Math.toIntExact() — it throws instead of lying. Two bugs. Both invisible until they weren't. Both taught me more than any tutorial. What's next? Phase 2 — consistent hashing, gRPC, and replication across 3 nodes. The self-healing part starts soon. Building in public. Learning Java the hard way. 🚀 #Java #DistributedSystems #BuildInPublic #LearningInPublic #SystemDesign #Backend

🚀 LeetCode #71 – Simplify Path | Java Solution Today I tackled a medium-level problem that beautifully combines string parsing + stack logic 💡 📌 Problem Summary Given a Unix-style file path, simplify it into its canonical form. 👉 Rules include: "." → current directory (ignore) ".." → go to parent directory Multiple slashes "//" → treated as one Result must be a clean, valid path 💡 Approach I Used Split the path using / Use a stack to process directories: Ignore "" and "." Pop when encountering ".." (go back) Push valid directory names Build final path from stack 💻 Java Code Snippet for (int i = 0; i < n; ) { while (i < n && p[i] == '/') i++; if (i == n) break; int start = i; while (i < n && p[i] != '/') i++; int len = i - start; // logic to handle ".", "..", and valid names } 🧠 Key Learning Real-world use of Stacks in path resolution Careful handling of edge cases Efficient string traversal without extra space 📊 Example Input: "/home//foo/../bar/" Output: "/home/bar" Happy Coding 😊 #LeetCode #Java #DSA #Stack #ProblemSolving #CodingJourney #100DaysOfCode #Algorithms

#Post11 In the previous post(https://lnkd.in/dynAvNrN), we saw how to create threads in Java. Now let’s talk about a problem. If creating threads is so simple… why don’t we just create a new thread every time we need one? Let’s say we are building a backend system. For every incoming request/task, we create a new thread: new Thread(() -> { // process request }).start(); This looks simple. But this approach breaks very quickly in real systems because of below mentioned problems. Problem 1: Thread creation is expensive Creating a thread is not just creating an object. It involves: • Allocating memory (stack) • Registering with OS • Scheduling overhead Creating thousands of threads = performance degradation Problem 2: Too many threads → too much context switching We already saw this earlier(https://lnkd.in/dYG3v-vb). More threads does NOT mean more performance. Instead: • CPU spends more time switching • Less time doing actual work Problem 3: No control over thread lifecycle When you create threads manually: • No limit on number of threads • No reuse • Hard to manage failures This quickly becomes difficult to manage as the system grows. So what’s the solution? Instead of creating threads manually: we use something called the Executor Framework. In simple words consider the framework to be like: Earlier, we were manually hiring a worker (thread) for every task. With Executor, we have a team of workers (thread pool), and we just assign tasks to them. Key idea Instead of: Creating a new thread for every task We do: Submit tasks to a pool of reusable threads This is exactly what Java provides using: Executor Framework Key takeaway Manual thread creation works for learning, but does not scale in real-world systems. Thread pools help: • Control number of threads • Reduce overhead • Improve performance We no longer manage threads directly — we delegate that responsibility to the Executor Framework. In the next post, we’ll see how Executor Framework works and how to use it in Java. #Java #Multithreading #Concurrency #BackendDevelopment #SoftwareEngineering

Something small… but it changed how I think about Java performance. We often assume `substring()` is cheap. Just a slice of the original string… right? That was true **once**. 👉 In older Java versions, `substring()` shared the same internal char array. Fast… but risky — a tiny substring could keep a huge string alive in memory. 👉 In modern Java, things changed. `substring()` now creates a **new String with its own memory**. Same value ❌ Same reference ❌ Safer memory ✅ And this is where the real learning hit me: **Understanding behavior > memorizing APIs** Because in a real system: * Frequent substring operations = more objects * More objects = more GC pressure * More GC = performance impact So the question is not: “Do I know substring?” But: “Do I know what it costs at runtime?” That shift — from syntax to system thinking — is where growth actually starts. #Java #BackendEngineering #Performance #JVM #LearningJourney

Still confused about how Java actually runs your code? 🤔 Here’s a simple breakdown of how the JVM works 👇 👉 1. Build Phase ✔️ Java code (.java) is compiled using javac ✔️ Converted into bytecode (.class files) 👉 2. Class Loading ✔️ JVM loads classes using: Bootstrap Class Loader Platform Class Loader System Class Loader 👉 3. Linking ✔️ Verify → Prepare → Resolve ✔️ Ensures code is safe and ready to run 👉 4. Initialization ✔️ Static variables & blocks are initialized 👉 5. Runtime Data Areas ✔️ Method Area & Heap (shared) ✔️ Stack, PC Register, Native Stack (per thread) 👉 6. Execution Engine ✔️ Interpreter executes bytecode line by line ✔️ JIT Compiler converts hot code into machine code for speed 👉 7. Native Interface (JNI) ✔️ Interacts with native libraries when needed 💡 JVM is the reason behind Java’s “Write Once, Run Anywhere” power. 📌 Save this post 🔁 Repost to help others 👨💻 Follow Abhishek Sharma for more such content #Java #JVM #SystemDesign #BackendDevelopment #SoftwareEngineer #Developers #TechJobs #Programming #LearnJava

While working on backend systems, I revisited some features from Java 17… and honestly, they make code much cleaner. One feature I find really useful is Records. 👉 Earlier: We used to write a lot of boilerplate just to create a simple data class. Getters Constructors toString(), equals(), hashCode() ✅ With Java 17 — Records: You can define a data class in one line: public record User(String name, int age) {} That’s it. Java automatically provides: ✔️ Constructor ✔️ Getters ✔️ equals() & hashCode() ✔️ toString() 💡 Practical usage: User user = new User("Dipesh", 25); System.out.println(user.name()); // Dipesh System.out.println(user.age()); // 25 🧠 Where this helps: DTOs in APIs Response objects Immutable data models What I like most is how it reduces boilerplate and keeps the code focused. Would love to know — are you using records in your projects? #Java #Java17 #Backend #SoftwareEngineering #Programming #Microservices #LearningInPublic

📈 Does Java really use too much memory? It’s a common myth but modern Java tells a different story. With improvements like: ✔️ Low-latency garbage collectors (ZGC, Shenandoah) ✔️ Lightweight virtual threads (Project Loom) ✔️ Compact object headers (JEP 450) ✔️ Container-aware JVM & Class Data Sharing Java today is far more memory efficient, scalable and optimized than before. 💡 The real issue often isn’t Java it’s: • Unbounded caches • Poor object design • Memory leaks • Holding unnecessary references 👉 In short: Java isn’t memory hungry it’s memory aware. If your app is consuming too much RAM, start profiling your code before blaming the JVM. #Java #BackendDevelopment #Performance #JVM #SoftwareEngineering

💡 Ever wondered what really happens inside a HashMap in Java? It’s not just key → value storage… it’s a smart combination of hashing + indexing + collision handling working in milliseconds. Here’s the magic 👇 🔹 When you put a key, Java computes its hashCode() 🔹 That hash is converted into an index in an array (bucket) 🔹 If multiple keys land in the same bucket (collision), Java handles it using: → Linked List (before Java 8) → Balanced Tree (after Java 8, when threshold is crossed) ⚡ Result? Average time complexity stays O(1) for get() and put(). 💥 But here’s the catch… Poor hashCode() implementation = more collisions = slower performance. 🚀 Quick Tip: Always override equals() and hashCode() together when using custom objects as keys. This ensures correct retrieval and avoids hidden bugs. HashMap looks simple from outside… but inside, it’s a finely optimized system. #Java #DataStructures #SystemDesign #BackendDevelopment #CodingTips