A business analyst submits a ticket to widen the customer number from eight digits to ten. The primary RPG developer looks at the physical file and says the update should be fine. The developer increases the field length. They recompile the main order entry program. They test the green screen. The screen accepts the ten digits. The update moves into production on a Friday afternoon. A change impact analysis would have listed what happens next. At two in the morning, a nightly batch job crashes with a decimal data error. The job stops.
The nightly batch job passed the ten digit customer number to a downstream CL program. That program expected an eight digit parameter. The failure stopped the billing run. The billing failure stopped the general ledger update. The IT director receives a phone call at three in the morning to fix the broken chain. This failure happens because the developer trusted their memory of the system. They looked at a few obvious programs. They missed the scheduled batch job. They missed the CL program.
What change impact analysis means in plain terms
Change impact analysis on IBM i is the list of everything that moves when one thing moves. You pick a single element in your library. You ask the software to document every connection tied to that element. The resulting list tells you exactly what requires a recompile. The list details every program passing the field as a parameter. It details every display file showing the field on a screen. It records every logical file built over the physical file. It records the printer files that put the customer number on a paper invoice.
A complete map eliminates developer guesswork. Your developers near retirement understand the core billing programs. They know which physical files hold the primary data. They still miss the hidden connections built by developers who left the company a decade ago. A proper impact list catches the forgotten data queues. It catches the utility programs buried in utility libraries. It identifies the programs compiled with owner authority. A program compiled with USRPRF(*OWNER) adopts its owner’s authority while it runs. Modifying one of these programs without a complete map introduces severe security risks to the production environment.
Where the built-in cross reference helps and where it stops
IBM i development teams rely on DSPPGMREF to find connections. The developer types the command on the green screen. They specify the program name and a target library. They output the results to an outfile. They query the outfile using SQL. They export the results to a spreadsheet. The team treats this spreadsheet as a complete map of the application environment.
DSPPGMREF reports which files a program references. It records dependencies at the file level. It captures references at compile time. The output produces a list of files used by each compiled program. This built-in function provides a solid starting point for a simple update. The command proves that the main order entry program touches the customer master file.
The built-in cross reference stops at compile time. It misses the connections assembled while the program runs. Runtime-built call targets do not appear in any static cross-reference. A program might assemble a target program name from a parameter passed from a screen. The DSPPGMREF command cannot document that target. The command also misses data queues. It misses triggers attached to physical files. It misses override commands issued in a preceding CL program. Relying on this command leaves your team with a partial picture. The partial recompile leads directly to the batch job failure at two in the morning.
Tracking dependencies outside the compile time cross reference
| Dependency Type | Compile Time Visibility | Runtime Action | Consequence of Missing It |
|---|---|---|---|
| Physical file read | Yes | Retrieves fixed record format | Decimal data error on mismatched field length |
| Display file write | Yes | Pushes formatted data to screen | Truncated digits on user interface |
| Runtime-built call target | No | Program resolves name dynamically | Parameter mismatch on the call |
| Database trigger | No | Fires secondary program on file write | Silent failure of auditing tables |
| File override command | No | Points to alternative file member | Data written to incorrect historical file |
How the copy member multiplies the change
A developer changes a single field inside a copy member. Copy members pull source from other libraries into a program at compile time. A data structure inside the copy member defines the standard customer record. That one copy member might be pulled into 200 different programs. Changing the customer number length in the copy member requires recompiling all 200 programs. The small change ripples across the entire production environment.
The developer must locate every program pulling in that member. The developer must ensure the reading tool can find the member. An unresolved copy member is one the reading tool could not find. Missing an unresolved member means missing a required recompile. The missing recompile leaves old logic running against new file structures. When the untouched programs read the new ten digit database record into their eight digit memory space, the program fails on the read.
The unresolved copy member might live in a personal library. It might be lost on a defunct partition. It might sit in a source file excluded from the nightly backup. You need proper application dependency mapping for copy members across the whole system. The map finds the missing source. The map proves the reading tool resolved the dependency. The map lists the programs the developer recompiles.
How a complete change impact analysis list reads
A complete impact list removes the mystery from the change request. The list documents exactly what moves before the developer touches the code. It organizes the dependencies into clear categories. The document lists programs by name. It records physical files. It details display and printer files. It lists the scheduled jobs that run them. Finally, the list records the members the pass could not resolve.
Your IT director reviews this complete list before approving the change request. The list proves the true scope of the eight digit to ten digit conversion. The developer sees the 200 programs tied to the copy member. The complete list replaces optimism with verifiable data. Under IT general controls for RPG changes, the developer can attach that complete list to the change request before approval.
How AS/Forward maps the interconnection graph
Golden Path Digital built AS/Forward to produce that list. AS/Forward is software that reads IBM i RPG source. It reads six RPG dialects through a proprietary ingestion layer. It builds an interconnection graph across every program, file, copy member and display file. It generates a plain-English description of each program from the ingested source. You can read more about AS/Forward on our software page.
The tool flags unresolved copy members and missing dependencies as warnings. It shows a readiness status per program. The software scopes a change in a migration view. You pick the field. You read what moves. The view lists the programs that need a recompile. AS/Forward carries one US patent pending. We tested the ingestion layer against roughly 5,000 programs drawn from PUB400 and public code repositories.
The software converts to any target language the client picks. Python and free-format RPG are two examples. The AI sits behind the structured read of the source. The ingestion layer maps the connections and generates the descriptions. The model answers questions on top of that structure. It runs against Claude, OpenAI, Gemini or local models on the customer’s own hardware. The preferred deployment is air-gapped inside the client network.
How your team checks the list before trusting it
We tell every client to verify the AS/Forward output on their own system. You pick a complex program you know well. You ask the developer who wrote the program to review the interconnection graph. You compare our plain-English description to your existing documentation. You check the warning list for unresolved copy members.
You run the compile time cross reference and compare it to our runtime map. Your team will see the runtime-built call targets that DSPPGMREF misses. They will see the CL programs that drive FTP transfers. CL programs that drive FTP transfers often hold a user ID and password as literal text. If the customer number change breaks the CL program, the FTP transfer fails. A read of the source finds those literal credentials.
Your developers trace the file overrides. They map the database triggers. They check the programs compiled with owner authority. Your team proves the accuracy of the map before making any target decision. The check builds trust in the data. The trust enables accurate project planning. Accurate planning prevents production outages.
Schedule an IBM i modernization assessment today
Golden Path Digital gives you the data required to manage your RPG environment. We complete the structured read of the source code. You review the interconnection graph. You read the plain-English descriptions. The understanding comes first. The target decision comes second. That second decision belongs entirely to you. Every outcome is valid. You can move off RPG. You can clean up to free-format. You can keep green screens and modernize behind them. You can migrate the database first.
We also build custom software on top of that map. The warning list shows the members the pass could not read. The plain-English descriptions train the new developers. Your IT department regains control over the IBM i partition.
Call Golden Path Digital at 501-232-7188. Ask us to read your production source libraries for the IBM i modernization assessment. We ingest the production source libraries. We hand back the program count. We provide the dependency graph. We deliver the warning list and the list of programs nothing calls. If your security policy keeps source inside your network, ask us about an air-gapped install, where AS/Forward reads the source on your own hardware and nothing leaves. We give your team the complete map.