DZone.com Feed

Solving the Mystery: Why Java RSS Grows in Docker on M1 Macs

Sumeet Sharma — Tue, 12 May 2026 19:00:00 GMT

The Problem

You're running a Java application in a Docker container on your M1 Mac. Everything works fine, but you notice something strange: The resident set size (RSS) keeps growing, even though your heap usage is stable. After hours of investigation, you find mysterious rwxp memory regions, each exactly 128 MB, accumulating in your process memory map.

What's causing this? Is it a memory leak? A JVM bug? Something else entirely?

The Art of Token Frugality in Generative AI Applications

Sibanjan Das — Tue, 12 May 2026 18:00:00 GMT

There was a time when token costs felt like rounding errors. A prototype making a few hundred calls a day, with a few cents here and there. That changes fast. When a generative AI (GenAI) application scales to thousands of users making multiple requests daily, token costs stop being a footnote and start being a line item that competes with infrastructure. The question is not whether to manage token consumption. It is whether you do so deliberately or by accident.

This article organizes some of the methods for reducing token consumption in production GenAI and agentic AI applications. Though not an exhaustive list, it is an actionable set of principles to apply directly and generative enough to spark further ideas. After all, frugality is the mother of invention, and in the age of AI transformation, thinking carefully about where tokens go is not an optimization. It is a discipline.

Has AI-Generated SQL Impacted Data Quality? We Reviewed 1,000 Incidents

Lior Gavish — Tue, 12 May 2026 17:00:00 GMT

Code breaks data. At least it used to.

Data teams write SQL transformations to shape raw data for downstream use cases. When those queries change, they can rupture dependencies or alter metrics in unintended ways.

Code Quality Had 5 Pillars. AI Broke 3 and Created 2 We Can’t Measure

Abgar Simonean — Tue, 12 May 2026 16:00:06 GMT

If you've been writing production software for more than a few years, you grew up with a gut sense of what "good code" meant beyond "it works." You could look at a pull request and feel whether the code was clean, or if the logic was going to be a nightmare to debug in six months.

We formalized that gut sense into five things: readability, maintainability, security hygiene, documentation, and structural simplicity. We built tools to measure them, argued about them in code reviews, and underneath all of it sat an assumption so obvious that nobody bothered to say it out loud — a human wrote this, and that human can explain why every line is there.

You Secured the Code. Did You Secure the Model?

Eran Kinsbruner — Tue, 12 May 2026 15:00:00 GMT

Your team just shipped an AI-powered feature. You scanned the code. Passed SAST. Reviewed the PR. Green across the board.

But here’s what you probably didn't scan: the model weights. The agent framework. The dataset lineage. The MCP server that your agent calls at runtime.

The 7 Pillars of Meeting Design: Transforming Expensive Conversations into Decision Assets

Otavio Santana — Tue, 12 May 2026 14:30:00 GMT

Software engineering prioritizes optimization, focusing on distributed systems, caching, cloud elasticity, observability, and AI-assisted development to boost productivity and speed. However, one of the most costly and overlooked inefficiencies is meeting culture.

Research from Harvard Business Review, Atlassian, and Microsoft Work Trend Index consistently shows that professionals spend much of their week in meetings, many of which fail to produce decisions, clarity, or measurable outcomes. In software development, this issue is amplified, as meetings disrupt deep focus, a critical asset for engineers. A poorly structured one-hour meeting with ten engineers not only wastes an hour but also disrupts concentrated work, delays delivery, and increases organizational latency.

When Search Started Breaking at Scale: How We Chose the Right Search Engine

sunil paidi — Tue, 12 May 2026 14:00:00 GMT

When we first built our search system, everything worked fine.

The data size was manageable, search responses were fast, and updates were happening as expected. Like many teams, we assumed that once a search engine is set up, it will continue to work as the system grows.

Scalable Support Request Analysis Using Embeddings, HDBSCAN, and Tiny LLMs

Jijo Puthalath — Tue, 12 May 2026 13:00:01 GMT

Data Exploration

Analyze the historical data to understand data quality, recurring key phrases, noise, and other patterns. Also, examine meta-attributes such as manual tagging, assigned department, assigned personnel, etc. Use spaCy or any other library to identify the most common words. This will indicate which words need to be masked, replaced, or normalized.

Data Cleansing and Enrichment

Identify domain-specific noise and aliases, and define regex rules to remove or standardize them.

DuckDB for Python Developers

varun joshi — Tue, 12 May 2026 12:00:00 GMT

If you have ever tried to run a quick aggregation on a 3GB CSV file in pandas, you know the ritual: wait for it to load into the memory, watch your RAM climb, maybe get a Memory Error, then reach for something heavier — a Postgres instance, a Spark cluster, a cloud warehouse. It's a lot of infrastructure for what should be a five-minute analysis.

DuckDB exists to break that cycle. It's an analytical database that runs entirely in process, requires zero setup, and can query CSV files, Parquet, and pandas DataFrames directly — often faster than tools that cost thousands of dollars a month to run. This post is for Python developers who work with data and want a sharper tool in their kit.

AI in Software Development: A Mirror, Not a Magic Wand

Jonathan Dodd — Mon, 11 May 2026 20:00:00 GMT

“AI’s inflection point has arrived.” This statement reflects how deeply artificial intelligence is embedding itself into our daily lives. For software developers, that reality is unavoidable. Whether you’re using GitHub Copilot for small productivity gains or experimenting with more advanced agentic workflows, AI-assisted development is here to stay — and learning to use it well is quickly becoming essential.

“AI’s inflection point has arrived.”

AI-Driven Integration in Large-Scale Agile Environments

Abhijit Roy — Mon, 11 May 2026 19:00:00 GMT

Abstract

This article explores the integration of AI technologies into Agile frameworks, focusing on large-scale applications such as the Scaled Agile Framework (SAFe). Beginning with personal experiences, the article discusses the synergistic potential of combining AI tools like Splunk and MuleSoft with Agile methodologies to enhance project velocity and foresight.

It highlights the importance of maintaining human oversight to balance AI insights, mitigating risks through regular feedback loops. Drawing on cross-industry insights, particularly from logistics, the article demonstrates the potential improvements AI can bring to software release cycles.

Monitoring Spring Boot Applications with Prometheus and Grafana

Ramya vani Rayala — Mon, 11 May 2026 18:00:00 GMT

Monitoring Spring Boot Applications with Prometheus and Grafana

Spring Boot’s Actuator and Micrometer provide rich metrics that can be scraped by Prometheus and visualized in Grafana. This guide covers configuring a Spring Boot application to expose Prometheus-formatted metrics, writing custom metrics, and setting up Prometheus and Grafana for monitoring.

We cover installing Prometheus, writing a configuration to scrape your application, importing Grafana dashboards, and crafting PromQL queries and alerting rules. We also discuss Prometheus best practices, including metric naming conventions, label cardinality, and retention settings. Security considerations, troubleshooting tips, and the performance impact of metrics collection are also included.

The Serverless Illusion: When “Pay for What You Use” Becomes Expensive

David Iyanu Jonathan — Mon, 11 May 2026 17:00:00 GMT

The pitch is seductive in its simplicity. You write a function. You deploy it. You pay only for the milliseconds it runs. No servers idling through the night, no reserved capacity gathering dust, no 3 a.m. pager alerts because a VM decided to kernel panic during a deployment window. The cloud provider handles the undifferentiated heavy lifting — their phrase, not mine — and you, liberated from operational tedium, focus on building the thing that actually matters.

I believed this. Genuinely. For a long time.

Mastering SwiftUI Gestures: Basic to Advanced

Pavel Andreev — Mon, 11 May 2026 16:00:00 GMT

Welcome back. If there is one thing that defines a truly great iOS app, it’s how it feels under the user’s fingertips. Fluid, intuitive, and responsive interactions are what separate good apps from exceptional ones. In SwiftUI, building these interactions revolves entirely around the Gesture API.

While adding a simple .onTapGesture is something we all learn on day one, truly mastering the SwiftUI gesture system — understanding gesture states, transaction animations, and complex composition — unlocks a whole new level of UI development.

Stop Guessing, Start Seeing: A Five -Layer Framework for Monitoring Distributed Systems

Prashant Pathak — Mon, 11 May 2026 15:00:00 GMT

We had hundreds of microservices. Thousands of enterprise customers. And alerts firing constantly — CPU at 80%, memory at 75%, disk at 60%. Engineers were drowning in noise, and still, every few weeks, a customer would open a ticket before we knew anything was wrong.

The problem wasn't a lack of monitoring. It was a lack of structure.

Stop Using Python for Your GenAI Apps, Use Go and Genkit Instead

Xavier Portilla Edo — Mon, 11 May 2026 14:30:00 GMT

For the last few years, every GenAI tutorial, framework, and “hello world” has assumed one thing: that you are writing Python. It made sense at the start. The research community lives in Python, the model providers ship Python SDKs first, and the notebook culture is hard to beat for prototyping. But there is a quiet, important shift happening in 2026: the teams actually shipping AI features at scale are increasingly moving their production generative AI (GenAI) workloads off Python, and onto languages built for services.

Go is at the center of that shift. And Genkit Go, the Go flavor of Google’s open-source GenAI framework, is the cleanest path I have seen to build production-ready AI services in Go: typed flows, structured output, built-in HTTP serving, observability, and a Developer UI, all from a single binary.

How to Effectively Evaluate a Ranking ML System

Muthukumaran Vaithianathan — Mon, 11 May 2026 14:00:00 GMT

I've seen too many ranking systems evaluated on metrics that look great in papers but mean nothing to the business. The evaluation gap between research and production is real, and it costs companies millions of dollars.

The problem starts with how we think about evaluation. Most data science teams treat it as a one-time validation step. You train a model, check some offline metrics, maybe run an A/B test, and ship it. But ranking systems are different from classification or regression tasks. They operate in feedback loops where today's rankings influence tomorrow's training data. They serve millions of requests with millisecond latency requirements. And they affect business metrics that offline metrics barely correlate with.

Hallucination Has Real Consequences — Lessons From Building AI Systems

Ram Ghadiyaram — Mon, 11 May 2026 13:30:01 GMT

In 2023, a New York lawyer was sanctioned after submitting a brief containing fabricated case citations generated by ChatGPT. The model invented plausible-sounding but nonexistent precedents.

Legal RAG tools from LexisNexis and Thomson Reuters still hallucinate between 17 and 33% of the time, even with retrieval grounding, according to a 2025 Stanford empirical study.

How to Secure Secrets in CI/CD Pipelines

Sandeep Kumar Khandelwal — Mon, 11 May 2026 13:00:05 GMT

CI/CD pipelines are the foundation of modern software delivery. Every code change, no matter how small or large, always goes through automated build, test, and deployment workflows prior to production delivery, and then becomes available to end users.

These CI/CD pipelines are connected with several systems. They are connected with different external systems, including image container registries, cloud platforms, artifact repositories, package managers, infrastructure tools, third-party applications, and many other systems. To enable this automation, pipelines depend on credentials including API tokens, cloud keys, service accounts, and passwords.

Improving Java Application Reliability with Dynatrace AI Engine

Ramya vani Rayala — Mon, 11 May 2026 12:00:17 GMT

Modern Java applications require robust observability and automated intelligence to ensure reliability at scale. Dynatrace’s AI-driven platform continuously learns application behavior, establishes statistical baselines and applies deterministic, causation based analysis to detect anomalies and pinpoint root causes.

By correlating metrics, logs, traces, and topology context across applications, services and infrastructure, Dynatrace can automatically highlight the true source of problems and assess their impact. This drastically reduces alert noise and MTTR .

Building a Production-Ready AI Agent in 2026: Beyond the Hello World Demo

Nikita Kothari — Fri, 08 May 2026 20:00:00 GMT

The Demo Problem: The "Vibe" vs. The "System"

In 2026, the novelty of an AI agent answering a question has evaporated. Every developer can string together a "Hello World" demo using the latest Anthropic or OpenAI SDK. These demos usually look flawless on LinkedIn: the agent reads a PDF, summarizes it, and perhaps even "books a flight" in a mock environment.

However, the "Demo-to-Production Gap" is wider than ever. When these agents hit real users, they encounter edge cases that a notebook can't simulate:

Inside What Actually Breaks in Large-Scale S/4HANA Conversions (And How to Prevent It)

Deepika Paturu — Fri, 08 May 2026 19:00:00 GMT

Broken Custom ABAP Code in S/4HANA

From an engineer’s perspective, one of the first headaches in a brownfield S/4HANA migration is custom ABAP code that no longer runs correctly. Unlike a simple upgrade, S/4HANA introduces a new architecture with a simplified data model and revised logic. Many classic SAP ECC tables and transactions either vanish or behave differently in S/4HANA, meaning some Z-programs that worked fine in ECC may now short-dump or produce incorrect results.

Common breakage patterns include:

When Angular APIs Return 200 but the Frontend Is Already Failing Users

Bhanu Sekhar Guttikonda — Fri, 08 May 2026 18:00:01 GMT

Successful HTTP requests have become a deceptively comforting metric in modern web systems. Dashboards show low latency, the network tab fills with green entries and the backend reports clean 2xx rates, yet users experience empty screens, contradictory state, stuck workflows or data that appears to randomly revert. This failure mode is common in Angular applications because the transport layer can succeed while the application layer has already violated a business contract and Angular’s default HTTP and reactive ergonomics are optimized around HTTP-level success versus domain-level correctness.

How Angular Treats 200 as Success

Angular’s HTTP layer is intentionally aligned with HTTP semantics a request is represented as an Observable and failures in the HTTP layer are emitted on the Observable error channel. Angular documents three broad categories of request failure network/connection failure, timeout and backend error responses and states that HttpClient captures these errors as an HttpErrorResponse returned through the Observable’s error channel. When an API responds with a non success HTTP status, the error channel is used and HttpErrorResponse provides the HTTP layer context.

Beyond SOLID: Embracing CUPID for Modern Software Craftsmanship

Nikita Kothari — Fri, 08 May 2026 17:00:00 GMT

For decades, the SOLID principles — Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion — have been the undisputed gold standard of object-oriented design. They were forged in an era of monolithic desktop applications and strict C++ or Java hierarchies.

However, as our industry has shifted toward microservices, serverless functions, and dynamic languages, many developers find that strictly following SOLID can lead to "over-engineering." We end up with an explosion of interfaces for single-method classes and a cognitive load that makes the codebase feel like a dense, impenetrable thicket.

The Only AI Test That Still Humbles Every Machine on Earth

Faisal Feroz — Fri, 08 May 2026 16:00:00 GMT

Imagine a video game with no instructions. No tutorial. No hint of what winning even looks like. You get dropped in, and you figure it out.

Most people do this in under a minute.

Custom Model Context Protocol (MCP) for NL2SQL: A Rigorous Evaluation Framework on Oracle Database

Sanjay Mishra — Fri, 08 May 2026 15:00:00 GMT

When you let an LLM turn natural language into SQL, you need to know: is it correct, will it run on your database, and is it efficient? SQLclMCP is an open-source framework that answers those questions by comparing LLM-generated SQL to human-written baselines on Oracle Database — using the Model Context Protocol (MCP) and a 500-question TPC-H benchmark. MCP keeps “how SQL is generated” behind a single HTTP API: the evaluator sends a question and gets back SQL, so you can swap models, prompts, or even the server implementation and still run the same evaluation. This article walks through the pipeline, how to run it, what gets measured, a few example graphs and tables, and Oracle gotchas we fixed in the prompt.

Why This Matters

Natural language to SQL (NL2SQL) works well for ad-hoc questions and app backends — until the model returns the wrong rows or a query that fails or runs too slowly in production. To ship with confidence you need three guarantees: the result set is correct (same logical result as the intended query), the SQL executes on your database without syntax or runtime errors, and it’s efficient enough (reasonable latency and plan quality, e.g. Oracle EXPLAIN PLAN). The only reliable way to get those guarantees is to compare LLM output to a gold standard on a real database, in a repeatable pipeline — so you can improve prompts, compare models, and catch dialect gotchas (Oracle vs MySQL, EXTRACT vs LIMIT, and the like). This framework gives you that pipeline.

RAG Done Right: When to Use SQL, Search, and Vector Retrieval and How To Combine Them

Ram Ghadiyaram — Fri, 08 May 2026 14:30:00 GMT

In this article, I will attempt to explain why retrieval-agumented generation (RAG) fails when retrieval is treated as a one-size-fits-all approach.

For example, the internal AI assistant looks great at demo time. Vector database ingesting overnight, GPT-4-class model, clean stakeholder presentation. The team ships.

How AI Is Rewriting Full-Stack Java Systems: Practical Patterns with Spring Boot, Kafka and WebSockets

Ramya vani Rayala — Fri, 08 May 2026 14:00:00 GMT

Building real-time applications means balancing user responsiveness with heavy backend processing. A proven solution is to decouple heavy workloads using events and asynchronous processing. In this approach, a Spring Boot application quickly publishes events to Kafka instead of processing requests inline. Then Kafka consumers (with AI/ML logic) handle the data in the background, and the results are pushed to clients in real time via WebSockets. This article highlights three key patterns enabling this architecture:

Event Production with Spring Boot and Kafka
AI-Driven Processing in Kafka Consumers
Real-Time WebSocket Delivery to the Frontend

Event Production with Spring Boot and Kafka

The first step is capturing an event and publishing it to Kafka. By offloading work to Kafka the application can respond immediately to the user without waiting for processing. Spring Boot’s integration with Apache Kafka provides a KafkaTemplate to send messages to topics.

The Data Warehouse Concurrency Playbook: Surviving the "Super Bowl" Moment

Anusha Kovi — Fri, 08 May 2026 13:30:00 GMT

It was a normal Tuesday until someone dropped a real-time dashboard link into a big team group. A few people opened it, and then a few hundred did. Within minutes, a slack pattern appeared: queries timing out, dashboards spinning, and the inevitable 'Is the data broken?'.

The confusing part here is that the CPU wasn't paged, the warehouse didn't look obviously maxed out, and nothing was 'red.' Yet the platform was unusable. That's what concurrency incidents look like in data: not a clean failure but a slow collapse into queues and retries.

How to Make Software Team Deliver More, Faster and Better #1 - The Team Toolset

Georgi V. Georgiev — Fri, 08 May 2026 13:00:14 GMT

Every engineering manager, VP or CTO demands their teams to push for more - quicker delivery, more features and with better quality. On the other hand side the guy with the project manager hat can simply laugh - up to those the delivery is a simple math and a balance between the scope (features, the More), the time (the Faster) and the Better (or the Worse, say - the quality). Based on my experience as an engineer and an engineering manager I still think that there is a big box of tools that can be used to break the project management triangle and simply push things further - for more, faster and better. In the given article I will start with toolset#1 - the team.

Managers do not deliver themself, they deliver with their teams. So, the goal of the engineering manager is to make sure that their team deliver. And the toolset that you have is as follows: