A developer on your team opens a change ticket for a one-line fix in an RPG program. Seven other programs call that program by name in their own source. The ticket records the fix and the approval, and it lists none of the seven callers. Without the callers, the ticket loses the call chain, and a person who opens it later cannot see which programs the fix could reach. Under IT general controls, that ticket is part of the change management record you keep for each change. The developer can add the seven callers to the ticket before anyone approves the fix.
What IT general controls cover
IT general controls cover the security and compliance side of system development, and change management controls are one part of them. Organizations in financial services keep IT general controls to comply with rules such as the Sarbanes-Oxley Act, or SOX. One common grouping splits the work into five domains: access controls, change management, data backup and recovery, security management, and IT operations controls.
Change management controls cover any change to IT infrastructure or code. They also include the planning and documentation of each change. On IBM i, a one-line RPG fix falls under this domain, and so does a program your team removes from a library.
What SOX ITGC change management asks your team to show
Change management controls help your company document each change and authorize it. One example of such a control is a change ticket with approvals and a test and rollback plan. That ticket gives your team a formal process to request, approve, test and deploy each change.
For an RPG change, the ticket already shows who asked for the change and who approved it. You can build a fuller record by attaching two more items to the same ticket. The first is an impact list of the programs and files the change touches. The second is a plain-English description of each program on that impact list, as the program stood before the change.
These two items are one way to build the record, and you decide whether to use them. With both items attached, the approver checks the change against a list of the programs it touches. When your team prepares for a change management audit, it can start from the change tickets it keeps today and add these items to each one.
The developer who writes the test and rollback plan can work from the impact list in the same ticket. That developer tests each program on the impact list before the change goes in. The same person then writes the rollback plan to cover each of those programs by name. A regression test plan scoped from the code puts those tests in order, and it starts with the programs that update the changed file.
How the migration view lists what a change moves
The question for any RPG change is short: “If we touch this, what else moves?” We built AS/Forward to answer that question from a map of your whole codebase.
AS/Forward reads your RPG source through a proprietary ingestion layer and parses the codebase programmatically. From that parse, it maps every dependency and traces the call chains between programs. It also generates a plain-English description of each program from the same parse, before any AI model touches the source.
With the dependency map, you can change a file and see what else the change affects. The descriptions come from the ingested source itself, and they hold up when a developer checks them against the code.
The migration view is the part of the AS/Forward dashboard you open for a single change. You choose a specific field or object, and the migration view scopes the impact of changing it. It then shows what else would need to change with it. That output is the impact list: the programs and files the map links to the change.
Read our AS/Forward page to see the migration view beside the other views in the AS/Forward dashboard. If you want the method behind an impact list in more depth, read our post on change impact analysis.
What a change record on IBM i can include
A change record on IBM i draws its items from three places. Your change ticket supplies the approvals and the plan, and AS/Forward supplies the rest from the migration view and the program pages.
| Record item | Where it comes from |
|---|---|
| The approvals and the test and rollback plan | Your change ticket |
| The impact list of programs and files the change touches | The migration view |
| The plain-English description of each program on the impact list, as it stood before the change | The program page for that program |
| The dependency edges of each program on the impact list | The program page for that program |
| Warnings for an unresolved copy member or a missing dependency | The program page for that program |
| The readiness status of each program | The program page for that program |
Each program page pairs the source with its description, its dependency edges, its warnings and a readiness status. A developer can check each dependency edge against the source on the same page. The readiness status depends on the confidence of the ingestion layer in its parse of that source. Clean programs get the ready status, and programs with gaps go to human review before anyone converts them. If a program on the impact list is waiting for human review, note that in the ticket.
The description from before the change shows what each program did as of the last ingest before your team approved the change. After the change goes in, you can ingest the new source and compare the new description with the one in the record.
The developer and the approver add these items to each change record in four steps.
- Before approval, the developer attaches the impact list from the migration view to the change ticket.
- Next, the developer attaches the plain-English description of each program on the impact list, as the program stood before the change.
- The approver then copies each warning from the program pages on the impact list into the ticket.
- After the change goes in, the developer files the impact list with the test results in the same change record.
Using the impact list to find a root cause
Change management controls also help a company perform a root cause analysis when something goes wrong. Say a nightly job fails the morning after an RPG change goes in. The operator sees which program stopped, and the first step is to ask whether the change touched that program.
In the change record, look for the failed program on the impact list. If the program appears there, start with the change. The plain-English description in the record shows what the program did as of the last ingest before the change. Your developer can compare that description with the new source and look for the difference behind the failure.
If the failed program is missing from the impact list, look at the other changes that went in on the same day. Then check whether the failed program and the changed program connect through a program name built at run time, because the impact list cannot include that call.
If you find a run time call between the two programs, write it into the change record. The developer who traces the next failure in that program can then start from a record that already lists the call.
Access questions belong to a different domain
Some questions about a change belong to access controls, a separate domain of IT general controls. Who can change a program on your production system is an access question. The impact list shows what a change touched, and access controls cover who had the authority to make the change. When your team gathers evidence for that domain, start with our post on the IBM i security audit, because it covers the access side.
What the map cannot show
An impact list reflects the source as of the last ingest, because AS/Forward works from the source it ingested. Before you attach an impact list to a change ticket, check the date of the last ingest. If anyone changed the source after that date, ingest the source again before you attach the list.
Copy members raise a second limit. At compile time, each copy member adds its source to the program that includes it. An unresolved copy member is one the reading tool could not find. AS/Forward raises a warning on the program page for an unresolved copy member, and it raises a warning for a missing dependency too.
Calls built at run time raise a third limit. A program name assembled from a parameter at run time does not appear in any static cross-reference. No tool that reads source can see that value. A call built at run time raises no warning. Search your RPG source for calls that build the program name from a parameter. Add any caller you find to the change ticket.
Your team can also compare the impact list with the output of IBM’s DSPPGMREF command. DSPPGMREF reports which files a program references at the file level, and it captures those references at compile time. If DSPPGMREF reports a file that the impact list leaves out, check the date of the last ingest first. Then look at the warnings on that program page for an unresolved copy member or a missing dependency.
If your team wants to test a program description before it goes into a change record, read our post on checking AS400 documentation against the compiled source.
Within those limits, the impact list includes every caller that states the called program in its source, as of the last ingest.
Your change process and approvals stay yours
Your team keeps its change process, and the approvals stay with the people who sign them today. We supply the map and the program pages, and your team attaches them to its own change records.
In the recommended deployment, AS/Forward runs air-gapped inside your own infrastructure, and the source code behind your change records stays on your network. When you forward a change record to your risk officer or your CFO, the plain-English descriptions explain the changed programs in words they can follow. Your team can use the map and the program pages for audit prep or for planning before it converts a single line.
You can keep every program as it is today and attach impact lists to each change ticket. You can also convert programs later, after the assessment sizes the work. Both choices are valid. The tool does not force a rewrite you did not ask for.
Tell us how your team records RPG changes
When you ask us to map your RPG library with AS/Forward, each change record your team keeps can include an impact list from the migration view. Each record can also include the plain-English description of every program on that list.
The assessment comes first and sizes the work. Read our page on the IBM i modernization assessment before you call, because it explains that first step.
Call 501-232-7188 and tell us how your team records RPG program changes today. Tell us roughly how many programs are in your library, and whether your change tickets list the callers of each changed program. If you already compare a change with DSPPGMREF output, tell us that too. If you prefer to write, send the same details through our contact page.