A Playbook for Modernizing the Mainframe, Part 4
Earlier in our playbook, Modernizing Development on Mainframe, my colleague Sujay Solomon described the key criteria for supporting developers towards a successful modernization effort. Developers desire flexibility in using their preferred, best-in-class tools, and they want to do so without adhering to historical practices established by their predecessors. Not surprisingly, a successful modernization effort is highly dependent on developers having the ability to treat the mainframe as any other development platform without having to learn its specificities. In this part of our playbook, I’ll explain how developers can apply a classic technique to more easily maintain mainframe applications.
A picture is worth a thousand words
At CA Technologies I am the product manager for CA Development Environment for z Systems, our company’s enterprise-grade, open IDE for multi-modal development. A large part of my work focuses on helping to improve the productivity for seasoned developers and new-to-mainframe developers – ultimately showcasing that application development on z Systems is not all that different. At times that might seem challenging given that many mainframe applications have grown to resemble huge monoliths – complex systems requiring extensive reading of code, source level debugging, and lengthy exercises to understand application flow and interrelations. You would think that managing such a code base would be a nightmare, but that is only true if developers were limited in their techniques for achieving application understanding.
What I have learned working with our customers is that developers can effectively bypass this complexity by practicing the age-old mantra of visualizing success… and quite literally! Visualization has long been a common technique to facilitate comprehension of complex matters – from scientific equations to designing next generation vehicles, and this exact same technique can be applied equally well to application development.
Make the leap from novice to grandmaster
To illustrate my point, let’s pretend you have your heart set on mastering the game of chess. Like in coding, there is a finite number of “building blocks”; in this case, six different chess pieces with unique rules on how they can be played. That part is easy to understand. The challenge of mastering chess comes from the sheer number of moves available to you as the game progresses, not to mention all the potential moves that your opponent might take in response to your actions. The same applies to application development. After all, sometimes the most difficult challenge is simply figuring out the intentions and logic of the developer who last worked on your code.
In chess, the sequence of moves made over the course of a game is traditionally annotated like in the diagram below.
It’s accurate and easy to carry out… but is this method of recording history also the best way to learn the game? Unless you happen to be an IBM Deep Blue computer, you will most likely benefit more from applying visualization. Visualization not only improves your understanding of what is, but when used creatively, will also facilitate understanding of the what if. That is a game changer for maintaining legacy code. I’ve found that visualization techniques not only help new-to-mainframe developers achieve understanding, but they can also deliver new insights for seasoned developers as well.
Achieve application understanding
Next time you dive into a mainframe application, instead of choosing to read the code line-by-line, apply visualization for a much easier and satisfying experience. Visualization is available in the CA InterTest™ Eclipse UI to help developers to better understand COBOL program execution flow and connections between modules. It’s a tool that can explore, analyze and discover anomalies, leading to more effective maintenance of mainframe applications and improved productivity.
Dynamic graphs act as ‘mini-maps’ that allow you to more easily navigate sections of code in the editor that represent the areas of interest in the execution flow. For example, identifying how code is used during its execution is made easy by jumping to a node that represented the section under review.
From there, the history slider allows playback to see what happened in the graph from the beginning.
Save your statement trace to analyze the graph later, without the need to re-run the debugging session or even to be connected to a mainframe. You can also share your data with colleagues.
Visualization is a powerful technique for understanding and analyzing complex functionalities. If you would like to learn more about visualization and other features available in CA Development Environment for z Systems, feel free to contact me at Dejan.Milinkovic@ca.com.
Better yet, join our developer tech talk series, where my team and I explore the various ways this IDE helps improve productivity. You can catch up on the first four episodes right here: