IBM i

IBM i 

A space for professionals working with IBM’s integrated OS for Power systems to exchange ideas, ask questions, and share expertise on topics like RPG and COBOL development, application modernization, open source integration, system administration, and business continuity.


#Power


#IBMi
#Power
#Operatingsystems
#Servers
 View Only

Don’t Modernize the Oldest Code First

By George Van Eaton posted 09/11/26 07:47 AM

  

How to prioritize IBM i modernization by risk, business value, and change pressure—not age

Modernization planning often starts with the most visible technical debt.

The oldest RPG.

The largest program.

The most fixed-format source.

The code that looks the most dated.

That approach is understandable, but it is also incomplete.

A thirty-year-old program that rarely changes, runs reliably, and sits at the edge of the application may offer very little return from immediate modernization.

Meanwhile, a newer component that supports pricing, billing, interfaces, or recurring production problems may deserve attention much sooner.

Modernization should not be prioritized by age alone.

A better approach is to evaluate business value, change pressure, operational risk, architectural leverage, knowledge risk, and delivery risk.

Age provides context.

It does not provide the roadmap.

Start With the Application Map

In Part 7, I discussed building six working maps before major modernization begins:

  • Application structure
  • Dependencies
  • Business rules
  • Data
  • Production behavior
  • Knowledge gaps

Those maps help answer an important question:

What do we understand well enough to change responsibly?

Once that understanding exists, another question follows:

What should we change first?

Most mature IBM i environments do not have one modernization opportunity.

They have many.

Some are technically difficult but operationally stable. Others look relatively clean while sitting in the middle of critical business processes.

A useful roadmap needs a way to distinguish between them.

Technical Debt Is Only One Dimension

Technical debt matters.

Poorly structured code slows development. Duplicated logic increases maintenance risk. Large programs make testing and change more difficult. Tightly coupled designs increase the impact of even modest requirements.

But technical debt is only one factor.

Suppose two programs are equally difficult to maintain.

One changes ten times a year.

The other has not changed in five years.

They do not have the same modernization value.

The first program repeatedly imposes the cost of its existing architecture on every enhancement, defect, regulatory change, or integration request.

That makes frequency of change an important part of modernization prioritization.

Measure Change Pressure

I think of this as change pressure.

How often is the business asking an area of the application to do something new?

That pressure may come from:

  • Enhancement requests
  • Regulatory requirements
  • Customer demands
  • Production defects
  • Interface changes
  • Reporting needs
  • Data changes
  • Integration work

A component under constant change pressure is often a stronger modernization candidate than one sitting quietly in production.

The reason is simple.

Every future requirement has to pass through the architecture that exists today.

If a tightly coupled pricing process changes repeatedly throughout the year, reducing that coupling may provide value over and over again.

Instead of asking only:

How old is this code?

Ask:

How much future work is likely to pass through it?

That changes modernization from a cleanup exercise into an investment decision.

Look at Operational Pain

Production support provides another important signal.

Some components consume far more operational attention than others.

They may require manual recovery, depend on fragile sequencing, generate recurring incidents, or rely heavily on developers who know the system from years of experience.

That operational burden has a cost even when nobody is actively enhancing the component.

Review:

  • Incident history
  • Job failures
  • Restart procedures
  • Manual interventions
  • Support documentation
  • Areas where recovery depends heavily on individual experience

These often reveal modernization opportunities that static code analysis alone will miss.

A component that creates recurring operational pain may be a much stronger modernization target than an older program that simply looks dated.

Find Architectural Leverage

Some modernization work improves one program.

Other modernization work improves an entire application area.

That distinction matters.

Suppose ten programs contain slightly different versions of the same business rule.

You could modernize each program separately.

Or you could create one trusted implementation behind a clear procedure, service, or architectural boundary.

The second approach creates architectural leverage.

The same principle applies to:

  • Shared validation
  • Database access
  • Repeated calculations
  • Integration logic
  • Error handling
  • Logging
  • APIs
  • Common data definitions

These modernization opportunities are valuable because their impact extends beyond the component being changed.

They reduce the cost of future work across the system.

Business Criticality Changes the Sequence

High business value does not automatically mean “modernize this first.”

Sometimes it means the opposite.

A stable core process may be extremely important while also carrying significant delivery risk.

In that situation, the better strategy may be to improve the environment around the component first.

That can include:

  • Strengthening tests
  • Clarifying interfaces
  • Documenting dependencies
  • Separating business rules
  • Improving observability
  • Reducing the blast radius of future changes

Then address the core.

A modernization roadmap should ask both:

What would create the most value?

and:

What sequence allows us to reach that value responsibly?

Modernization sequencing is architecture work too.

Consider Knowledge Risk

Another form of technical debt does not appear directly in the source code.

It exists in people’s heads.

If only one person understands a component, that is risk.

If developers consistently need the same senior engineer before changing a program, that is risk.

If nobody can explain why an important business rule exists, that is risk.

If production recovery depends on someone remembering an undocumented sequence, that is risk.

Modernization can reduce this exposure by clarifying responsibilities, documenting behavior, separating concerns, and creating designs that more developers can understand and change safely.

Sometimes the modernization problem is not poor code quality.

It is whether the knowledge required to maintain the system will survive.

A Simple Prioritization Model

You do not need a complicated scoring algorithm.

For each modernization candidate, evaluate six dimensions:

Dimension Question
Business Value How important is this capability to the organization?
Change Pressure How frequently does this area need to change?
Operational Risk How much production pain or failure exposure exists?
Architectural Leverage Would improving this area simplify future work elsewhere?
Knowledge Risk How dependent is the organization on undocumented expertise?
Delivery Risk How difficult or dangerous would the modernization itself be?

The goal is not to calculate a perfect score.

The goal is to make the decision explicit.

“This program is ugly” is not a strong modernization case.

“This capability changes frequently, causes recurring production issues, affects several processes, and is understood by only two developers” is considerably stronger.

Now engineering and leadership can discuss modernization using meaningful criteria rather than appearance alone.

Build the Roadmap in Layers

Not every modernization opportunity should become a major project.

Some improvements can happen during normal feature work:

  • Converting frequently maintained RPG to fully free-format
  • Extracting repeated logic
  • Improving error handling
  • Simplifying SQL
  • Strengthening documentation

Other changes require more deliberate structural work:

  • Introducing service programs
  • Establishing cleaner data-access boundaries
  • Centralizing business rules
  • Creating APIs
  • Separating tightly coupled responsibilities

Larger strategic efforts may eventually redesign major application boundaries, fragile batch processes, legacy integrations, or core business capabilities.

The point is not to avoid large modernization efforts.

It is to avoid making every modernization effort large.

Smaller improvements create experience, reduce risk, and build capacity for deeper architectural work.

Modernize Along the Path of Future Work

One of the most practical modernization strategies is to improve the system where the business is already asking it to change.

When a significant enhancement enters a difficult part of the application, use that requirement as an opportunity to improve the surrounding design.

That might mean:

  • Extracting a business rule
  • Creating a procedure around repeated logic
  • Strengthening a database boundary
  • Introducing an API
  • Adding focused tests
  • Documenting dependencies discovered during the work

The business requirement still moves forward.

But the application also becomes easier to change the next time.

Over time, modernization follows the path of actual business investment rather than competing with it.

Where AI-Assisted Development Can Help

AI-assisted development can make prioritization better informed.

AI can help developers:

  • Analyze unfamiliar RPG
  • Identify repeated logic
  • Surface potential dependency patterns
  • Compare similar implementations
  • Summarize large components
  • Identify possible refactoring candidates

It can also accelerate discovery when developers enter areas of the application they do not know well.

But prioritization requires context that source code alone does not contain.

AI does not automatically know which business capability matters most, which production problem creates the greatest operational cost, or why one unusual business rule exists.

The operating principle from Part 7 still applies:

AI discovers. Engineers verify. The organization decides.

AI can improve the evidence available to the team.

The modernization decision still belongs to engineering and the business.

What Not to Modernize

A mature modernization strategy should also identify areas that do not need attention right now.

Some components are reliable, well understood, isolated, and under little change pressure. Others may be approaching retirement or replacement.

Leaving those components alone is not a failure.

It is prioritization.

The goal is not to make every RPG source member look contemporary.

The goal is to make the application easier to understand, easier to change, and safer to operate.

If an old component is already meeting those needs reliably, there may be more valuable places to invest.

Final Thought

IBM i environments contain plenty of old code.

That makes age an easy modernization metric.

It is also a weak one.

A better roadmap prioritizes where business change, operational risk, architectural leverage, and knowledge risk create a reason to act.

Then it sequences the work so the organization can improve the system without creating unnecessary delivery risk.

Modernization is not a contest to see how much old RPG can be eliminated.

It is the disciplined work of making the system easier to understand, easier to change, and safer to operate.

That is a much better definition of progress.


George VanEaton is an IBM i engineering leader, software architect, and technical writer with more than 30 years of experience with RPG, Db2 for i, SQL, application modernization, and enterprise production systems. He is the creator of The RPG Blend™ and an IBM Redbooks contributing author on the work-in-progress publication Modernizing IBM i Applications.

The views expressed in this article are the author’s own.

0 comments
2 views

Permalink