IntelliJ HTTp Client Generates Incorrect BigDecimal Request Body

Debugging a microservice with no errors and no logs can be frustrating. I explored this scenario and shared a structured approach to finding the root cause—from thread dumps to DB checks and timeouts. Sharing it here 👇 Would love to hear your approach. #Microservices #Debugging #BackendDevelopment #Java #SystemDesign

I used to run parallel tasks using ExecutorService… But something always felt incomplete 🤔 Yes, tasks were running concurrently… But how do you know when ALL of them are done? That’s when I discovered the combo: 👉 ExecutorService + CountDownLatch And honestly, this is where multithreading started to make real sense. ⸻ 💡 The idea is simple: • ExecutorService → runs tasks in parallel ⚡ • CountDownLatch → makes sure you wait for all of them ⏳ ⸻ 🔥 Real flow: 1. Create a thread pool using ExecutorService 2. Initialize CountDownLatch with count = number of tasks 3. Submit tasks 4. Each task calls countDown() when done 5. Main thread calls await() 👉 Boom — main thread continues only when everything is finished ✅ ⸻ 🧠 Why this matters: ✔ Clean coordination between threads ✔ No messy shared variables ✔ Perfect for parallel API calls, batch processing, etc. ⸻ Before this, I was just “running threads” Now I’m actually controlling concurrency That’s a big difference. ⸻ If you’re learning backend or system design, this combo is 🔥 Simple tools… powerful impact. Have you used this pattern in real projects? 👇 #Java #Multithreading #ExecutorService #CountDownLatch #BackendDevelopment #LearningInPublic

🚀 Day 26 – Lambda Performance: Clean Code vs High Performance Lambdas made Java expressive and concise — but not always free. As architects, we must balance readability with performance, especially in high-throughput systems. Here’s what you should know before using lambdas everywhere: 🔹 1. Lambdas Are Not Always Zero-Cost Stateless lambdas → optimized & reused Stateful lambdas → may create new objects ➡ Can impact memory & GC under heavy load. 🔹 2. Beware in Tight Loops list.forEach(x -> process(x)); ➡ Looks clean, but traditional loops can be faster in hot paths ➡ Avoid lambdas in performance-critical loops. 🔹 3. Autoboxing Overhead Stream<Integer> vs IntStream ➡ Boxing/unboxing adds CPU + memory overhead ➡ Prefer primitive streams (IntStream, LongStream). 🔹 4. Streams vs Loops – Choose Wisely Streams → readable, declarative Loops → better control & performance ➡ Use streams for clarity, loops for critical performance paths. 🔹 5. Parallel Streams Are Not Magic list.parallelStream() ➡ Works well for large, CPU-bound tasks ❌ Can degrade performance for: - Small datasets - I/O operations - Shared resources ➡ Always benchmark before using. 🔹 6. Method References Are Faster & Cleaner list.forEach(System.out::println); ➡ Slightly better readability and sometimes better optimization. 🔹 7. Avoid Complex Lambda Chains stream().filter().map().flatMap().reduce() ➡ Hard to debug ➡ Can impact performance ➡ Break into smaller steps when needed. 🔹 8. JVM Optimizations Help — But Don’t Rely Blindly JIT can optimize lambdas heavily, but: ➡ Not guaranteed in all scenarios ➡ Performance depends on usage patterns 🔥 Architect’s Takeaway Lambdas are powerful — but use them intentionally. ✔ Prefer clarity in most cases ✔ Optimize only where needed ✔ Measure before optimizing Because in real systems: 👉 Readable code wins… until performance becomes critical. 💬 Where do you draw the line between readability and performance when using lambdas? #100DaysOfJavaArchitecture #Java #Lambdas #Performance #JavaPerformance #SystemDesign #CleanCode #TechLeadership

Have you ever debugged a production issue where logs show the same error everywhere… but you still can’t figure out what actually failed? I used to make this mistake a lot — catch exception → log error → throw again Service logs Repository logs Controller logs Same exception 3–4 times. Just noise. Then I changed one simple thing: don’t log where you’re just throwing the exception. Now I follow this: Service/Repository → just throw or wrap the exception Log only once at the boundary (API / consumer) Always add context We often don’t pay much attention to logging, but it plays a crucial role when debugging a system. You need clarity on where to log, what to log, and where not to. Now instead of messy logs, I get one clear error log with full context. Debugging feels less like guessing and more like tracing a story. Less logs. Better logs. That’s the real strategy. #BackendDevelopment #Microservices #SystemDesign #Java #SpringBoot #Logging #SoftwareEngineering #CleanCode

If your class name looks like CoffeeWithMilkAndSugarAndCream… you’ve already lost. This is how most codebases slowly break: You start with one clean class. Then come “small changes”: add logging add validation add caching So you create: a few subclasses… then a few more or pile everything into if-else Now every change touches existing code. And every change risks breaking something. That’s not scaling. That’s slow decay. The Decorator Pattern fixes this in a simple way: Don’t modify the original class. Wrap it. Start with a base object → then layer behavior on top of it. Each decorator: adds one responsibility doesn’t break existing code can be combined at runtime No subclass explosion. No god classes. No fragile code. Real-world example? Java I/O does this everywhere: you wrap streams on top of streams. The real shift is this: Stop thinking inheritance. Start thinking composition. Because most “just one more feature” problems… are actually design problems. Have you ever seen a codebase collapse under too many subclasses or flags? #DesignPatterns #LowLevelDesign #SystemDesign #CleanCode #Java #SoftwareEngineering #OOP Attaching the decorator pattern diagram with a simple example.

🚀 Day 22 – Method References (Cleaner than Lambdas?) While using lambdas, I discovered a cleaner alternative: Method References --- 👉 Lambda example: list.forEach(x -> System.out.println(x)); 👉 Same using Method Reference: list.forEach(System.out::println); --- 💡 What’s happening here? 👉 Instead of writing a lambda, we directly reference an existing method --- 💡 Types of Method References: ✔ Static method ClassName::staticMethod ✔ Instance method object::instanceMethod ✔ Constructor reference ClassName::new --- ⚠️ Insight: Method references improve: ✔ Readability ✔ Code clarity ✔ Maintainability …but only when they don’t reduce understanding --- 💡 Takeaway: Use method references when they make code simpler—not just shorter #Java #BackendDevelopment #Java8 #CleanCode #LearningInPublic

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

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

What actually happens when you hit a REST API? 🤔 Let’s break it down step by step 👇 1️⃣ Client sends HTTP request 2️⃣ Request hits DispatcherServlet 3️⃣ HandlerMapping finds the correct controller 4️⃣ Controller processes request 5️⃣ Service layer applies business logic 6️⃣ Repository interacts with DB 7️⃣ Response is returned as JSON 💡 Behind the scenes: - Jackson converts Java → JSON - Spring handles dependency injection - Exception handling via @ControllerAdvice ⚡ Real benefit: Understanding this flow helps you: ✔ Debug faster ✔ Write better APIs ✔ Optimize performance Next time you call an API, remember — a lot is happening inside 🔥 Follow for more backend deep dives 🚀 #SpringBoot #Java #RestAPI #BackendDeveloper

Understanding Request Mapping in Spring Boot While working on my Spring Boot projects, I explored how request mapping plays a crucial role in handling client requests efficiently. 🔹 @RequestMapping This is a general-purpose annotation used to map HTTP requests to handler methods. It can be applied at both class and method level and supports multiple HTTP methods. 🔹 @GetMapping Specifically designed for handling HTTP GET requests. It makes the code more readable and is commonly used for fetching data from the server. 🔹 @PostMapping Used for handling HTTP POST requests. Ideal when sending data from client to server, such as form submissions or creating new records. Why use specific mappings? Using @GetMapping, @PostMapping, etc., improves code clarity and makes APIs more expressive compared to using @RequestMapping for everything. In real projects, choosing the right mapping annotation helps in building clean and maintainable REST APIs. #SpringBoot #Java #BackendDevelopment #RESTAPI #CodingJourney #LearningInPublic