"Reflection and annotations obscure the engine. Vert.x reveals the truth."

I solved LeetCode 42: Trapping Rain Water in Java, and it turned out to be one of those problems that looks straightforward at first but hides deep lessons in algorithm design and optimization. The problem asks you to calculate how much water can be trapped between bars of different heights after it rains. It sounds simple, but when you try to implement it, you realize how easily brute-force approaches break down. My initial solution used nested loops to check how much water could be trapped at every index. It worked but ran with O(n²) time complexity, which quickly became inefficient for large inputs. That is when I shifted toward precomputation. The key idea is to figure out how much water each bar can hold by knowing the tallest bar to its left and right. Once that information is known, the amount of trapped water at any position is simply the minimum of those two maximum heights minus the height of the bar itself. To make this efficient, I created two arrays: maxLeft[i] stores the tallest bar to the left of index i. maxRight[i] stores the tallest bar to the right of index i. This approach brought the time complexity down to O(n) while keeping the logic simple and elegant. This problem taught me that performance improvements often come from rethinking the way you process information. Precomputation, caching, and avoiding repetitive operations are not just algorithmic tricks. They are the same concepts that drive efficiency in backend engineering, database optimization, and system design. In many ways, this problem reflects real-world engineering. It is not about how fast you can write code, but how effectively you can anticipate what the system will need before it needs it. That mindset is what separates good developers from great ones. What is one problem that helped you truly understand the balance between simplicity and optimization? #Java #Programming #SoftwareDevelopment #ProblemSolving #Algorithms #Coding #DSA #LeetCode #Engineering #SystemDesign

A common question people ask on Spring Boot Subreddit: "I am new to Spring Boot. How to get started to learn Spring Boot?" Here are the resources that you can use 👇 1. There is no better way to learn than building an application progressively. Start with this 𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭: 𝐁𝐮𝐢𝐥𝐝 𝐔𝐑𝐋 𝐒𝐡𝐨𝐫𝐭𝐞𝐧𝐞𝐫 𝐀𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧 - 𝐂𝐨𝐦𝐩𝐥𝐞𝐭𝐞 𝐂𝐨𝐮𝐫𝐬𝐞 https://lnkd.in/g_BqQN67 2. To be able to write production-grade code, it is also very important to understand the best practices and anti-patterns. 𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 𝐑𝐄𝐒𝐓 𝐀𝐏𝐈 𝐀𝐧𝐭𝐢-𝐏𝐚𝐭𝐭𝐞𝐫𝐧𝐬 𝐚𝐧𝐝 𝐁𝐞𝐬𝐭 𝐏𝐫𝐚𝐜𝐭𝐢𝐜𝐞𝐬 https://lnkd.in/gisckF-A 3. Next, learn how to modularize your application so that it won't become big ball of mud over time. 𝐒𝐩𝐫𝐢𝐧𝐠 𝐌𝐨𝐝𝐮𝐥𝐢𝐭𝐡 𝐢𝐬 𝐜𝐫𝐞𝐚𝐭𝐞𝐝 𝐟𝐨𝐫 𝐛𝐮𝐢𝐥𝐝𝐢𝐧𝐠 𝐌𝐨𝐝𝐮𝐥𝐚𝐫 𝐌𝐨𝐧𝐨𝐥𝐢𝐭𝐡 𝐚𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧𝐬 𝐮𝐬𝐢𝐧𝐠 𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭. https://lnkd.in/gDfVbtm5 4. 𝐎𝐧𝐜𝐞 𝐲𝐨𝐮 𝐠𝐚𝐢𝐧 𝐠𝐨𝐨𝐝 𝐟𝐨𝐮𝐧𝐝𝐚𝐭𝐢𝐨𝐧 𝐰𝐢𝐭𝐡 𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭, 𝐲𝐨𝐮 𝐚𝐫𝐞 𝐫𝐞𝐚𝐝𝐲 𝐭𝐨 𝐥𝐞𝐚𝐫𝐧 𝐡𝐨𝐰 𝐭𝐨 𝐛𝐮𝐢𝐥𝐝 𝐚𝐧 𝐚𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧 𝐮𝐬𝐢𝐧𝐠 𝐌𝐢𝐜𝐫𝐨𝐬𝐞𝐫𝐯𝐢𝐜𝐞𝐬 𝐀𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞. https://lnkd.in/g3UuQAd3 5. 𝐈𝐟 𝐲𝐨𝐮 𝐚𝐫𝐞 𝐩𝐫𝐨𝐟𝐢𝐜𝐢𝐞𝐧𝐭 𝐢𝐧 𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 𝐚𝐧𝐝 𝐢𝐬 𝐢𝐧𝐭𝐞𝐫𝐞𝐬𝐭𝐞𝐝 𝐭𝐨 𝐛𝐮𝐢𝐥𝐝 𝐀𝐈-𝐏𝐨𝐰𝐞𝐫𝐞𝐝 𝐀𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧𝐬 𝐮𝐬𝐢𝐧𝐠 𝐒𝐩𝐫𝐢𝐧𝐠 𝐀𝐈: https://lnkd.in/eNdyaJdb 6. 𝐃𝐨 𝐲𝐨𝐮 𝐰𝐚𝐧𝐭 𝐭𝐨 𝐛𝐮𝐢𝐥𝐝 𝐀𝐈 𝐀𝐠𝐞𝐧𝐭𝐢𝐜 𝐖𝐨𝐫𝐤𝐟𝐥𝐨𝐰𝐬 𝐮𝐬𝐢𝐧𝐠 𝐉𝐚𝐯𝐚 𝐚𝐧𝐝 𝐒𝐩𝐫𝐢𝐧𝐠 𝐀𝐈? 𝐓𝐡𝐞𝐧 𝐲𝐨𝐮 𝐬𝐡𝐨𝐮𝐥𝐝 𝐝𝐞𝐟𝐢𝐧𝐢𝐭𝐞𝐥𝐲 𝐜𝐡𝐞𝐜𝐤𝐨𝐮𝐭 𝐄𝐦𝐛𝐚𝐛𝐞𝐥 𝐟𝐫𝐚𝐦𝐞𝐰𝐨𝐫𝐤. https://lnkd.in/e2Dmf_QZ #Java #Spring #SpringBoot #AI #SpringAI #GenAI #Embabel #SpringModulith #Microservices #BestPractices #AntiPatterns

Backend Performance isn’t just about making your backend “fast.” It’s about understanding where time and resources are being wasted. Let’s break down how high-performing backend systems stay efficient — even under heavy load. Every request that hits your backend goes through 3 bottlenecks: - Network latency – how fast data travels - Processing time – how long your code runs - I/O wait – how long you wait for the database or filesystem Optimizing performance means knowing which one is killing you. For example: If your API feels slow, most engineers jump straight into optimizing code. But often, the culprit isn’t code — it’s I/O. A single SELECT * or missing index can waste more time than 100 lines of inefficient logic. That’s why profiling matters more than guessing. Use tools like: - EXPLAIN ANALYZE for SQL queries - APMs like New Relic or Datadog - Built-in profilers (Node’s –inspect, Python’s cProfile, Go’s pprof) Don’t optimize blindly. Measure, then tune. Once you’ve found the bottleneck: - Fix I/O with caching and connection pooling - Fix CPU with async patterns and batch jobs - Fix latency with CDNs and regional deployments Each fix targets a different layer of your system. And remember — optimization has diminishing returns. Shaving 10ms off a request no one cares about isn’t engineering; it’s ego. Focus on the bottlenecks that move the needle for users. If you love diving into backend fundamentals like this — performance, scalability, caching, and system design. You’ll enjoy Backend Quizzes → https://lnkd.in/ddm5HBBK It’s a free platform to test how well you really understand backend engineering principles.

🚀 Day 34 of #100DaysOfCode – LeetCode Problem #228: Summary Ranges 🧩 Problem: Given a sorted, unique integer array nums, return the smallest list of ranges that covers all numbers in the array exactly. Each range is represented as: "a->b" if the range covers more than one number. "a" if it covers a single number. 📘 Example: Input: nums = [0,1,2,4,5,7] Output: ["0->2", "4->5", "7"] 💡 Approach: We traverse the array while tracking the start of each range. Whenever we detect a break (i.e., the next number isn’t consecutive), we close the range and store it. 🔍 Steps: Initialize start = nums[0]. Traverse the array. If the next element isn’t consecutive, push "start->current" (or "start" if equal). Move to the next starting number and continue. 💻 Java Code: class Solution { public List<String> summaryRanges(int[] nums) { List<String> result = new ArrayList<>(); if (nums.length == 0) return result; int i = 0; while (i < nums.length) { int start = nums[i]; int j = i; while (j + 1 < nums.length && nums[j + 1] == nums[j] + 1) { j++; } if (start == nums[j]) { result.add(String.valueOf(start)); } else { result.add(start + "->" + nums[j]); } i = j + 1; } return result; } } ⏱️ Complexity: Time: O(n) Space: O(1) ✅ Result: Accepted (Runtime: 3 ms) It’s a simple yet elegant problem — a great reminder that clean logic often beats complex tricks

What is a constructor? A constructor is a special method in a class used to initialize an object immediately after it is created. Its main purpose is to put the object into a valid, usable initial state by assigning values to its instance variables (fields). Key Characteristics: Name: Must be the exact same name as the class. Return Type: Has no explicit return type (not even void). Invocation: It is called automatically when you use the new keyword to create an object (e.g., new Car()) . Default Constructor ⚙️ Compiler-Generated: It is automatically provided by the Java compiler if you don't define any constructors. Signature: It is always a no-argument constructor. Removal: The compiler stops providing it the moment you write any explicit constructor (even a no-argument one). Implicit Call: It implicitly executes the superclass's no-argument constructor via super() as its first statement. Default Values: It sets all instance variables to their system-defined defaults (e.g., null, 0, false). 2. Parameterized Constructor 📝 Custom Initialization: It accepts one or more arguments to set specific initial values for an object's fields. Signature Required: It must define the types and order of its parameters in the method signature. Avoids Null/Zero: It ensures the object starts in a meaningful, valid state rather than using default values. Overloading: A class can have multiple parameterized constructors, differentiating them by their unique signatures. Mandatory Data: It can be used to enforce that certain critical data is provided upon object creation. 3. Copy Constructor 👯 Specialized Parameterized: It is a constructor that takes one argument—an object of the same class. Duplication Purpose: Its primary role is to create a brand new object with the exact same state as an existing one. Manual Implementation: Java does not provide it automatically; the programmer must explicitly define it. Field Assignment: Its body contains code that manually copies the values of the source object's fields to the new object. Shallow/Deep Copy: It must be carefully implemented to handle mutable reference fields (nested objects) to ensure a true deep copy and object independence. Anand Kumar Buddarapu

Reactive Programming Is Not a Silver Bullet. Part 2 Where reactivity is truly needed: High I/O latency and many clients External REST calls that are waiting for third-party APIs. Integrations with slow or unstable systems. WebSocket/SSE/long-lived sessions. Kafka pipelines where producers/consumers are waiting for acknowledgments or commits. Here, reactive is a must-have. End-to-end backpressure When the entire data path is reactive (e.g., Reactor → R2DBC → Postgres). The flow is controlled from the source all the way to the storage. There is no excessive load on bottlenecks. What to choose if you've decided to go reactive If you're committed, choose reactive-friendly languages and frameworks: Kotlin + coroutines (on the JVM — the most balanced solution). Node.js — a natural event loop, excellent for BFF/proxy layers. Go — a simple and cheap concurrency model. Java 21+ with virtual threads (Project Loom) — very promising, but there's still limited production experience. Conclusion Reactivity is not about "speed." It's about efficient resource utilization when you spend a lot of time waiting. If your bottleneck is the database, CPU, or memory, reactivity won't save you—it will just push the system to its limit faster. P.S. Reactivity is not for beginners A reactive stack requires not only the right technologies but also a mature engineering team. What could be worse than a slow, blocking call in a service that only has 1-5 threads? Nothing. You effectively paralyze the entire event loop: no other request can be processed until that one blocking call finishes. Reactive architecture isn't about magic; it's about discipline. If you choose non-blocking, you must ensure that everything is non-blocking—from the HTTP client down to the database driver and cache. first part: https://lnkd.in/eTGHE3Uv

Day 42 — Build Your First RAG Microservice in Java 🚀 Today, let’s turn theory into action — build a simple RAG (Retrieval-Augmented Generation) layer using Java + LangChain4j + Qdrant. 💡 RAG in one line: “Retrieve what matters → feed it to LLM → get context-aware answers.” 🧩 Tech Stack • LangChain4j → Connect Java to AI models • Qdrant → Vector DB for semantic search • Spring Boot → REST microservice • LLM → OpenAI / Ollama 🧱 Core Logic (Simplified) List<Document> docs = vectorStore.findRelevant(query, 3); String context = docs.stream().map(Document::text).collect(Collectors.joining("\n")); String answer = llm.generate("Use this context:\n" + context + "\nQ: " + query); That’s it — a Java method that retrieves + reasons + responds 💬 ⚡ Mini Example Ask: “What is LangChain4j used for?” 👉 Response: “LangChain4j helps Java developers integrate AI, embeddings, and vector stores to build intelligent apps.” 🧭 Why This Matters With RAG, you can: ✅ Build AI search copilots ✅ Create contextual chatbots ✅ Avoid retraining large models 💬 “RAG gives your AI memory — it recalls context when it matters.” Follow along — tomorrow we’ll combine this RAG layer with a fine-tuned model for hybrid, adaptive intelligence

🚀 Day 31 of #100DaysOfCode – LeetCode Problem #704: Binary Search 🧩 Problem: Given a sorted array and a target value, find the index of the target using an algorithm with O(log n) time complexity. If the target doesn’t exist, return -1. 💡 Approach: This is a classic Binary Search problem. We use two pointers (i and j) to represent the current search range. Calculate the middle index mid. If nums[mid] equals the target → return mid. If target > nums[mid] → search the right half. Else → search the left half. Repeat until the range is empty. 💻 Java Code: class Solution { public int search(int[] nums, int target) { int i = 0, j = nums.length - 1; while (i <= j) { int mid_i = i + (j - i) / 2; int mid_val = nums[mid_i]; if (target < mid_val) { j = mid_i - 1; } else if (target > mid_val) { i = mid_i + 1; } else { return mid_i; } } return -1; } } ⏱️ Complexity: Time: O(log n) Space: O(1) ✅ Result: Accepted (Runtime: 0 ms) Binary Search — simple, efficient, and one of the most fundamental algorithms every developer must master.