Thoroughly Modern: Simplify IBM i Application Management and Extract Key Insights
October 10, 2022 Ray Everhart
IBM i developers and managers understand all too well that application documentation is often out of date – if it even exists. A study from the Singapore Management University says that developers only spend 5 percent of their time writing new code. They spend 20 percent of their time modifying legacy code, and they spend 60 percent of their time trying to understand the code before they modify it.
As businesses adapt to compete in their industries, IT is pressured to innovate and improve agility while maintaining existing systems. It’s also critical that stakeholders can quickly access data from applications to support decision making. This is a tall order for an average developer, made even more difficult as resources retire and take application knowledge with them. This presents a huge liability for the business – not only in acquiring skilled developers to manage the applications, but also in mitigating the risk when introducing application changes without proper impact analysis.
So, how do we understand our applications in a way that’s efficient and effective?
In a recent webinar, almost 50 percent of attendees reported that they had been working with their applications for fewer than 10 years. We’ve heard from many clients that their applications lack documentation but it’s not realistic to create it manually.
If you’re new to an organization and fortunate enough to have a colleague who knows the application, that person might be able to help you get up to speed. However, that process can take months or years depending on the scope of the application(s).
It also introduces the risk of human error in the sense that you might know the business requirements and the components but you’re unable to efficiently analyze the impact of those changes. We’ve all heard catastrophic stories about how something was missed or we didn’t understand the impact of a change at the last minute. These are the things that keep IT managers up at night.
Businesses running RPG or CA 2E (Synon) applications understand that the need to innovate is inevitable – it’s a digital world and organizations are disrupting industries with technology. From an IT perspective, my recommendation is to start by thinking differently in terms of application management. For many years, the common approach to application management has been, “It’s okay because I have a few subject matter experts that have been with me for a long time.” That’s only acceptable if the application doesn’t change or modernize.
RPG and CA 2E (Synon) applications are typically large and have a monolithic structure. The point of modernizing your code is to break it into small, reusable components. You might have a program, a file, and a display file. Your traditional green screen approach to managing your applications might require you to keep track of a few things. If you decide to modernize your code, you’re going to have multiple smaller pieces. In that case, perhaps the functional area goes from three objects to 40, making the application more difficult to keep track of. As a result, the impact of change is different from having a single monolithic object or several different versions of the same program.
We worked with a client who had a program with 52,000 lines of code that they needed to modularize. Trying to understand that program manually would have been a near-impossible undertaking without a tool that automates the task.
There are many factors that affect how we understand an application. As I mentioned, a lack of documentation is a barrier. When a colleague started developing IBM i applications decades ago, he would print out the programs, review them with a highlighter and look for things that he would need to remember as he was trying to figure out what it did, or what it called. That’s just not the way to do it anymore.
Where Do We Start?
Code cleanup is usually where you’d start for any significant project. Let’s say you want to start modernizing your code – you might be analyzing decades of code. Instead of trying to tackle it all at once, we recommend identifying key areas of the application that benefit the business. This allows you to control the scope and the effort while introducing improvements that add value to the business without bringing in unintended changes. Being able to map your application down to the object level and identify which objects are used helps you modify the things that you need to, and only test what’s necessary.
The most efficient way to improve your application management is to use a tool like Fresche’s X-Analysis to leverage the metadata that you collect about your application. Once you have the metadata, tasks like code cleanup can happen quickly. You can automatically identify the objects you haven’t used in a certain period of time. You can also find out if those objects are independent, or if they are dependent on other objects. You can then create a cross-section of what can be easily removed from your system without modifying any programs.
This is all possible without examining code. Instead, you’re looking at the metadata that X-Analysis captures. X-Analysis allows you to filter and sort your application objects, which makes it a great tool for code cleanup. There’s no point in modernizing code that you don’t use or carry forward, so this saves significant time and effort. For example, rather than performing a system-wide test, you can focus on a functional area.
Using metadata is a great approach to application management for modernization projects. For example, you might want to resize a column and a table (such as making the customer number larger). You need to know what the size of impact is and how you’re going to test it. You may not be able to roll out all of the changes at once. So how do you do it in a way that minimizes the testing, and minimizes the risk? Being able to manage your application, and see the dependencies without looking at the code, gives you better control over the project.
The Importance Of Automated Testing
Because X-Analysis reveals the dependencies, you can very quickly set up a test environment and be sure that you don’t have any cross-contamination from other developers in your test environment. You can then identify all of the objects you need to test in isolation – and make the process repeatable.
When you’re modernizing code, you don’t want to take a big-bang approach. I recommend small bits at a time, which means you’re going to be running these tests over and over and over. Automation is the best way to accelerate your modernization project because setting up those tests and repeating them is going to pay dividends back. This not only applies to the existing project, but when you’re done, you now have additional components of your application that are every bit as valuable as the application itself. The testing is an investment that will more than pay for itself.
X-Analysis provides analysts, developers, architects and operations teams with detailed analysis and interactive diagrammatic constructs that enable rich understanding of existing applications, whether they were developed yesterday or 30 years ago.
This application understanding and management tool enables you to discover information about an application that they would otherwise have to find manually. It greatly accelerates your ability to understand your application and bypass the non-relevant parts of the application. This increases developer productivity because you can zero in on the area that you need to change. At the same time, X-Analysis mitigates risk because it provides automated impact analysis.
Some companies may have a desire to keep a significant amount of design logic from the existing application design and move that to the modernized version of the application. For those situations, X-Analysis provides design extraction functionality that automatically creates JEE and RPG industry-standard modern components and constructs as exports from the recovered designs.
A legacy application component can be rewritten using a combination of the JSF, EGL, Facelets, and persistence frameworks such as Hibernate, all generated by top-down automation from the recovered X-Analysis model. Because each organization’s situation is potentially different, the X-Analysis suite is available in different editions that suit the appropriate development stage or budget constraints of that client.
X-Analysis can recover the design logic from even the most poorly structured application. Whereas, for more structured applications (for example, CA 2E generated applications), X-Analysis can directly extract the details of the existing model. This provides an excellent base for efficient and effective design recovery and reengineering to JEE.
The Next Steps
Ray Everhart is senior product manager of X-Analysis at Fresche Solutions. Everhart has spent years helping IBM i companies by assessing their RPG, COBOL and CA 2E (Synon) applications and processes to improve business outcomes. As product manager for X-Analysis, he works closely with IBM i customers to understand their business goals and technical needs in order to drive innovation within the product suite.
This content is sponsored by Fresche Solutions.