DEV Community: slxca

Why WHOIS Is Dead in Modern Java (And How to Check Domains with RDAP)

slxca — Thu, 17 Sep 2026 19:57:19 +0000

If you have ever needed to programmatically check domain registration status or look up authoritative nameservers in Java, you likely ran into the same painful legacy protocol: WHOIS.

For decades, checking a domain meant opening a raw TCP socket on port 43, sending a query, and parsing completely unstructured plain-text responses. Every domain registry formats their output differently, meaning your code breaks the moment a registrar updates their whitespace, disclaimer, or field naming.

Fortunately, ICANN designated WHOIS as deprecated and introduced RDAP (Registration Data Access Protocol) as its official successor.

Here is why RDAP is superior and how to use it cleanly in Java without framework bloat.

Why RDAP Changes Everything

RDAP modernizes registry lookups by replacing ad-hoc text streams with established web standards:

Standard HTTP(S): Queries run over standard port 443 using simple GET requests. No firewall issues blocking port 43.
Strict JSON Schema: Responses adhere to standardized JSON formats (defined in RFC 9083), eliminating brittle regex parsing.
Standardized Status Codes: Determining whether a domain is taken is straightforward:
- HTTP 200 OK = Registered / Exists
- HTTP 404 Not Found = Available
Universal Discovery via IANA: You do not need to hardcode WHOIS server hostnames. IANA maintains a centralized bootstrap registry mapping TLDs to their authoritative RDAP endpoints.

The Problem with Java RDAP Libraries

While RDAP itself is a massive upgrade, the Java ecosystem historically lacked a simple, focused client:

Abandoned projects: Several early RDAP implementations have not received updates in years.
RFC Overkill: Many attempts try to implement every single RFC extension (complex vCard parsers, ASN allocations, IPv6 subnet blocks), turning a simple domain check into a heavy multi-megabyte dependency.
Manual Bootstrap Routing: Writing the logic to query IANA bootstrap files, cache them thread-safely, and handle edge-case ccTLDs requires non-trivial boilerplate.

To solve this, I built rdap-java—a lightweight (~5 KB) client built on top of native Java 11+ HttpClient and basic JSON parsing.

Quick Implementation Guide

1. Add Dependency

Available directly on Maven Central:

Maven:

<dependency>
    <groupId>com.slxca</groupId>
    <artifactId>rdap-java</artifactId>
    <version>1.0.0</version>
</dependency>

Gradle:

implementation 'com.slxca:rdap-java:1.0.0'

2. Check Domain Availability

Checking if a domain is registered takes just a few lines:

import com.slxca.rdap.RDAPClient;
import com.slxca.rdap.RDAPResult;
import com.slxca.rdap.RDAPException;

public class DomainService {
    public static void main(String[] args) {
        RDAPClient client = new RDAPClient();

        try {
            RDAPResult result = client.checkDomain("github.com");

            if (result.isRegistered()) {
                System.out.println(result.getDomain() + " is already taken.");
                System.out.println("Queried Endpoint: " + result.getServerUrl());
            } else {
                System.out.println(result.getDomain() + " is available!");
            }
        } catch (RDAPException e) {
            System.err.println("Lookup failed: " + e.getMessage());
        }
    }
}

3. Inspect Nameservers

If you are validating DNS setup or migration pipelines, you can extract authoritative nameservers directly from the parsed response:

RDAPResult result = client.checkDomain("cloudflare.com");

if (result.isRegistered()) {
    System.out.println("Authoritative Nameservers:");
    for (String ns : result.getNameservers()) {
        System.out.println(" -> " + ns);
    }
}

Handling Fallbacks & Custom Registries

Most major gTLDs (.com, .net, .org) and newer extensions are automatically resolved via the IANA bootstrap registry.

However, some ccTLDs (such as .de, .ch, or .nl) operate their own RDAP services outside the centralized IANA bootstrap list. rdap-java comes with curated built-in fallbacks for these registries, and also allows manual overrides for private or internal registries:

// Register or override a custom endpoint at runtime
client.registerServer("customtld", "[https://rdap.example-registry.net/rdap/](https://rdap.example-registry.net/rdap/)");
RDAPResult result = client.checkDomain("app.customtld");

Summary

If your Java application still relies on socket connections to port 43 or parsing raw WHOIS text files, migrating to RDAP is long overdue.

GitHub Repository: slxca/rdap-java
Maven Central: com.slxca:rdap-java

Feedback, edge-case TLD reports, and contributions are always welcome!

Why I Stopped Using Vector RAG for Coding Agents (And Used Git Markdown Instead)

slxca — Sun, 30 Aug 2026 21:38:22 +0000

If you use Cursor, Claude Code, or Windsurf daily, you’ve probably hit this wall:

You spend 45 minutes explaining your architecture, your API contracts, and why you never use a certain library pattern. The agent gets it, writes great code, and you finish the feature.

Next morning, in a fresh session:

"Let's implement this! I will use [the exact pattern you ruled out yesterday] and rebuild [a helper function that already exists]."

It feels like babysitting a brilliant junior engineer with amnesia.

The Two Usual "Solutions" (And Why They Break)

1. The Giant `CLAUDE.md` / `.cursorrules` Dump

The first instinct is dumping every rule, schema, and architectural pattern into a project instructions file.

The Problem: It murders your baseline token usage. Every single prompt sends 4,000+ tokens of context before you even type "fix this bug". Worse, models suffer from context dilution—when everything is in the prompt, nothing is prioritized.

2. Vector DBs & Semantic RAG

The second instinct is building or adopting a vector-based memory tool (embedding chunks of past chats/code).

The Problem: Semantic similarity $\neq$ authoritative truth. If you refactored an auth flow three times, a vector search for "how does auth work" will retrieve all three versions with near-identical similarity scores. The agent cannot distinguish between a deprecated experiment and today’s standard.

What Actually Works: Deterministic, Topic-Scoped Markdown via MCP

Instead of guessing via embeddings or overloading the system prompt, the cleanest architecture treats agent memory like codebase documentation:


.opencontext/
├── architecture.md
├── api-contracts.md
├── state-management.md
└── rejected-approaches.md

How it works under the hood:


[New Coding Session]
│
▼

1. Agent queries MCP index (~100 tokens)
("Available topics: architecture, api-contracts, state-management...")
│
▼
2. Agent fetches ONLY what it needs for the current task
(e.g., read_context("api-contracts"))
│
▼
3. Agent writes code adhering to exact invariants
│
▼
4. Architectural change? Agent mutates the markdown file in-place

The 3 Core Principles

1. Index-First Token Gating

Instead of dumping 15 KB of architectural docs into the system prompt, the agent starts every session with a tiny, auto-generated index:

{
  "topics": ["auth-flow", "error-handling", "database-conventions"],
  "total_files": 3
}

Cost: ~100 tokens. The model calls read_context("auth-flow") only if the prompt touches authentication.

2. In-Place Mutation over Infinite Append

Vectors fail because they append indefinitely. With topic-scoped markdown files, the agent updates the existing document when an architectural decision changes. There are no competing versions in vector space.

3. Git as the Universal Sync Layer

Because memory is just flat .md files inside the repository:

Zero Cloud Lock-in: No API keys, no external vector databases, no extra monthly subscriptions.
PR Reviews for AI Memory: When an agent updates .opencontext/api-contracts.md, it shows up directly in your GitHub pull request diff.
Cross-Agent Parity: You can start a task in Claude Code, commit your branch, open Cursor, and Cursor's MCP server immediately reads the exact same context.

Example: Setting Up Local MCP Memory

You can connect a lightweight local MCP server to Cursor or Claude Code in seconds.

In your claude.json or Cursor MCP settings:

{
  "mcpServers": {
    "opencontext": {
      "command": "npx",
      "args": ["-y", "opencontext-mcp"]
    }
  }
}

Now, instead of re-explaining constraints, you can simply tell your agent:

"Check the database conventions in our context and scaffold the new user billing schema."

The agent checks the index, reads .opencontext/database-conventions.md, adheres to your patterns, and moves on.

Conclusion & Discussion

We don't need complex vector pipelines for single-repository agent memory.

Plain text in Git has been the source of truth for software engineering for 20 years. Giving agents deterministic read/write access to structured markdown via MCP solves context persistence without the overhead.

How are you currently preventing your coding agents from losing context across sessions? Are you sticking with static rule files, using RAG, or building internal tools?

Why WHOIS is Deprecating and How to Use RDAP in Java

slxca — Thu, 16 Jul 2026 02:17:13 +0000

The Problem with WHOIS

For decades, the WHOIS protocol was the go-to solution to check domain ownership, IP address allocations, and Autonomous System Numbers (ASNs). However, WHOIS has a massive flaw: it lacks a standardized format. Parsing plain text responses from hundreds of different registries is an absolute nightmare.
Enter RDAP (Registration Data Access Protocol). It’s the official, modern successor to WHOIS. It runs over HTTP and delivers responses in structured JSON.

Introducing rdap-java

While working on infrastructure and DNS monitoring utilities, I realized that existing Java solutions for RDAP were either part of massive, bloated frameworks or heavily outdated.
To solve this, I built rdap-java—a lightweight, dependency-minimal client specifically designed to fetch and map RDAP data cleanly.

Quick Code Example

Here is how simple it is to look up a domain using the package:

// Quick draft example of querying a domain
RdapClient client = new RdapClient();
DomainResponse response = client.queryDomain("github.com");

System.out.println("Registrar: " + response.getRegistrarName());
System.out.println("Status: " + response.getStatus());

(Note: Feel free to adjust this snippet to match your exact API syntax!)

Open Source & Feedback

The project is fully open-source under the MIT license. If you are building anything in the networking, DevOps, or cybersecurity space with Java, I’d love for you to try it out.
Check out the repository here: https://github.com/slxca/rdap-java
What features should I add next? Let me know in the comments!