IBM i RPG Code Analysis & Health Assessment

What is RPG Metrics?

RPG Metrics is KDP’s IBM i code-analysis technology designed specifically for RPG applications.

It analyses RPG source code and measures key characteristics of the application, including complexity, maintainability, commenting levels, executable code, free-format compatibility and high-risk procedures or subroutines.

Rather than simply reporting how many source members exist, RPG Metrics looks inside the code and helps identify where complexity and technical risk are concentrated.

This makes it possible to move away from assumptions and build a modernization plan based on measurable evidence.

What we analyse in your RPG code

Why this matters

Mature IBM i applications often contain many years of business logic, enhancement and maintenance.

The application may continue to perform a critical role within the business, but it can become increasingly difficult to understand which parts are stable and straightforward to maintain and which contain concentrated technical risk.

A Code Health Assessment gives you an evidence-based view of the current application before significant modernization work begins.

Questions the assessment can help answer

• Which RPG programs contain the highest complexity?
• Where are the most difficult procedures and subroutines?
• Which programs are likely to be the hardest to change safely?
• How maintainable is the current codebase?
• How well is the application documented?
• How much older RPG syntax remains?
• Which areas should be tackled first in a modernization project?
• Where could modernization investment deliver the greatest value?

See where complexity is concentrated

A single complexity score for a program can hide where the real problem sits.

RPG Metrics can identify individual procedures and subroutines with high cyclomatic complexity, allowing developers and managers to see exactly where technical risk is concentrated.

This can be particularly valuable when deciding which areas of an application should be reviewed, refactored or modernized first.

We do the analysis for you

The KDP Code Health Assessment is a service, not a software implementation project.

You can provide us with a representative set of RPG source, or we can agree a secure method of access appropriate to your environment.

KDP carries out the analysis using RPG Metrics and returns the findings as a structured assessment.

We can then review the results with you and explain what the metrics mean in practical terms, helping you decide where further investigation or modernization work is justified.

Designed with source-code security in mind

We understand that IBM i source code may contain commercially sensitive application logic.

Where required, analysis can be carried out within the customer environment so that source code does not need to leave your systems.

Only calculated metrics and assessment information need to be used for reporting and review.

RPG and CL analysis

RPG is the primary focus of the assessment, but CL source can also be included to provide a broader picture of the application.

CL programs often contain important operational logic around program control, job processing, error handling and application flow. Including CL in the assessment can therefore provide useful additional context around the RPG application itself.

From code analysis to modernization planning

Modernization does not have to mean rewriting an entire application.

The assessment can help identify the parts of the application where change is most likely to deliver value and the areas where risk is highest.

For example, an organization may decide to focus first on programs that combine high complexity, lower maintainability and significant use of older RPG techniques, while leaving stable and low-risk code unchanged.

This allows modernization priorities to be based on evidence rather than assumptions.

Establish a baseline before modernization begins

A Code Health Assessment can provide a measurable baseline before a modernization project starts.

That baseline can then be used to compare the application over time and demonstrate whether complexity, maintainability and other code-quality measures are improving.

This can help technical teams, IT management and business stakeholders make more informed decisions about where modernization effort and budget should be directed.