Dipesh Dhirajlal’s Post

🚀 Day 11: Scope & Memory – Mastering Variable Types in Java 🧠📍 Today’s focus was on understanding where data lives in a program—a crucial step toward writing efficient and predictable code. In Java, the way a variable is declared directly impacts its scope, lifetime, and memory allocation. Here’s how I broke it down: 🔹 1. Local Variables – Temporary Workers ⏱️ • Declared inside methods • Accessible only within that method • Created when the method starts, destroyed when it ends • ⚠️ Must be initialized before use (no default values) 🔹 2. Instance Variables – Object Properties 🏠 • Declared inside a class, outside methods • Require an object to access • Each object gets its own copy • Changes in one object do NOT affect another 🔹 3. Static Variables – Shared Data 🌐 • Declared with the static keyword • Belong to the class, not objects • Accessed using the class name (no object needed) • Only one copy exists, shared across all instances 💡 Key Takeaway: Variable scope is more than just visibility—it’s about memory management and data control. Knowing where and how variables exist helps in building optimized and scalable applications. Step by step, I’m strengthening my foundation in Java and moving closer to writing production-level code. 💻 #JavaFullStack #CoreJava #CodingJourney #VariableScope #MemoryManagement #Day11 #LearningInPublic

🌊 Java Streams changed how I write code forever. Here's what 9 years taught me. When Java 8 landed, Streams felt like magic. After years of using them in production, here's the real truth: What Streams do BRILLIANTLY: ✅ Filter → map → collect pipelines = clean, readable, expressive ✅ Method references make code self-documenting ✅ Parallel streams can speed up CPU-bound tasks (with caveats) ✅ flatMap is one of the most powerful tools in functional Java What Streams do POORLY: ❌ Checked exceptions inside lambdas = ugly workarounds ❌ Parallel streams on small datasets = overhead, not gains ❌ Complex stateful operations get messy fast ❌ Stack traces become unreadable — debugging is harder My 9-year rule of thumb: Use streams when the INTENT is clear. Fall back to loops when the LOGIC is complex. Streams are about readability. Never sacrifice clarity for cleverness. Favorite advanced trick: Collectors.groupingBy() for powerful data transformations in one line. What's your favorite Java Stream operation? 👇 #Java #Java8 #Streams #FunctionalProgramming #JavaDeveloper

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

#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

🏗️ 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

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

Is your Java knowledge still stuck in 2014? ☕ Java has evolved massively from version 8 to 21. If you aren't using these modern features, you’re likely writing more boilerplate code than you need to. I’ve been diving into the "Modern Java" era, and here is a quick roadmap of the game-changers: 🔹 Java 8 (The Foundation) 1. Lambda Expressions 2. Stream API 3. Optional 🔹 Java 11 (The Cleanup) 1.New String Methods – isBlank() and repeat() are life-savers. 2.HTTP Client – Finally, a modern, native way to handle REST calls. 3.Var in Lambdas – Cleaner syntax for your functional code 🔹 Java 17 (The Architect's Favorite) 1.Records – One-line immutable data classes. No more boilerplate! 2.Sealed Classes – Take back control of your inheritance hierarchy. 3.Text Blocks – Writing SQL or JSON in Java is no longer a nightmare. 🔹 Java 21 (The Performance King) 1.Virtual Threads – High-scale concurrency with zero overhead. 2.Pattern Matching – Use switch like a pro with type-based logic. 3.Sequenced Collections – Finally, a standard way to get first() and last(). Java isn't "old"—it's faster, more concise, and more powerful than ever. If you're still on 8 or 11, it’s time to explore what 17 and 21 have to offer. #Java #SoftwareEngineering #Backend #Coding #ProgrammingTips #Java21

Recently revisited an important Java Streams concept: reduce() - one of the most elegant terminal operations for aggregation. Many developers use loops for summing or combining values, but reduce() brings a functional and expressive approach. Example: List<Integer> nums = List.of(1, 2, 3, 4); int sum = nums.stream() .reduce(0, Integer::sum); What happens internally? reduce() repeatedly combines elements: 0 + 1 = 1 1 + 2 = 3 3 + 3 = 6 6 + 4 = 10 Why it matters: ✔ Cleaner than manual loops ✔ Great for immutable / functional style code ✔ Useful for sum, max, min, product, concatenation, custom aggregation ✔ Common in backend processing pipelines Key Insight: Integer::sum is just a method reference for: (a, b) -> a + b Small concepts like this make code more readable and scalable. Still amazed how much depth Java Streams offer beyond just filter() and map(). #Java #Programming #BackendDevelopment #SpringBoot #JavaStreams #Coding #SoftwareEngineering

🚨 Can a Thread call start() twice in Java? Short answer — No. And we learned this the hard way in production. 😬 😓 The real story We had a payment retry system. When a payment failed, our code called thread.start() again on the same thread to retry. Seemed logical... until we saw IllegalThreadStateException crashing the entire service at midnight. 💀 🔍 Why does this happen? Once a thread finishes, it moves to a TERMINATED state. Java does not allow restarting a dead thread — ever. ❌ Wrong: t.start(); t.start(); → 💥 CRASH ✅ Right: Create a new Thread each time, or use ExecutorService 💡 How we fixed it Replaced raw threads with ExecutorService. Every retry = a new task submitted to the pool. No crashes. No headaches. 🧠 Remember: 🔁 Thread lifecycle → New → Runnable → Running → Terminated 🚫 Once terminated — cannot restart ✅ Always use a new Thread or ExecutorService One line of mistake. One midnight crash. One lesson for life. 🙂 Have you ever hit this bug? Drop a comment 👇 #Java #Multithreading #Threading #JavaDeveloper #BackendDevelopment #CodingTips #SoftwareEngineering

🔥 Day 12: forEach vs Stream vs Parallel Stream (Java) Another important concept for writing clean and efficient Java code 👇 🔹 1. forEach (Traditional / External Iteration) 👉 Definition: Iterates over elements one by one using loops or forEach(). ✔ Simple and easy to use ✔ Full control over iteration ✔ Runs in a single thread 🔹 2. Stream (Sequential Stream) 👉 Definition: Processes data in a pipeline (functional style) sequentially. ✔ Cleaner and more readable code ✔ Supports operations like filter(), map() ✔ Runs in a single thread 🔹 3. Parallel Stream 👉 Definition: Processes data using multiple threads simultaneously. ✔ Faster for large datasets ⚡ ✔ Uses multi-core processors ✔ Order may not be guaranteed ❗ 🔹 When to Use? ✔ forEach → simple iteration & full control ✔ Stream → clean transformations & readability ✔ Parallel Stream → large data + performance needs 💡 Pro Tip: Parallel streams are powerful — but use them carefully. Not every task benefits from parallelism. 📌 Final Thought: "Write simple with forEach, clean with Stream, fast with Parallel Stream." #Java #Streams #ParallelStream #forEach #Programming #JavaDeveloper #Coding #InterviewPrep #Day12