Brewing Modernization: How to Update Legacy RPG and Databases Without Burning the Coffee

☕ Today’s Coffee: Lavazza Gran Aroma — bold, aromatic, with a rich finish.

Modernizing legacy RPG applications and IBM i databases is a lot like brewing a strong cup of coffee: done carefully, it energizes the business and delivers something rich. Done hastily, it leaves a bitter taste and creates more problems than it solves.

We’re at a tipping point. IBM is moving away from SDA and SEU (with SEU likely following soon), developers are being asked to learn modern tools like VS Code and RDi, and leadership is hearing constant whispers about “leaving the IBM i.” The reality: you can’t ignore modernization any longer. The choice is whether to do it right—or do it wrong.

Why Modernization Matters

  1. Sustainability – RPG programs from the 80s and 90s may still run, but maintenance is slow, risky, and knowledge-dependent. A single retirement can create a huge knowledge gap.
  2. Integration – APIs, web services, and analytics all demand modular, SQL-based designs that play well with other platforms.
  3. Talent Retention – Developers—especially new ones—don’t want to work in “green screen only” environments. They want modern tooling, code editors, and workflows.
  4. Future-Proofing – IBM’s roadmap and broader IT trends point clearly: modernization is inevitable. Waiting only increases cost and risk.

The Human Challenge: Getting Developers to Move

One of the hardest parts of modernization isn’t technical—it’s cultural. Many RPG developers are comfortable with SEU, SDA, and DDS. They know how to fix problems fast in that environment. Asking them to switch to VS Code or RDi feels like asking them to throw away decades of mastery.

Common pushbacks include:

  • “The old code works—why change it?”
  • “I can code faster in SEU than in VS Code.”
  • “SQL is slower than native I/O.” (true in some edge cases, but usually outdated thinking).
  • “I’m scared of using something new. What if I break it?”
  • “I don’t have time to learn with all the deadlines we already have.”
  • “We don’t have time to rewrite everything.”

These concerns are real, and they can’t be brushed aside. Deadlines are pressing, and learning new tools feels like slowing down. But the truth is, modernization done right actually frees up time in the long run by reducing technical debt and making development more efficient.

Overcoming the Resistance

  • Incremental Wins: Don’t modernize everything at once. Pick a subroutine, a program, or a file, and modernize while making a real enhancement.
  • Education: Show developers how VS Code, RDi, and SQL simplify tasks they already struggle with.
  • Support: Provide mentorship and time for developers to learn, not just deadlines.
  • Leadership Alignment: Upper management needs to see modernization as essential for longevity, not a luxury project.

Doing It Correctly

1. Start Small, Prioritize High-Impact Areas

  • Identify programs or databases that cause daily pain (like nightly batch jobs, invoicing routines, or order entry).
  • Begin by modernizing just one calculation spec or one table. Don’t try to tackle everything at once.
  • Example: Converting one invoicing routine to free-format RPG can reduce onboarding time for juniors from weeks to days.

2. Introduce Modern Practices Gradually

  • RPG Free-Form: Convert fixed-form to free-form line by line, not entire programs at once.
  • Modularity: Move common routines into service programs.
  • SQL Views: Replace repeated embedded join logic with SQL views for clarity and consistency.
  • Example: A “CustomerActive” view can replace dozens of handwritten joins across the system.

3. Maintain Parallel Functionality

  • Always validate that modernized code behaves exactly the same as the legacy code.
  • Use regression testing, compare file outputs, or run dual systems temporarily.
  • Example: When replacing an RPG program that updates invoices, run the old and new versions side by side on test data to confirm identical results.

4. Engage Developers Early

  • Show developers how tools like VS Code, RDi, and even AI assistants (ChatGPT, Copilot) make their work easier.
  • Build shared templates for common programs so nobody is starting from scratch.
  • Celebrate small wins: “Ed converted this old report driver to free-form in one afternoon.”

5. Communicate with Leadership

  • Translate modernization benefits into business language:
    • Less downtime → more customer satisfaction
    • Easier onboarding → lower training costs
    • Future-proof code → reduced migration risk
  • Share concrete ROI examples:
    • “Refactoring one program cut new hire training time by 30%.”

Doing It Incorrectly

  1. Big Bang Rewrite – Attempting to rewrite everything in six months almost always fails. High cost, high risk, low adoption.
  2. Ignoring Culture – Developers resist change if it feels like “extra work” or if leadership doesn’t back them up.
  3. Tool Overload – Dropping a pile of tools on the team without training or standards creates chaos, not clarity.
  4. Data Integrity Risks – Neglecting commit/rollback or testing leads to corrupted data, broken trust, and leadership skepticism.

Case in Point: One company attempted to migrate all RPG programs to Java in a single project. They underestimated the embedded business logic in RPG and ended up with delays, overruns, and broken functionality. The result? Millions wasted and a leadership team now skeptical of modernization.

Getting Everyone on Board

Developers

  • What they care about: cleaner code, faster debugging, modern editors.
  • How to win them over: give them tools (VS Code, RDi, AI prompts) that save time on daily tasks.
  • Pro Tip: pair juniors and seniors on modernization projects. Seniors provide business knowledge, juniors bring fresh eyes.

Management

  • What they care about: costs, risks, timelines.
  • How to win them over: show incremental ROI—fewer production issues, shorter onboarding, less dependence on tribal knowledge.

Executives

  • What they care about: strategy, future-proofing, external perception.
  • How to win them over: connect modernization to the company’s larger goals: agility, cloud integration, customer satisfaction.

Leadership Angle: Modernization Is a Team Sport

Leaders must set the tone:

  • Encourage small, consistent improvements—not waiting for the mythical “big project.”
  • Recognize and reward developers who modernize code as part of daily work.
  • Tie modernization goals into career paths and OKRs so developers feel invested.

When leadership reinforces that modernization is not a side project but the way forward, culture shifts. Teams stop saying “why bother?” and start asking “how can we improve this?”

Final Sip

Modernization done right is like Lavazza Gran Aroma—strong, energizing, and sustainable. Done wrong, it’s burnt coffee: bitter, costly, and avoided by everyone.

The recipe for success isn’t complex:

  • Start small.
  • Validate results.
  • Equip your team with the right tools.
  • Communicate ROI in business terms.
  • Build a culture of continuous improvement.

When you approach modernization as an evolution, not a revolution, you preserve the value of legacy code while preparing your systems—and your people—for the future.

☕ Follow The RPG Blend for practical modernization strategies, leadership insights, and code examples you can use today.
đź“‚ Code examples on GitHub: The RPG Blend

Comments

Post a Comment

Popular Posts