The first step in a conversion
is to run the Collector.
The Collector collects over 70 different types of non-standard
code, weeding out "false positives" (e.g. collecting
U DEV and skipping D U) and grouping errors by type.
At the end of the collection stage, you'll have a complete picture
of the conversion task ahead of you.
Since the real work for
is to identify codelets written by hand by hundreds of programmers
over decades, the converter is adapted for each application being
converted. This process takes from 2-10 weeks.
During this time, each time we run ,
it stores the changes it makes. Any time the converter sees a
new codelet it hasn't seen before, it asks the operator to verify
it's conversion, highlighting the old
code, and the new change it
If the operator accepts the change, stores
this information. If not, the converter lets the operator edit
the line on-the-fly, and it stores this change in its "Manual"
database (a Manual Edit Report can be used by testers to focus
on these few routines more carefully).
has now learned
how to convert this codelet into your standard code, and the next
time it finds this exact same code, it will do the conversion
automatically. In this way, it gets smarter and smarter.
is a one-time-use
conversion utility. It's job is to find code you want changed, and
change it to whatever code you want to replace it with.
The application code which you'll use and/or sell to your clients
needs to be written by your staff so that it is unique to your application,
and so that you retain the rights and copyright to your software.
with the idea that you will be writing a set of standard function
calls which it will insert into your routines during the conversion.
(e.g. in the example above, "U
%DEV" will be replaced by "D
In other words, for DSM-Cache conversion, your staff will write
the %ZSTD routine (or whatever you decide to call it) and our staff
will replace the DSM code with calls to your conversion utility.
Once is fully
customized to your application, and your replacement code (e.g.
%ZSTD) has been thoroughly tested, you're ready to do the conversion
- a process which takes about two hours from start to finish!
Ideally, we would like to develop the conversion database on a
Final Version of your software, but that isn't always possible.
to allow new development and maintenance changes can continue during
the conversion process.
The day of the conversion, you'll halt all new development and
move the current version of all your software into the conversion
directory, and run the converter.
database of converted codelets with the routines you're asking it
to convert, and if it finds a difference, it goes back into OPERATOR
mode for that routine, and gets verification from the operator about
each new change.
of extras, such as:
- AUDIT TRAIL: Each change to a line is documented in
an audit global.
- QA TESTING: Every change is stored in a QA Testing database
under: UNTESTED. When your QA staff is doing their testing runs,
you turn on the QA SWITCH, and every time they run converted code
it moves that code from the UNTESTED to the TESTED database, along
with who did the test, what time, what the input values were and
what output resulted. A special QA Report can be run anytime to
see what remains to be tested.
- STANDARD CODE: Because all your code is now running through
a single standard utility (your %ZSTD), you can run your code
in both the old and new systems (e.g. DSM and Cache) simultaneously
- allowing for easier roll-out of new code.
- NO MERGING: Because the conversion is done in one morning,
there's no need to merge changes other departments make to your
- FUTURE DEBUG CAPABILITIES: You can turn on the QA TESTING
functionality on at customer sites to capture values in real-time
so your programmers can better analyze and debug problems.
- EASY CALLS: By replacing non-standard code with function
calls, future development can continue to be implementation-nonspecific,
so future migrations won't require conversions. Remember,
you're not just converting your old code, you're creating a new
standard for all development going forward! (See our
product which checks future code releases for non-standard code:
see The Enforcer.)