You open a support ticket at the start of the day. A nightly job stopped overnight, and the job log points to an RPG program that nobody on your team has opened in years. Your senior developer knows the program by its name but still has to open the source to learn what it updates. Before anyone changes a line, you want an answer to one question: if we touch this, what else moves? Today that answer comes from a search of the source and from memory.
A technical debt assessment answers that question for every program in the system at once. On IBM i, the debt is the distance between what your code does and what you can show that it does. Code that has grown for decades gains programs and copy members faster than anyone documents them. We treat that distance as a plain measure of the code, and the assessment turns it into counted items you can check.
We run the assessment on your production source libraries with AS/Forward, and that page explains how the software runs inside your own network. AS/Forward reads all six RPG dialects through a proprietary ingestion layer. It flags dead code and traces call chains before any AI model touches the code. The report measures the debt in seven sections, and each section answers a question you already ask.
The program count
A technical debt assessment starts from one number, the count of programs we ingested from your production source libraries. Every other section of the report builds on that count. Because AS/Forward handles all six RPG dialects, the count includes your oldest RPG along with your newest.
Migration-impact reporting then scopes the work program by program, before you commit to anything. When the count is a guess, the plan changes each time someone finds another library. When the count comes from the source, the plan starts from a number you can check.
Try one check before the report arrives. Ask your developers to estimate the program count, and then compare their estimate with the report. The gap between the two numbers is the first measure of the debt, because it shows how much of the system nobody had counted.
The interconnection graph
AS/Forward builds interconnection graphs across the whole codebase. The graph connects each program to the programs it calls and the files it uses. You can start from one file and see what else moves when that file changes.
The graph follows calls as well as files. When one program calls a second program that calls a third, AS/Forward traces that chain. Pick a program near the top of a chain, and the graph shows the programs further down.
Copy members add to the list of programs a change reaches. A copy member pulls source from another member into a program at compile time. A change to that member reaches every program that includes it the next time that program compiles. You want that list of programs in hand before anyone edits a shared member.
On the graph, the debt is every connection that nobody wrote down before the assessment. Test the graph on a file you know well, and look at every program connected to it. When a program on that list surprises your senior developer, you have found one of those connections.
The plain-English descriptions
Some of the debt on IBM i is a program that only one person can explain. AS/Forward writes a plain-English description of every program from the ingested source. A developer can learn what a program does from its description before opening the source. The structured read of the source comes first, and the AI works from that structure.
Each program page pairs the source with its description, its dependency edges, warnings for anything unresolved and a readiness status. Because the source and the description appear on the same page, a developer can check one against the other. Run that check first on a program you know well, because it shows you how far to trust the descriptions of programs nobody knows.
The description stays in place when that one person moves to other work. Every developer who opens the program after that starts from the same page.
The warning list
A warning marks something the ingestion layer could not resolve. AS/Forward flags unresolved copy members and missing dependencies as warnings. An unresolved copy member is one the ingestion layer could not find, and the report shows a gap in every program that includes it.
Treat each warning as a task. Your developers track down the missing member or the missing dependency before anyone converts the program that needs it.
You can shorten this list before the report arrives. Ask where the copy members for your oldest programs live today. When the answer is a library outside the production source libraries, add that library to the assessment.
The length of the warning list is a direct measure of the debt in your source libraries. A short list means AS/Forward resolved nearly everything it ingested. A long list shows you where the gaps are before any conversion starts.
The programs nothing calls
AS/Forward flags dead code, which here means the programs that nothing else in the codebase calls. Each program on that list is a candidate to leave the scope before anyone sizes the work.
This list can shrink the plan. Every program you keep is a program someone has to document and test, and a program that does no work still adds that effort. Your developers confirm each program before it leaves the scope. Start with the programs your senior developer already expected to see on the list, and then work through the ones nobody recognizes.
The readiness split
AS/Forward marks clean programs ready, and programs with gaps go to human review before anyone converts them. That split turns one assessment into two working lists.
The ready list is the part of the technical debt assessment you can plan from today. The review list is the debt that still needs a person, and its length tells you how much expert review the project needs before conversion. You can schedule the ready programs first while your developers work through the review list.
When your CFO asks how much of the system is ready to convert, you can forward the size of the ready list.
When the question moves up from programs to whole applications, our page on an application portfolio assessment explains how to score each application from facts you can check.
The scope of one change in the migration view
The migration view scopes the impact of changing one field or one object. Suppose you plan a longer customer number. You pick that field in the view, and the view lists what else changes with it. With that list in hand, a field length change stops being a matter of “should be fine” and becomes a set of programs you can review one at a time.
That list answers the question from the support ticket before the next ticket arrives. A change request can reach the approval meeting with its list of affected programs attached, and the people who approve it see the scope before they sign. When you forward the plan to your risk officer, the list goes with it as evidence.
You can test the view against your own history. Pick a change you made last year, and run the same field through the migration view. Then compare the list with the programs you changed at the time. Look first at any program on the new list that the old change left alone.
Reading the technical debt assessment as one report
Each section of the report answers one question you ask before you approve a change.
| Report section | The question it answers |
|---|---|
| The program count | How much code do we own? |
| The interconnection graph | If we change this file, what else moves? |
| The plain-English descriptions | What does this program do? |
| The warning list | What could the ingestion layer not resolve? |
| The programs nothing calls | Which programs can we set aside? |
| The readiness split | Which programs are ready, and which need a person first? |
| The scope of one change | What else changes when we change this one field? |
One kind of call never appears in the report, and you should plan for it. A program name assembled from a parameter at run time does not appear in any static cross-reference, because no tool that reads source can see that value. That call is missing from the graph and the migration view, and a program on the dead code list could be its target.
Ask your developers which programs build a program name from a parameter. Check those calls by hand before you approve a change or set aside a program from the dead code list. The other edges in the graph come from the source itself, and you can check each one against the code.
If your auditor asks about object settings as well as source, our page on a code audit explains how the two reviews differ.
Start with the assessment
We follow one order on every estate: “The assessment comes first, the target decision comes second, and the second decision is yours.” After the report, AS/Forward converts your code to the target language you pick, such as free-format RPG or Python. Staying on IBM i in free-format RPG and moving the logic to Python are both valid outcomes, and the report sizes the work for either one. Our page on the IBM i modernization assessment explains how that target choice follows the report.
AS/Forward can run the whole assessment air-gapped inside your own infrastructure, and your source code then stays on your network. AS/Forward has one US patent pending.
Call us at 501-232-7188 and ask for a technical debt assessment of your production source libraries. Tell us how many production libraries you have and which program raised your last support ticket, and we can scope the assessment from there. If your source has to stay inside your network, say so on the call, and we plan the air-gapped install from the start. To start in writing, send us a note through our contact page.