Fresche Taps AI For New RPG-To-Java Conversion Tool

AI-Driven Legacy Modernization for IBM i: A New Playbook

Rajesh sat at his desk, the familiar hum of the aging server rack a low thrum against the morning quiet.

The glowing green characters on his screen, a tapestry of RPG code woven over decades, held the very heartbeat of his company’s operations.

He knew every subroutine, every variable, every intricate business rule buried within.

Yet, he also felt the weight of it—the sheer, Herculean effort required to keep it running, let alone evolve it for a new era.

The world outside his window raced towards AI and cloud, while he, an unsung hero of the IBM i, felt like he was holding back the tide with sheer will and hard-won experience.

It was not just code; it was a legacy, a responsibility.

For years, the path forward felt like a treacherous, slow climb.

Why This Matters Now

That feeling of being caught between an indispensable past and an imperative future is a reality for countless organizations globally.

The backbone of many enterprises still rests on robust, yet increasingly challenging, legacy systems.

Modernization is not just a buzzword; it is a strategic imperative.

Now, the advent of generative AI is not merely changing the conversation, it is rewriting the playbook for legacy modernization.

Companies like Fresche Solutions are tapping into this AI revolution to offer a tangible path forward, promising to significantly accelerate complex projects like RPG to Java conversion by harnessing AI’s power while carefully managing its inherent risks, as reported by IT Jungle.

In short, Fresche Solutions’ X-Modernize AI leverages generative AI and large language models (LLMs) to transform legacy RPG and Synon code into modern Java.

This innovative tool combines deep application understanding with AI-driven conversion and human oversight, promising faster, more reliable application modernization for IBM i systems.

The Elephant in the Server Room: Why Legacy Code is So Hard to Modernize

Imagine inheriting a magnificent, intricate machine—a Victorian-era clockwork automaton.

It is beautiful, functional, and built to last.

Now, imagine needing it to run on a modern operating system, integrate with a smart home, and speak Python.

That is essentially the challenge of modernizing legacy RPG applications.

It is not merely a language translation; it demands understanding every intricate business rule embedded within its decades-old structure.

The core problem extends beyond the age of the code; it lies in the depth of embedded business logic.

Over years, critical rules become deeply intertwined with the code’s structure, often in ways that defy simple, rules-based translations.

Many have found rip-and-replace approaches cost-prohibitive with high disruption risk.

Others have attempted to feed raw RPG code into general-purpose Large Language Models (LLMs), hoping for a magical Java output.

This often leads to code that technically runs, but is inconsistent, difficult to maintain, and riddled with logical errors—what the industry calls hallucinations.

It is like asking a brilliant poet to translate a complex engineering manual; the output might be beautiful, but functionally flawed.

As John Clark, Fresche’s CTO, points out, the various unique tools and commands RPG developers have historically used create landmines for a DIY approach with mainstream LLMs, according to IT Jungle.

The DIY Trap: When Good Enough Is Not

Consider a mid-sized manufacturing firm, heavily reliant on a custom-built inventory management system on their IBM i.

Their IT team, eager to embrace AI, experimented with feeding snippets of their RPG code into a publicly available LLM.

Initial results looked promising—some Java was indeed generated.

However, testing revealed the LLM had converted RPG date codes inconsistently across different modules, misinterpreting data areas, and fundamentally altering the business logic for certain inventory movements.

The generated code might have been syntactically correct Java, but it simply did not do what it did before.

This experience underscored a crucial truth: without deep, specialized understanding and careful guidance, the creativity of AI can quickly become a liability.

What the Research Says About AI-Powered Modernization

The promise of generative AI for code conversion is immense, but the data points to a nuanced path forward, not a blind leap.

Fresche’s approach with X-Modernize AI offers valuable lessons, backed by their decades of experience in application modernization.

AI Can Significantly Accelerate Code Conversion, But Not Alone

The biggest draw of generative AI is its potential to compress timelines.

Fresche states its X-Modernize AI can significantly speed up code conversion projects, according to IT Jungle.

This means organizations can achieve modernization goals faster, reducing project timelines and freeing up critical resources, ultimately leading to a quicker path to a modern, maintainable codebase and enabling future innovation sooner.

A Pragmatic, Hybrid Approach Is Crucial for Quality and Maintainability

Simply feeding raw RPG code into an LLM is a recipe for disaster.

Fresche takes a pragmatic approach, relying on its established X-Analysis tool to first extract underlying business rules from the RPG code.

Only then do AI agents generate Java code from these rules, not the original RPG, according to IT Jungle.

Marcel Sarrasin, general manager of modernization solutions at Fresche, emphasizes that their goal is business functional equivalence—the new Java code must perform exactly as the old RPG code did, IT Jungle reported.

Companies need solutions that integrate deep domain understanding and analytical tools with AI, rather than treating AI as a standalone magic bullet for LLM code conversion.

IBM i and RPG’s Uniqueness Demands Specialized AI Solutions

Mainstream LLMs often lack a comprehensive grasp of the unique characteristics of platforms like IBM i and languages like RPG.

Concepts familiar to RPG programmers, such as the move command, data areas, and data queues, can cause havoc for LLMs, according to Fresche’s John Clark, as noted by IT Jungle.

This insight underscores why a generic ChatGPT approach is insufficient.

Organizations must be wary of do-it-yourself attempts using general-purpose AI and instead seek out specialized vendors with proven expertise in the IBM i ecosystem and Synon modernization.

Fresche mitigates this by using a mix of different LLMs and strategically taking the steering wheel away from AI where its creativity is not beneficial, John Clark stated in IT Jungle.

Your Playbook for AI-Driven Legacy Modernization Today

Embracing AI for legacy modernization is not about letting machines take over; it is about smart collaboration.

This playbook, informed by Fresche’s pioneering work with X-Modernize AI, guides organizations in leveraging generative AI effectively.

A foundational step is to start with deep application understanding.

Before any code conversion begins, invest in tools that provide a comprehensive cross-reference and understanding of your entire legacy application.

Fresche’s X-Analysis, for example, is used to extract the underlying business rules buried in RPG code, according to IT Jungle.

This ensures that logic, not just syntax, is converted, setting the stage for business functional equivalence.

Prioritizing business rule extraction over raw code translation is critical.

The goal is to discern and extract the true business logic from RPG, allowing generative AI to create modern code from a clear, language-agnostic blueprint.

This avoids the pitfalls of attempting to guess intent from complex, older syntax.

Further, implement strategic AI constraints and guardrails.

Unconstrained AI can lead to errors.

Solutions should manage AI’s creativity and prevent code hallucination.

Marcel Sarrasin of Fresche notes their significant effort in constraining hallucinations, flagging elements for human review to ensure consistency, especially for common components like RPG date codes, as reported by IT Jungle.

Crucially, keep humans in the loop for the last mile.

Even advanced AI needs human oversight.

Fresche consciously builds exit points where developers step in for final review and refinement.

As Sarrasin emphasizes, a developer will still need to look at this converted code, according to IT Jungle.

This human-in-the-loop approach is vital for robust, accurate, and truly maintainable converted code.

Finally, target comprehensive modernization.

Think beyond just language conversion.

Consider tools that also support DDS to DDL conversion for database modernization and the transformation of greenscreen interfaces to modern JavaScript frameworks like React, IT Jungle reported.

This ensures a truly future-proofed application stack.

Risks, Trade-offs, and Ethics in the AI Modernization Journey

While the allure of AI-driven modernization is strong, it is crucial to navigate the landscape with a clear understanding of potential pitfalls.

The primary risk lies in over-reliance on unconstrained AI.

Without the strategic controls, business rule extraction, and human oversight championed by solutions like X-Modernize AI, you risk ending up with syntactically correct but functionally flawed code.

This can lead to increased technical debt, costly refactoring, and a loss of confidence in the modernization effort itself.

The trade-off is often between the perceived speed and low cost of generic AI versus the higher initial investment in specialized, integrated solutions designed for specific domains like IBM i and RPG.

The latter, while potentially more expensive upfront, mitigates the long-term risk of unmaintainable code.

Ethically, consider data privacy.

When sending proprietary legacy code to external LLMs, understanding how your code is used, stored, and secured by the AI model provider is paramount.

Ensure your chosen solution offers flexibility in LLM choice or provides strong guarantees around data handling, especially if concerns about specific AI model builders exist, IT Jungle suggests.

Ultimately, the goal is to enhance human capability and business value, not to create new, opaque systems that nobody fully understands or trusts.

Tools, Metrics, and a Cadence for Success

Successfully deploying AI in application modernization requires the right toolkit, clear performance indicators, and a structured approach.

Essential tools include application understanding and business rule extraction platforms, such as Fresche’s X-Analysis, indispensable for dissecting legacy code and uncovering its core logic.

An AI-powered code conversion platform, like X-Modernize AI, which integrates LLMs with domain-specific knowledge and human controls, is also crucial.

Supporting this, a modern development environment with standard Java development kits, IDEs, and build automation tools, alongside a robust Continuous Integration/Continuous Delivery (CI/CD) pipeline, seamlessly integrates AI-generated code into existing DevOps workflows.

Key metrics for success include conversion velocity (lines of code or functional units converted per period), defect density (bugs per thousand lines of converted code), and a maintainability index (quantifying ease of understanding and modification).

Measuring developer productivity (time saved on manual conversion) and the business functional equivalence rate (percentage of modules passing functional tests without significant remediation) provides a comprehensive view of project success.

A structured review cadence, ideally following an Agile methodology with regular sprint reviews, allows for assessing progress, addressing issues, and confirming functional equivalence.

Quarterly strategic reviews evaluate the overall modernization roadmap, budget, and long-term maintainability of converted applications, ensuring AI acts as a catalyst for improvement, not a source of chaos.

Frequently Asked Questions about AI-Driven Modernization

Fresche Solutions’ X-Modernize AI is a new software offering that leverages generative AI and large language models to convert legacy RPG and Synon code into modern Java, designed to significantly speed up code modernization projects, as reported by IT Jungle.

The platform ensures quality and maintainability through a pragmatic, hybrid approach.

It begins by using X-Analysis to extract underlying business rules from RPG code, with AI agents then generating Java code from these rules.

Human intervention points are strategically built in to constrain AI-driven hallucinations and ensure business functional equivalence, resulting in maintainable Java code, IT Jungle stated.

X-Modernize AI supports the conversion of fixed-format RPG III and RPG IV, as well as Synon code, primarily targeting standard Java 17 for any JVM.

It also facilitates DDS to DDL conversion for databases such as Db2 for i, Postgres, Oracle, and MySQL, and transforms greenscreen interfaces to JavaScript using React, according to IT Jungle.

A general LLM like ChatGPT is insufficient for RPG code conversion because IBM i and RPG possess unique characteristics and constructs, like the move command and data areas, that mainstream LLMs do not fully grasp.

Without specialized guidance, using a general LLM can lead to significant issues and unmaintainable output, a risk X-Modernize AI is specifically designed to mitigate through its integrated and constrained approach, IT Jungle noted.

Conclusion

As the sun sets, casting long shadows across Rajesh’s office, he can finally see a clear path.

The hum of the servers, once a reminder of stagnation, now whispers with the promise of transformation.

The green screens, once symbols of an unbreakable past, are becoming a blueprint for a future where his deep knowledge can be amplified, not replaced.

Tools like Fresche’s X-Modernize AI are not just about converting code; they are about bridging generations of technology, allowing seasoned professionals like Rajesh to continue shaping their companies’ destinies, leveraging the power of AI with a human touch.

It is a testament to the fact that even in the age of AI, human wisdom, domain expertise, and strategic vision remain irreplaceable.

The future of IBM i applications is not about abandoning the past, but intelligently bringing it forward.

Discover how smart AI integration can redefine your modernization strategy.

Visit Fresche Solutions to learn more.

References

IT Jungle, Fresche Taps AI For New RPG-To-Java Conversion Tool

Article start from Hers……