|
Frequently Asked Questions (FAQ)
General
What is Jazillian?
What is this “natural” Java code that Jazillian generates?
So now, what do I do with the Jazillian generated “natural” Java code next?
How do I get Jazillian?
What percent of my code will Jazillian translate correctly?
Supported Languages and Environments
What languages does Jazillian translate?
Which standards and versions does Jazillian support?
What hardware does Jazillian support (or assume that I'm using)?
Which Operating Systems does Jazillian support (or assume that I'm using)?
What COBOL, C, C++ and Java Packages (or "extensions") do you support? MFC? Swing? JDBC? Others?
Can Jazillian handle embedded languages like SQL?
Architecture and Design
Will Jazillian make my code more object oriented?
What if I want to re-architect my application and/or environment in this transformation process?
What does Jazillian do with my data, data layer, data structures, etc.?
What does Jazillian do with my User Interface? How do you link it?
Technical Details
What happens to my application's input and output files?
What are these "customized translation rules"?
Can users add their own translation rules?
Do you provide any sort of runtime library?
Will Jazillian rename functions and variables to match Java conventions?
How does Jazillian handle “Goto’s”?
Legal Issues
Can I use the code I generating for whatever I want?
What if I'm not comfortable submitting my source code to you?
What is Jazillian?
Jazillian is a solution that translates legacy source code (COBOL, C & C++)
to “natural” Java source code – Java code that looks as if it was hand
written. It is easily readable as Java code; therefore it is highly maintainable
and customizable. Jazillian generated code creates a great starting point
for enhancements and future development of your Java application. Jazillian
does not create “dead-end” proprietary or emulated Java code that is difficult to
understand and nearly impossible to modify. Jazillian generated Java code
becomes your source code; you really can get rid of your original legacy source
code. Jazillian creates a foundation for your Java application for use
today and your future development.
What is this “natural” Java code that Jazillian generates?
Jazillian generated “natural” Java code is Java code that looks as
if it was hand written. Not only is it easily readable as Java code, making it
highly maintainable and customizable, but it has no wrappers, emulation or
proprietary Java code involved. There is nothing artificial about it. Any Java
developer will be able to understand it, maintain it and modify it. See
Jazillian Design Philosophy for more details.
So now, what do I do with the Jazillian generated
“natural” Java code next?
Once Jazillian has translated your legacy code to Java, you may plug
that code into a J2EE, SOA, or some other Java-based architecture. In this way,
you're re-architecting your application while leveraging your existing
business logic code. Now that your application is in Java, you can do
whatever refactoring, redesigning, and re-architecturing is necessary, using
standard, off-the-shelf Java-based tools.
How do I get Jazillian?
Jazillian provides software conversion as a solution or service
to make sure we can get you as close to
100% as possible to “natural” Java code. This is done by Jazillian
working with you to understand what you have and where you want to go with your
overall transformation project (including your application, your architecture,
your J2EE and SOA environment). We typically develop
customized rules to generate Java code that looks exactly the way you want
it, including hooks to make it fit into your architecture.
Just contact us to get started.
What percent of my code will Jazillian translate correctly?
This is difficult to answer as it depends on the complexity of the application
code. If the code is straightforward and is standards compliant without a lot
of complexities, Jazillian will translate 99% to 100% of the code. For an
application that is old, has non-standard constructs, or does nasty things with
pointers and the preprocessor, Jazillian may only translate 90-95% of the
lines correctly. This would probably still mean that using Jazillian would
be significantly worthwhile as a resource in your migration and development project,
but the generated Java code would not be nearly perfect.
What languages does Jazillian translate?
Jazillian translates COBOL, C, and C++
source code to Java code. Java is the only destination language at this time.
Which standards and versions does Jazillian support?
Jazillian's pattern-matching approach allows us to be very flexible and accept many non-standard constructs in COBOL, C, and C++. Because we
only use a language parser in a limited way, the translation is
not tightly tied to any specific standard or vendor. In most cases,
non-standard constructs will simply "flow through" and appear in the
generated Java code. Having said that,
we are careful to accept all code that adheres to common language standards:
COBOL: Jazillian accepts code that conforms to the
most commonly used COBOL standard, "COBOL85". There are several
COBOL standards in use, and many vendor-specific extensions to those standards.
Although we officially only support COBOL85 code, we also handle many
of the smaller vendor-specific constructs. Major vendor-specific
features such as vendor-specific database and user interface code are not handled.
C: Jazillian accepts code that conforms to the latest C
standard, "C99". In addition, we
have added and continue to add support for some gcc
constructs.
C++: Jazillian accepts code that conforms to the latest
C++ standard, "ISO/IEC 14882", published in 1998.
Jazillian does not currently support non-standard
extensions and features for various C compilers.
In many instances, we can build customized translation rules to
accommodate specific non-standard code. The key to making this work is your
definition of what you are using and what you want to replace it with.
What hardware does Jazillian support?
Java primitives are fixed particular sizes, independent of
the hardware.
COBOL field types are replaced by Java primitives that are large enough to
hold the same value. For example, "PIC X(10)" indicates a 10-digit field
which would require a Java "long".
For C and C++, Jazillian provides
a rule which maps each primitive type to a Java primitive type, like this:
unsigned char-->int
signed char-->int
char-->char
unsigned int-->int
signed int-->int
...and so on...
These mappings will be correct for most platforms, but it's configurable.
Which Operating Systems does Jazillian support (or assume
that I'm using)?
Jazillian does not make any assumptions about which operating system
your code runs under. In the case of C and C++, many applications use
preprocessor constructs (e.g. "#ifdef WIN32") to make the code
cross-platform.
By default, Jazillian has no such variables set, as it typically
generates cross-platform Java from any of the platform-specific input code.
However, this is configurable; you may have whatever variables set
that you want for the translation.
Many simple platform-specific references are replaced by Jazillian.
For example, any "\n" at the end of the last printf() argument would be
removed and println() would be used instead. But there will always be
cases that cannot be caught. You might need to replace a hard-coded ":"
with File.pathSeparator, for example.
Any platform-specific references in your code to the Windows
Registry, UNIX devices, etc. must be replaced by hand.
What COBOL, C, C++ and Java Packages (or "extensions") do you
support? MFC? Swing? JDBC? Others?
Jazillian only generates Java code that's part of
the "core" Java language. That
means that the code it produces is all under the "java" directory, nothing
under "javax", "org", or any other directory. It cannot handle any non-core
COBOL, C or C++ packages, such as GUI packages, database accessing packages,
logging facilities, transaction managers, etc.
Can Jazillian handle embedded languages like SQL?
Jazillian currently has some limited capability to convert embedded SQL
into JDBC calls.
If you have embedded code that you want to carry forward and keep inside the
generated Java code (using SQLJ, for example), we can build custom rules
to do that.
Will Jazillian make my code more object oriented?
Generally, no. Jazillian will not redesign your application from being
procedural to object oriented. Each COBOL PROCEDURE SECTION becomes a Java class.
Each C input file becomes a Java class. Each C
struct, union, and enum also becomes a Java class. And of course, each C++ class becomes
a Java class.
And, naturally, the generated
Java code uses the built-in object oriented nature of Java. For example, a
call to a global C function can get changed to one or more calls on a particular
Java object instance:
fseek(v2, v1, 0); --> v2.rewind(); v2.skip(v1);
But beyond that, Jazillian does not do any type of "intelligent re-architecture".
What if I want to re-architect my application and/or
environment in this transformation process?
We will work with you to define custom rules that put hooks into your
business logic to allow it to fit into your new architecture. For example,
your code may need new calls inserted to connect to a database via JDBC or
Hibernate, or calls to a web-based GUI.
See Jazillian Design Philosophy
for more details.
What does Jazillian do with my data, data layer,
data structures, etc.?
If your data is kept in flat files, the generated Java code will continue
to use those flat files. If your data is kept in some database, there are
two options: Either you must replace the database-accessing code with
its Java equivalent, or we may be able to write custom rules to replace
your old calls with new ones.
Typically, when moving a legacy application to a Java environment, you'll
be replacing your current proprietary or vendor-specific database calls with
vendor-neutral calls from your Java code, such as JDBC calls to a relational
database, or calls to a persistence tool such as Hibernate. Jazillian can help
in this conversion by developing custom rules for you.
What does Jazillian do with my User
Interface? How do you link it?
As with database access, you have two options when it comes to hooking
up your Jazillian-generated Java code to GUI code.
Either you must replace the GUI-interface code with
its Java equivalent, or we may be able to write custom rules to replace
your old calls with new ones.
What happens to my application's input and output files?
If your application reads and writes flat files, Jazillian will produce
code that also reads and writes those same files in the same format.
For COBOL,
Jazillian stores your FD and WORKING_STORAGE information into a single
XML file, which is read when your application is running by the Jazillian-generated Java code. For more information, see The Jazillian COBOL-to-Java Approach.
For C and
C++, flat files are typically read and written as streams of bytes, and
so the Java code does the same, and looks very similar.
What are these “custom rules?”
Jazillian is designed as a series of several hundred
pattern-matching rules
that are applied to your legacy code to translate it to Java. Custom
rules are additional rules that we develop with your input, which are
specific to your application and your architecture. Some examples are:
- A Rule to add hooks to your new database, GUI, logging mechanism, etc.
- A Rule to rename files, variables, etc to more meaningful names.
- A Rule to remove hooks to code that will no longer be used in your new Java architecture.
- A Rule for organizing your code into Java packages.
- A Rule for replacing all "long"s with "BigInteger" for better precision.
Ideas for custom rules generally come from you. When you see the Jazillian-generated output for the first time, you may have ideas for changes that you'de
like to make, but you want those changes to be automated.
Can users add their own translation rules?
With Jazillian provided as a solution offering, we typically include
an agreed upon amount of customer rule development, rule modification and
professional services into the scope of what Jazillian provides in
the course of a project. For larger projects in terms of size or duration,
we will consider working with you to develop some of your
own custom translation rules. Exceptions can and do occur and we are open
to discuss other ways of working with you based on the specific needs of
your company and your project.
Do you provide any sort of runtime library?
Yes. We have a small runtime library that allows us to produce
simpler Java code. For example, in C you can determine an object's array index by
subtracting the address of the array from the address of the object. Jazillian looks for
that usage pattern, replacing it with a call to the ArrayUtils.indexOf() method in the
Jazillian Runtime Library.
Here is an example.
Will Jazillian rename functions and
variables to match Java conventions?
To the extent that that's possible, yes. Files and classes will be
named appropriately (for example, hello.c becomes Hello.java).
Variables will be
renamed where possible ("SOME_VAR_NAME" will become "someVarName"),
but not where impossible ("somevarname" will not be changed). Also,
Jazillian provides customizable text files to allow you to
provide your own mappings of existing names to new names for
file names, variable names, and method names. See the links to
app2.txt and files.txt in the C Example Application for examples.
How does Jazillian handle “Goto’s”?
Jazillian uses the goto-removal algorithm described in "Taming Control Flow: A Structured Approach to Eliminating Goto Statements" by Ana M. Erosa and Laurie J. Hendren, September 29, 1993. In this approach, the goto statements are moved closer and closer to their corresponding labels in a series of transformation steps, until the goto statements can just be removed. We made just one small improvement on this algorithm, taking advantage of the fact that Java does let you have "labeled breaks" - a variation on a goto.
This algorithm can produce code that, while correct, is more complicated than
a person would write. We also have additional pattern-matching
rules that will produce simpler Java code.
Can I use the code I generating for whatever I want?
Yes, the code generated by Jazillian is entirely owned by you. This
assumes, of course, that you are the owner of the original legacy source
code file we translated. Jazillian maintains no rights or claims
to the Jazillian generated Java source code. There is no ongoing
code usage cost, compiler cost or translation cost. This may be something
of a relief if you are coming from a COBOL and mainframe world.
What if I'm not comfortable submitting my source code to you?
This is a very common concern in today’s competitive business world and
the world of software piracy and systems security. We typically work with
you on a non-disclosure agreement basis. There are many ways to work
together to insure the protection of your assets and property. Please
contact us to discuss how we can insure that we can work with you to meet
the needs or your corporation and environment.
|
Home
The Jazillian Solution
