<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Kanagarajan Dhandayuthasamy (Kanag) on Medium]]></title>
        <description><![CDATA[Stories by Kanagarajan Dhandayuthasamy (Kanag) on Medium]]></description>
        <link>https://medium.com/@kanagarajan.d?source=rss-903731027163------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*0z72mCVSznAQuPc_k0ldhA.jpeg</url>
            <title>Stories by Kanagarajan Dhandayuthasamy (Kanag) on Medium</title>
            <link>https://medium.com/@kanagarajan.d?source=rss-903731027163------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 07:39:17 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@kanagarajan.d/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[The “JOBOL” Trap: Why True Legacy Modernisation is More Than Just Code Translation]]></title>
            <link>https://medium.com/@kanagarajan.d/the-jobal-trap-why-true-legacy-modernisation-is-more-than-just-code-translation-e5c587b764aa?source=rss-903731027163------2</link>
            <guid isPermaLink="false">https://medium.com/p/e5c587b764aa</guid>
            <category><![CDATA[generative-ai-solution]]></category>
            <category><![CDATA[legacy-modernization]]></category>
            <category><![CDATA[application-modernization]]></category>
            <category><![CDATA[cobol-to-java]]></category>
            <dc:creator><![CDATA[Kanagarajan Dhandayuthasamy (Kanag)]]></dc:creator>
            <pubDate>Fri, 21 Aug 2026 17:25:09 GMT</pubDate>
            <atom:updated>2026-08-22T05:23:23.541Z</atom:updated>
            <content:encoded><![CDATA[<p>In today’s hyper-accelerated technological landscape, the push for modernisation is relentless. Organisations across every sector are urgently seeking to transform their monolithic legacy systems (e.g., COBOL-based applications) into modern, resilient, and scalable applications (e.g Java, microservice architecture)</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lJOy47m9nvIBTfI8p1i59A.png" /></figure><p>Interestingly, the bottleneck isn’t just decades-old mainframes sitting in dusty basements. Even applications developed just a few years ago are becoming painfully difficult to maintain. The culprit? A rapidly growing scarcity of Subject Matter Experts (SMEs) who hold the niche, tribal knowledge required to keep these fragile systems running.</p><p>Right now, a massive wave of these modernisation requests focuses on a specific challenge: migrating legacy COBOL applications to modern, Java-based microservices architectures. However, if you look at the industry’s success rate with these transformations, the results are decidedly mixed.</p><p>Here is why so many modernisation projects stall, and how a two-step engineering approach can help you avoid the most common pitfalls.</p><h3>The Reality of Automated Transformation</h3><p>Driven by aggressive timelines, many organisations look for a silver bullet, experimenting with various automated transformation tools that promise seamless migration. The reality on the ground, however, is much more sobering.</p><p>Currently, the productivity gains provided by automated tooling and service companies hover around <strong>50% to 60%</strong>.</p><p>Why is there a ceiling on this automation? While basic syntax and small, isolated components can be transformed with high accuracy, complex enterprise systems are a different story. They are filled with deeply embedded business logic, undocumented workarounds, and tangled dependencies. You cannot simply feed decades of intertwined logic into a black-box converter and expect a pristine microservice to emerge. Edge cases and complex integrations invariably require a “human-in-the-loop” to unravel.</p><h3>The “JOBOL” Trap: Why Code-to-Code Translation Fails</h3><p>A one-size-fits-all approach is a recipe for disaster in application transformation. Success depends heavily on the source language, the target ecosystem, and the fundamental depth of the modernisation required.</p><p>One of the most dangerous — and most common — pitfalls in COBOL-to-Java migrations is the <strong>code-to-code translation approach</strong>.</p><p>When migration teams focus solely on translating programming syntax rather than rethinking the underlying architecture, they don’t end up with a modern Java application. Instead, they create <strong>“JOBOL”</strong> — an application written in Java, but structured exactly like a procedural, sequential COBOL program.</p><h3>What does “JOBOL” look like?</h3><ul><li><strong>Monolithic Classes:</strong> You end up with massive, 10,000-line Java classes that act like COBOL batch jobs.</li><li><strong>Procedural Mindset:</strong> Instead of leveraging Object-Oriented principles or functional programming, the code executes in rigid, top-down sequences.</li><li><strong>Fake Modernisation:</strong> It carries over legacy technical debt, tightly coupled dependencies, and outdated design patterns.</li></ul><p>Code-to-code translation completely ignores modern architectural paradigms like Domain-Driven Design (DDD). It places your legacy problems into a shiny new environment, entirely negating the reasons you wanted to modernise in the first place: scalability, agility, and maintainability.</p><h3>A Better Way: The Two-Step Approach</h3><p>To achieve true modernisation, IT leaders must move beyond line-by-line translation and embrace full-scale re-engineering. Based on deep field experience, migrating a complex legacy application should be executed in two distinct phases:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0SCzzsyABY5FRcuCKzml8Q.png" /></figure><h3>Step 1: Reverse Engineering (Extract to Functional Specifications)</h3><p>As a critical first step, the existing COBOL codebase must be reverse-engineered. The goal here is not to map the code, but to <em>strip away</em> the legacy syntax and unearth the pure business rules, compliance requirements, and core logic of the application. By creating a comprehensive functional specification, you separate <em>what</em> the business does from <em>how</em> the old system did it. This gives you a technology-agnostic blueprint of your enterprise logic.</p><h3>Step 2: Forward Engineering (Review and Architect)</h3><p>Once the functional state is clearly documented, it provides a transparent canvas for stakeholders to review the system in its entirety. Often, businesses realise that certain legacy rules are no longer needed, or that new workflows should be introduced. From there, engineering teams can design and develop the target application from the ground up. Because they are working from clean specifications rather than tangled code, they can properly utilize modern, cloud-native principles, containerization, and microservices architectures.</p><h3>The Takeaway</h3><p>When we aim to transform an old application into a new one, we must evaluate the architectural shift just as critically as the language shift.</p><p>Moving from COBOL to Java is not just about changing the words; it’s about changing the paradigm. By first extracting the underlying business logic and then consciously re-architecting the solution, organisations can successfully bypass the “JOBOL” trap. The result is a truly modern, scalable application that empowers the business and is ready for the future.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e5c587b764aa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Shift to Agentic Frameworks: Why CLI Agents are Taking Over the SDLC]]></title>
            <link>https://medium.com/@kanagarajan.d/the-shift-to-agentic-frameworks-why-cli-agents-are-taking-over-the-sdlc-f05e4864941e?source=rss-903731027163------2</link>
            <guid isPermaLink="false">https://medium.com/p/f05e4864941e</guid>
            <category><![CDATA[agenticframework]]></category>
            <category><![CDATA[cli]]></category>
            <category><![CDATA[ai-in-sdlc]]></category>
            <category><![CDATA[context-window-management]]></category>
            <category><![CDATA[no-custom-accelerator]]></category>
            <dc:creator><![CDATA[Kanagarajan Dhandayuthasamy (Kanag)]]></dc:creator>
            <pubDate>Thu, 20 Aug 2026 16:58:21 GMT</pubDate>
            <atom:updated>2026-08-20T16:58:21.554Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HmZncs7X4teNXGHg0gBm0w.png" /></figure><p>When discussing the adoption of Artificial Intelligence in the enterprise, it is often much easier to integrate it into the Software Development Life Cycle (SDLC) than into customer-facing business applications.</p><p>The reason for this is straightforward: AI responses are probabilistic, not 100% deterministic. If you embed an AI feature directly into a live consumer application, a hallucination or inaccurate response can happen in real-time, creating significant business risk. However, the SDLC naturally provides a “Human-in-the-Loop” safeguard. An AI can generate, review, or refactor code, but a human engineer will always verify and test it before it reaches production. This inherent safety net makes the SDLC the ideal environment for rapid AI adoption.</p><p>Development teams began building custom accelerators with proprietary parsing tools to understand their codebases, creating workarounds to stay within strict LLM context window limits.</p><p>The Bottleneck: <strong>Context Windows and Custom RAG</strong><br>Before the recent rise of autonomous agentic frameworks, development teams spent massive amounts of effort building custom accelerators and internal API scripts to handle different phases of the SDLC. Today, many of those custom-built solutions are becoming obsolete. The primary culprit? The complexity of handling large enterprise codebases.</p><p>When working with a massive repository, you cannot simply pass the entire project into a Large Language Model (LLM). You will immediately hit the “context window limit” — the strict maximum amount of text an AI can process at one time. While the latest models support a bigger context window limit, it still comes with other challenges. While bigger is better in theory, it comes with more cost, and another important aspect they need to look at is ‘lose-in-the-middle ’ of the context; not all content in the context is given equal importance.</p><p>To solve this, developers had to build complex strategies to feed the codebase to the AI chunk by chunk. They essentially had to build their own Retrieval-Augmented Generation (RAG) pipelines just to ask the AI questions about their own software. This proved incredibly difficult. Breaking code into chunks often meant losing critical context, such as file dependencies, import structures, and project architecture. Ensuring the LLM retained the right context across multiple files became a heavy engineering burden.</p><p>The Solution: <strong>Why Agentic CLI Frameworks Win</strong><br>This architectural headache is exactly why the industry is rapidly shifting toward agentic CLI (Command Line Interface) frameworks.</p><p>Instead of forcing internal teams to build and maintain custom RAG pipelines, these modern agentic frameworks handle the heavy lifting natively. When you ask a CLI agent a complex question about your repository, it acts autonomously. It dynamically retrieves only the specific, relevant code snippets needed for that exact prompt and sends only those to the LLM.</p><p>Key Benefits of Adopting CLI Agents<br>By moving away from custom API-key scripts and embracing agentic CLI frameworks, engineering teams unlock several major advantages:</p><h3>Optimized Token Usage: <strong>Because the agent intelligently filters and sends only the necessary code snippets, organizations save significantly on API token costs and reduce response latency</strong>.</h3><p>Zero Maintenance Overhead: Teams no longer have to waste engineering hours maintaining internal AI scripts or updating their custom RAG logic every time a new LLM version is released.</p><p>Seamless Developer Experience: CLI tools integrate natively into a developer’s existing terminal and IDE workspace. There is no need to context-switch to an external web portal to paste code snippets.</p><p>Maintained Architecture Context: Modern agents understand code structure. They can trace dependencies across files automatically, ensuring the AI has the perfect context without developer hand-holding.</p><p>By adopting these frameworks, developers are freed from the complexities of token limits and context loss. They can focus purely on what matters most: writing excellent software and guiding the AI as the critical Human-in-the-Loop</p><p>Within my professional network, Claude Code (Anthropic), OpenAI Codex CLI, and Gemini CLI (Google) are currently the most widely adopted agentic frameworks.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f05e4864941e" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>