How JNI performance was improved with QuestDB

I’ve created 1MRC (Million Request Challenge) think of it as an extension of Gunnar Morling's 1BRC challenge. Instead of processing rows 1MRC focuses on handling web requests using servers written in different languages primarily Java, Go, and Rust, with C, C++, and Java 25 implementations coming soon. It covers optimizations, connection pooling, virtual threads, JVM tuning, and how file descriptor limits affect Java’s performance. It also explores Go’s concurrency model and why it outperforms Java in raw throughput, along with comparisons across different HTTP server implementations. This started as an exploration and I thought of sharing it here so others can benefit. A detailed blog series capturing the learnings has been written and will be published soon. From initial runs: Go was nearly 5x faster than Java 11 out of the box. But with tuning and virtual threads, Java closed the gap to 3x, showing promising improvements. If you're into low-level performance tuning, language internals, or just love pushing systems to their limits this one's for you. Check it out experiment and feel free to contribute or share your own findings! https://lnkd.in/gehj5niz

Modern LLMs like Claude Sonnet 4.5 or GPT-5 still hit real limits translating monolithic mainframe systems to modern Java stacks. Mainframe code is vast, complex, and tightly coupled … making it challenging for even the best models to generate reliable, maintainable Java. Over the last years, deriving knowledge graphs from legacy code proved critical. But the trick isn’t just mapping everything: The power comes from organizing the graph into small, loosely connected “nests” … not one tangled mass. Fragmented knowledge graphs provide context LLMs need for focused, accurate reengineering. Peer discussion welcome … DM or comment to connect. #llm #knowledgegraph #mainframe #reengineering #Java

Java applications generate a lot of useful performance data through JMX. The question is, how do you bring that data into your observability stack? In this blog, Alex Boten walks through how to connect JMX with OpenTelemetry so you can see your Java metrics alongside the rest of your telemetry data. Read more here: https://lnkd.in/gEikv7Zf #honeycomb #observability

Day 43 – 100 Days of DSA Problem: = Reverse Nodes in k-Group Concept: Reverse the nodes of a linked list in groups of size k. If the remaining nodes are fewer than k, they remain unchanged. Approach: Count the total nodes to ensure there are at least k nodes in a group. Use pointer manipulation (pre, cur, nex) to reverse each group in place. Repeat until the end of the list is reached. Time Complexity: O(n) – each node is processed once Space Complexity: O(1) – in-place reversal #100DaysOfDSA #LeetCode #ProblemSolving #DSA #Java

🌟 GFG 160 Days of Code – Day 9 (#160DaysOfCode) 🌟 Today’s challenge: Minimize the Heights II 🔝🏢 Problem: Given an array of tower heights and an integer k, you must either increase or decrease each tower by k exactly once. The goal is to minimize the difference between the tallest and shortest tower after modifications. Example: Input: arr = [1, 5, 8, 10], k = 2 Output: 5 Explanation: Modified array = [3, 3, 6, 8], difference = 8 - 3 = 5 Approach in Java: 1️⃣ Sort the array 2️⃣ Compute the initial difference 3️⃣ Try splitting the array at each index i: Left part → increase by k Right part → decrease by k 4️⃣ Compute new high (tallest) and low (shortest) 5️⃣ Update the minimum difference

🚀 Day 71 — K Largest Elements (71/100) 🧩 Problem: Given an array of $n$ positive integers and an integer $k$, find the $k$ largest elements from the array. ⚙️ Approach: Used a Min-Heap (implemented via PriorityQueue in Java). Iterated through the array: Added the current element to the min-heap. If the heap's size grew larger than k, removed the smallest element (the root) using poll(). This ensures the heap always holds the k largest elements seen so far. Finally, extracted the elements from the heap to form the result. ⏱️ Time Complexity: $O(n \log k)$ 💾 Space Complexity: O(k) ✅ Result: Passed all 1111 test cases with 100% accuracy. Total Score: 135 🎯

✨ LeetCode 933 – Number of Recent Calls Today I explored an interesting problem involving queues and time-based logic. In this problem, we need to design a system that counts the number of requests received in the last 3000 milliseconds. Every time a new request ping(t) arrives, we must return how many previous requests fall within the range [t - 3000, t]. To solve this, I used a Queue-based Sliding Window approach. Each time a new request comes in, I add it to the queue and remove all timestamps that are older than t - 3000. The remaining elements in the queue represent all recent requests — and their count gives the answer instantly. Time Complexity: O(1) average Space Complexity: O(N) This problem beautifully demonstrates how queues can efficiently handle time-window-based counting — a common pattern in real-world systems like rate limiting and logging. ⚡ #LeetCode #Java #DSA #ProblemSolving #SlidingWindow #Queues #CodingJourney #LearningEveryday