Building a Custom Database Engine with C++ and Spring Boot

My colleague Laura Trotta released a new ES|QL plugin for JetBrains IDEs! If you're writing raw ES|QL queries in your code, this plugin gives you: 🔹 Autocomplete for commands, functions, and field names 🔹 Real-time syntax checking with clear error messages 🔹 Inline documentation on hover 🔹 The ability to run queries and see results directly in your IDE 🔹 Connection to your Elasticsearch instance for index and field discovery The plugin is it's built on the ES|QL ANTLR grammar, so it's fast and predictable. While the blog post focuses on IntelliJ IDEA with Java and Kotlin examples, this works in Rider (.NET) too. It's still experimental, so give it a spin and share your feedback on the GitHub repo! 📦 JetBrains Marketplace: https://lnkd.in/ddBRgPum 👉 https://lnkd.in/dnDu58BQ If you are a .NET developer, also make sure to check out the LINQ to ES|QL provider if you prefer a "EntityFramework style" DSL: 👉 https://lnkd.in/dgFzs6CD #Elasticsearch #ESQL #JetBrains #IntelliJ #Rider #DotNet #Java #Kotlin #DeveloperTools #Elastic

The AWS Lambda Durable Execution SDK for Java is now GA and durable-viz v0.2.0 is ready for it! durable-viz turns your durable function handler code into a flowchart using static analysis. No deployment or execution needed. It now has full support for all Java SDK primitives, including parallel branch extraction from the new builder API. Supports TypeScript, Python, and Java. Try it: npx durable-viz your-handler.java --open npm: https://lnkd.in/d_jDXr6r VS Code: https://lnkd.in/daJgMMAu GitHub: https://lnkd.in/dEnUkYPu #AWS #Lambda #DurableFunctions #Java #Serverless #OpenSource

Most used Spring Boot annotations (that you’ll see almost everywhere) If you’ve worked with Spring, you already know… half the magic is in annotations 😅 Here are some of the ones I keep using almost daily: * @SpringBootApplication → starting point of the app * @RestController → tells Spring this class handles APIs * @RequestMapping / @GetMapping / @PostMapping → for routing requests * @Autowired → dependency injection (used a lot, sometimes too much 👀) * @Service → business logic layer * @Repository → database layer * @Component → generic bean * @Entity → maps class to DB table * @Id → primary key * @Configuration → for config classes * @Bean → manually define beans when needed When I started, I used to just memorize these. Over time, I realised understanding when NOT to use them is equally important. Like: * overusing @Autowired everywhere * mixing @Component, @Service randomly * not understanding bean lifecycle Spring feels simple at start, but there’s a lot going under the hood. If you’re learning Spring right now → focus less on remembering, more on understanding what each annotation actually does. Which Spring annotation do you use the most? 👇 #ThoughtForTheDay #SpringBoot #Java #Backend #SoftwareEngineering

@PathVariable vs @RequestParam – Passing URL Data While working on my Spring Boot projects, I explored how to pass data through URLs using @PathVariable and @RequestParam, and how both are used in different scenarios. 🔹 @PathVariable Used to get values directly from the URL path. It is mostly used when the value is required and represents a specific resource. Example: /users/101 → here 101 is taken as path variable 🔹 @RequestParam Used to get values from query parameters in the URL. It is commonly used for optional data like filters, search, or pagination. Example: /users?name=Rahul → here name is a request parameter Why use both? Using @PathVariable and @RequestParam properly makes APIs more clear and meaningful. @PathVariable → for identifying resources @RequestParam → for filtering or optional inputs In real projects, understanding this difference helps in designing clean and scalable REST APIs. #SpringBoot #Java #BackendDevelopment #RESTAPI #CodingJourney #LearningInPublic

Spring Data Interview Question : Efficient Keyset Pagination with Spring Data WindowIterator Scenario You’re building a Spring Boot API to fetch comments for a post. The table has tens of millions of rows, and users can scroll deeply into the history. Initial Implementation is attached. Problem Observed in Production As users scroll deeper: - Queries slow down dramatically - DB CPU rises - Response times become inconsistent Why offset pagination is inefficient? Checkout detailed questions and answers : https://lnkd.in/ePcwy9tJ Subscribe and join 6.5k java and spring boot devs https://lnkd.in/gwiRqWBV #java #spring #springboot

Did you know Spring Data JPA can generate SQL queries just from method names? 😳 In this video, I explain how this method: findFirstByStatusOrderByTokenNumberAsc() automatically generates: SELECT * FROM token_queue  WHERE status = 'WAITING'  ORDER BY token_number ASC  LIMIT 1; This is used to fetch the next available token in a queue system. Full explanation available in TamilKadal YouTube channel   Link in the first comments section #SpringBoot #Java #JPA #Hibernate #BackendDevelopment #Programming #Coding #Developer #SoftwareEngineering #Tech #JavaDeveloper #LearnCoding

We've been building something quietly for a while, and I'm ready to share it. OpenTaint is an open-source taint analysis engine with the most thorough Spring Boot support. https://lnkd.in/darQ5ZRN Not "Java support." Actual modeling of how Spring works. Spring Boot's annotation-driven architecture creates data flows that are invisible to conventional static analysis. A bean injection crosses class boundaries with no call site in the source. JPA persistence links two HTTP endpoints through the database with no shared code path. A Freemarker configuration object determines whether user input reaching template.process() is exploitable — or harmless. These are not edge cases. This is the default architecture of most Java web applications. OpenTaint traces tainted data through every layer: - Following data across file and class boundaries — through DTO field access and method chains. - Resolving configuration-aware sinks — tracing through DI to determine whether a resolver or handler is actually exploitable. - Connecting endpoints through persistence — where the database or service state is the only link. - Distinguishing dangerous fields from safe ones — at per-column granularity within those flows. The engine operates on bytecode, resolves virtual dispatch, and maps every finding back to its HTTP endpoint. If you're using Semgrep or CodeQL on your Java/Kotlin/Spring codebase — try OpenTaint on the same project and compare what it finds. We've published reproducible comparisons on the blog, but seeing it on your own code is more convincing. Apache 2.0 + MIT. Engine, rules, CLI, GitHub Action, GitLab CI — everything is open source. #java #kotlin #spring #springboot #security #appsec #opensource #sast #taintanalysis

Testcontainers + MockMvc Most developers test their database code against an in-memory database. It's fast, it's easy to set up, and it lies to you. Your production app runs on PostgreSQL. Your tests run on H2, which has a different engine, different behavior, and different edge cases. You can have 100% passing tests and still ship a bug that only exists in production. So I made a different choice. My integration tests spin up a real PostgreSQL container via Testcontainers, run every assertion, then tear it down. My end-to-end tests go one step further using MockMvc to fire real HTTP requests through the full Spring stack, hitting the actual controller, service, repository, and database. No shortcuts at any layer. No mocks. No surprises in production. Testcontainers (testcontainers.com) makes this easy; it supports Java, Go, Python, .NET, and has native integration with Spring Boot 3+. Not the easiest path. The correct one. --- 💬 Do you test against a real database or an in-memory one? Drop it in the comments. 🔗 Full project: https://lnkd.in/dse3hHTV 🔗 Testcontainers: https://testcontainers.com #Java #SpringBoot #Testing #BackendDevelopment #SoftwareEngineering

🚀 Week 1 Progress Report Focused on building strong fundamentals across multiple areas: 💡 DSA: Arrays, Recursion, started Dynamic Programming 💻 Full Stack: Started React, Spring Boot CRUD APIs completed ☕ Java: Strengthening core concepts ⚙️ System Design: Basics + URL Shortener project 🧠 Aptitude: Clock & Calendar, Time & Work 🗄️ DBMS: SQL (DDL, DML), CRUD operations, Joins 📈 Consistency > intensity. Building step by step. #DSA #FullStack #Java #SpringBoot #React #SQL #SystemDesign #LearningJourney

Day 95 of #365DaysOfLeetCode Challenge Today’s problem: **Path Sum III (LeetCode 437)** This one looks like a typical tree problem… but the optimal solution introduces a powerful concept: **Prefix Sum + HashMap in Trees** 💡 **Core Idea:** Instead of checking every possible path (which would be slow), we track **running sums** as we traverse the tree. 👉 If at any point: `currentSum - targetSum` exists in our map → we’ve found a valid path! 📌 **Approach:** * Use DFS to traverse the tree * Maintain a running `currSum` * Store prefix sums in a HashMap * Check how many times `(currSum - targetSum)` has appeared * Backtrack to maintain correct state ⚡ **Time Complexity:** O(n) ⚡ **Space Complexity:** O(n) **What I learned today:** Prefix Sum isn’t just for arrays — it can be **beautifully extended to trees**. This problem completely changed how I look at tree path problems: 👉 From brute-force traversal → to optimized prefix tracking 💭 **Key takeaway:** When a problem involves “subarray/paths with a given sum,” think: ➡️ Prefix Sum + HashMap #LeetCode #DSA #BinaryTree #PrefixSum #CodingChallenge #ProblemSolving #Java #TechJourney #Consistency