I often hear from people I work with
that “System z is old school” or “no one writes code for
mainframes any more.” I quietly let them say their piece – but I
know better. There is plenty of new and exciting work being done
with every hardware platform that IBM offers – System z included.
But I'm getting ahead of myself. In this blog post, I'll look at
mainframe application development, de-bunk some common
misconceptions, and provide links to the latest technology for
streamlining application development on z/OS and Linux for System z.
Current Thinking on Developing
applications for Mainframe Systems
Except for the savvy group of "Master the Mainframe" students from universities, if you ask someone
in a Computer Science program about how much exposure to mainframes
and z/OS they receive you'll find that they give you something of a
hollow stare. “Mainframes? Nobody writes applications for them
any more.” some of them might (erroneously) say. And even if you
ask someone who knows that there is quite a bit of new work done on
mainframe systems every day, they usually think of some archaic
programming environment involving large, heavy, and old text-based
terminals with 24x80 screens.
There's an ongoing perception that
application development for z/OS requires the use of text-based user
interfaces , writing code in assembler language, using ALL CAPITAL
LETTERS, and lacking common comforts such as interactive debuggers.
This causes most people to think that writing applications for z/OS
is hard to do and thus they tend to avoid it whenever possible.
This, in turn, feeds the urban legend of the difficulty in working
with z/OS, since the set of people working with the systems becomes
more isolated. While this ancient history is fun to think about, it
turns out that the reality of developing applications for z/OS is
very much different than this urban legend.
To further the thinking, people also
believe that accessing mainframe systems is nigh impossible to
accomplish. Here is a point that has a level of truth in it. It is
true that mainframe systems don't grow on trees, or fit in our
pockets. And so it has been a bit of a struggle in the past to get
access to mainframe systems. But recent offerings are making this
barrier to entry come down – I'll give some pointers on this at the
end of this blog post.
It turns out that as of 2012, the
common perceptions about application development for z/OS are very
far from reality. The reality here is that application development
for z/OS is very much like application development for any other
platform. You use modern application development tools including
integrated development environments (IDEs), interactive debuggers,
feature-rich, syntax-highlighting editors, including wizards which
generate application source code on your behalf. These tools also
include capabilities to interact with remote databases, allowing
teams to test out complex SQL queries prior to coding them into
applications and support for multiple programming languages including
Java, C/C++, COBOL, and PL/I. The tools assist development teams in
compiling, linking, and debugging their applications, all from a
remotely connected workstation which communicates with the
application running on the mainframe system.
COBOL is a very common language used
for business applications running on mainframe systems. The tools
available for COBOL are vast and deep in function, ranging from code
analysis and understanding tools to advanced code re-factoring
support built into the code editors. This re-factoring support
allows for re-locating blocks of function, ensuring that the
resulting application code still performs the same set of steps after
the re-factoring is complete.
In addition to COBOL, however, Java is
a very popular programming language for mainframe applications. Java
applications running in application server environments, on-line
transaction processing environments, as well as for running batch
programs are all supported, with the tools helping teams write these
applications and deploy them into the target runtime environments.
This still leaves the access to the
z/OS systems as something to take care of. Well, it turns out that
there is a solution to this issue as well. It is now possible to
access a high fidelity emulation environment for application
development of mainframe applications – whether those are COBOL,
C/C++, Java, or even assembler language programs. And for all the
runtime environments into which those applications might run –
batch, WebSphere Application Server, CICS, IMS, or DB2. This
environment can be thought of as an emulation environment rather than
a simulation of mainframe functions running on a workstation. As
such, development teams can get much more familiar with System z and
z/OS systems as well as working with their applications running in
their intended runtime environments.
Now to Make it Easy
All the parts which I've described
above have been available separately for quite some time now. For
those that are wondering what the names of those tools are, here is a
However, the burden has been on the
development organization to realize the integration points amongst
these tools and to figure out how to use the above tools in the
combination for which they were intended.
A solution from IBM takes the guessing
out of this and helps teams realize the benefits of using the above
tools in combination. The Integrated Solution for System z Development (ISD for z) is a combination of
the tools I have noted above. This solution represents the
recommended set of tools for developing applications that contain
mainframe components. The solution and the corresponding
integrations have been optimized to support typical development usage
scenarios. With ISD for z, you get all the capabilities which you
have come to expect when writing code for Linux or Windows platforms,
along with a whole lot more features to enable team collaboration
across projects which have pieces that run on multiple platforms.
Application development for z/OS and
System z is really just like development for every other platform.
Tools exist to help access the system environment, edit, compile, and
debug applications running on the platform, and even understand
existing applications which have evolved over decades of continual
refinement. And access to a z/OS system for application development
purposes is easier than ever before – removing that barrier to
entry which has held development teams back in the past.
Have a look at these and I think you'll
agree that the future is bright for software development – no
matter what the target platform is. In fact, the tools enable
organizations to choose their deployment platform based on their
business requirements, not based on the skill-set of their
organization. This frees up the organization to choose the best
platform for the job to be performed – freedom indeed!