Big-Data, Data Analytics & Databases on JAVAPRO International

Petabyte-Scale AI Memory with Serverless Java

Wed, 15 Apr 2026 07:00:01 +0000

The current wave of Generative AI innovation is built on a paradox. While models are becoming more powerful and efficient, the infrastructure required to operate them at scale is becoming increasingly wasteful. Enterprises are investing millions into compute, storage, and energy, yet a significant portion of these resources remains idle. Modern vector databases, graph systems, and caching layers are based on a monolithic architecture run as always-on clusters, consuming CPU and RAM regardless of whether data is actively accessed. Studies and industry analyses consistently show that up to 80% of compute resources in such systems are effectively wasted on idle workloads.

High-Performance Vector-Search Grids with Java

Wed, 08 Apr 2026 07:00:02 +0000

The rapid rise of Generative AI has fundamentally changed how modern systems are designed. While much of the attention has focused on large language models and inference pipelines, the real differentiator in production systems lies elsewhere: in the infrastructure that delivers context to those models. Retrieval-Augmented Generation (RAG) has become the de facto pattern for enterprise GenAI. It relies on fast, scalable access to embeddings, metadata, and relationships. Yet for Java developers, building such systems at scale has remained a challenge. External vector databases introduce latency, fragmentation, and operational complexity. Distributed caches struggle with memory inefficiency and serialization overhead. Traditional databases cannot handle high-dimensional similarity search at the required speed.

No Deadlocks in MongoDB: Atomic Documents and Retries with Spring Data MongoDB

Thu, 18 Dec 2025 07:00:01 +0000

Deadlocks are frequent in SQL databases, as normalization and two-phase locking (2PL) require locking multiple tables or rows during DML operations. Numerous use cases share them, and transactions might access data in a different order, resulting in circular waits and deadlocks. While databases can detect them, they can’t prevent or resolve deadlocks, as the application determines what is run and in what order. The best the database can do is cancel one statement or transaction, and let the application rollback and retry, which can reduce performance as systems wait several seconds before getting notified. As Oracle Database makes clear in the error log: “It is a deadlock due to user error in the design of an application or from issuing incorrect ad-hoc SQL.” Most RDBMS use pessimistic locking to avoid conflicts, but deadlocks are unavoidable, and locking can increase latency. For instance, by default, DB2 waits 10 seconds for deadlock detection, SQL Server waits 5 seconds, Oracle waits 3 seconds, and YugabyteDB and PostgreSQL wait 1 second. These delays impact latency, but deadlock prevention remains the application’s responsibility. The only way to entirely prevent deadlocks is by avoiding locks altogether, as in MongoDB, which provides lock-free ACID transactions.

Why AI Agents Need a Protocol-Flexible Event Bus

Thu, 06 Nov 2025 07:00:01 +0000

Your AI agents are only as effective as the messaging infrastructure that ties them together.

Java and Databases: From SQL to JPA and NoSQL

Thu, 19 Jun 2025 07:00:02 +0000

Over the past 30 years, Java has significantly changed the way applications interact with databases. In the early days, Java applications typically used a client/server model and a three-tier architecture, where SQL statements were often embedded as string literals within the application. These statements were sent to databases through straightforward interfaces such as JDBC.

As programming paradigms shifted towards Object-Oriented Programming (OOP), Java developers began to integrate business logic more seamlessly into data structures. This move represented a shift from purely database-centric models to application-first designs. This transition enabled data abstraction through application programming interfaces (APIs), allowing SQL database tables and rows to be represented as classes and objects within the application. As a result, data sharing and persistence also evolved, moving from strictly normalized relational tables to document-oriented databases that align more closely with object-oriented structures and specific use cases.

Vector Embedding in Java Applications: Gen-AI Functions Directly from the Database

Tue, 06 May 2025 11:30:01 +0000

Generative AI (GenAI) has rapidly advanced in recent years and is increasingly finding its way into practical software development. What was once considered a research topic is now becoming a tool for everyday developers — including in the Java space. Vector embeddings play a key role here: they enable functions like semantic search, text classification, or recommendation systems, opening up entirely new application possibilities.

But how can these technologies be integrated into existing Java applications without the need for complex frameworks or external cloud services?

A Tale of Two Runtimes: Setting Up Your Local Java Development with Flink

Fri, 02 May 2025 07:00:03 +0000

It was the best of builds, it was the worst of builds. One ran effortlessly in the IDE, the other stubbornly broke at runtime. Welcome to the tale of two runtimes: your local development setup and the Flink cluster where your job is ultimately meant to live.

In this post, we’ll walk through how to set up your Flink Java project so you can develop, test, and run it locally with ease. Just like Charles Dickens’s works, if you’re just getting started with Apache Flink, the setup can feel a bit intimidating…

Thinking differently about testing

Mon, 27 Jan 2025 16:35:56 +0000

10x Insights to help take a different view of quality assurance

I’ve given a few talks about 10x developers, or rather 10x professionals and been involved in process (re)engineering for many teams and projects. However much you learn about people and their roles - there’s always something new to discover. In fact, it’s amazing how often your worldview is blinkered, how often there’s a different way to do or think about some aspect of your life or career.

EclipseStore TAKES CONTROL OF CONCURRENCY

Fri, 29 Nov 2024 14:45:02 +0000

In the world of data management, ensuring data integrity and consistency is paramount, especially for mission-critical applications in finance, healthcare, and other sensitive sectors. This is where the concept of ACID comes in.

ACID: The Bedrock of Reliable Data

ACID stands for Atomicity, Consistency, Isolation, and Durability. These properties are essential for any database system that handles transactions. Let’s break down what each means:

Atomicity: An operation within a transaction is either all successful or all fails. This ensures that the data remains consistent.
Consistency: The database enforces data integrity rules. Transactions may not leave the data in an invalid state.
Isolation: Transactions execute as if they were isolated from each other. Changes made in one transaction are invisible to other ongoing transactions until the first one is committed.
Durability: Once a transaction is committed, the changes are permanently persisted in storage. This ensures that data is not lost even in case of system crashes or power failures.

EclipseStore: Speed Meets Simplicity