Frequently Asked Questions


What are UniqueSoft's customization capabilities?

D*Code is built on a platform designed for flexibility and customization. While the tool does have a large set of built-in capabilities (e.g., size and quality metrics for COBOL programs), most customer engagements have needs beyond generic analysis. D*Code tool can be customized in terms of the input language, the output language, the legacy and target environments, the analysis performed, and the transformations applied. This allows D*Code to exactly match the needs of the project and enables analysis and transformation of systems for which no COTS tools exist.

Examples of customizations from UniqueSoft engagements include supporting custom extensions to COBOL and other mainframe languages, supporting proprietary legacy languages, supporting proprietary deployment environments (and creating transformations to remove the reliance on those environments), adding customer-requested analysis (e.g., Halstead Complexity) and displaying the results graphically, and creating project-specific transformations (e.g., fixing the "JOBOL" created by a third-party COBOL-to-Java tool and removing database access anti-patterns to reduce the time it takes to produce a report).

It is common on mainframes, especially in larger installations, for the languages and environments to have been customized by the vendor for the client's needs. For mainframe technologies not already supported by D*Code, and for client-specific customization to supported technologies, D*Code can be readily customized to support these legacy systems. For example, D*Code can be customized to check code against coding standards.

Domain-specific customizations have been done for insurance, telecommunications, ETL back-office support, database use, transportation control, finance, network control, data management, rule extraction for product support, inventory control, secure communications, authentication and authorization, and digital signal processing. The customizations have covered a wide range of application in D*Code. For example, support has been added for a proprietary legacy language so that applications across the entire company can be modernized, optimizations have been added for DSPs that can also be applied to new DSP families, identification and elimination of database read anti-patterns have been applied to multiple projects with heavy reliance on database access, and recognition of COBOL data layout idioms has been used to help transform COBOL to Java in multiple projects.

What languages are supported?

D*Code currently supports COBOL, Java and SQL as well as several deployment technologies, including CICS, DB2, UNIX/Linux, and various web and cloud frameworks. New input languages can be added by adapting the front-end parsers on the analysis tool.

The complex semantics of some languages are a challenge for tools that cannot perform deep analysis. For example, COBOL data layouts allow one to assign an alternate name to an existing field and to equate values and names. This is important both for analysis (for example, to determine which groups of identifiers are part of a feature) and for transformation to other languages (for example, understanding which 88 level declarations are the same concept as enumerations used in other languages). An 88 level can be assigned any value, so assignments in the code can provide values to the "variable" that was not in the initial declaration. D*Code can extract all values used in the program, including those given in assignments. If values come in from the environment, however, that information is not in the code itself. In this case, the tool allows the user to provide such informationso that the tool can optimize the transformation.

How does D*Code aid the process of database migration?

Translating between languages (for example, COBOL to Java) is a strength of D*Code. Other translations, such as from Java to PL/SQL can be added as customizations. Many of the issues of converting a flat-file database to a hierarchical or relation database stem from the primitive nature of the flat-file database. That is, the database is simply structured chunks of data accessed by their locations on the storage media. Database functionality that is common in modern databases (location independence, indexing, consistency checking, data schemas, data constraints, data normalization, asynchronous access, etc.) is part of the application itself in flat-file systems. D*Code helps uncover this functionality in the legacy code so that the database and the related code can be converted.

In order to understand the contents of the database, the related code must be examined. D*Code can analyze the legacy system, determine all code that reads from or writes to the database, extract the code related to the database, and present this information to the user. For example, denormalization is common in flat-file databases because of the difficulty in maintaining data relationships.D*Code can find all code that reads from or writes to the database, can find replicated code and data types which indicate denormalized data, and can detect specific types of uses of the data such as interpreting some data as an embedded pointer.

As part of the overall process, it is typically also necessary to migrate the related code that uses the databases. This migration covers how the database itself is accessed (e.g., the create and open methods), how the records within the database are accessed (e.g., the read and write methods), and how the data within the records is processed. As with conversion between languages, it is important to understand the database concepts as embodied in the code and to properly translate them, which is a strength of D*Code. For example, code related to hash-key management feature can be eliminated. In addition, code that depends on specific data types used in the database can be migrated to new structures as required. For example, types and code that rely on character values of T and F for Booleans can be translated to actual Booleans, making the resulting code much easier to maintain.

Since the UniqueSoft tool can be customized to check code against coding standards, these checks are also very useful in the transformation process, so that the resulting code after transformation adheres to the standards. This is not possible when using COTS translation tools, and it is a differentiator of D*Code.

How is D*Code typically deployed at a client location?

D*Code is delivered as a self-contained virtual machine (VM) or as a docker container. This VM is installed only on the server, which can be any machine supporting standard virtual machines such as Oracle's VirtualBox or VMWare. This scheme enables rapid and centralized deployment of multiple customized versions of D*Code. The data is also stored on the server with the VM, allowing centralized access to project data.

Each individual user interacts with D*Code through a standard web browser such as Chrome. No special software is required on the user's machine. The tool license is independent of the number of users or the machines used to access the server.

What are the primary differentiators inherent in D*Code capabilities?

There are several general differentiators for D*Code capabilities:

  • The ability to customize the tool to a customer's needs, including the ability to handle undocumented features in compilers, unique and proprietary languages and environments, project-specific analysis needs and views, and overlaying external data on the analysis results. This has been discussed above.
  • The ability to capture deep knowledge about the system instead of just raw data through code analysis using symbolic interpretation and partial evaluation techniques. This knowledge is in the terms familiar to the stakeholders as opposed to how it is represented in the code. This knowledge is important for understanding what features are implemented in the system, where the code is related to those features, and in properly transforming the code to new languages (e.g., recognizing how COBOL data is used and translating to equivalent data using Java idioms).
  • The ability to visualize large amounts of information about the system, including across multiple languages, in ways that allow the user to rapidly gain an understanding of very large code bases through hierarchical abstraction and the ability to interactively drill down to individual lines of code.
  • The ability to apply AI to the modernization process, bringing both cost savings and quality improvements. D*Code acts as an expert assistant to the user, maximizing the efficiency of the subject matter experts and allowing them to focus on the important aspects of the modernization (e.g., understanding where transformations should be applied instead of the tedious and error-prone process of actually applying to transformations to a large code base).
  • The ability to produce test suites that demonstrate functional equivalence of the legacy software and the modernized software. Legacy code often does not have an associated test suite or, if it does, the test suite is neither comprehensive nor updated to reflect changes since the program's creation.

How does UniqueSoft approach business rule extraction?

What it means to be a business rule can change in different domains and applications. In general, though, a business rule is composed of a set of conditions and an action; when some conditions become true, the associated action happens.

Business rules are extracted from the code using the following general process:

  • D*Code automatically extracts an initial set of rules based on all conditions in the code.
  • Based on the initial rule extraction, the tool users identify which conditions are not considered to be business relevant.
  • D*Code then extracts a final set of rules.
  • From the final set of rules, the tool users perform two actions. First, they identify which rules are technical rules and can be ignored in a business-level summary. Second, they supply abstract aliases for the remaining conditions and actions.
  • D*Code automatically applies the selection of technical rules and the abstract aliases to the extracted rules to produce a final set of abstract business rules.

Other D*Code capabilities can be used in conjunction with rules extraction to provide more tailored rules. For example, rules can be extracted for a particular entry point to the code or for individual methods. The code itself can be preprocessed to focus on a particular product line (e.g., a type of insurance offering), to remove rainy-day scenarios, to eliminate dead code or refactor redundant code, etc.

The extracted business rules can be output in multiple formats (HTML, tables, etc.) or translate them to other languages (Java, SQL, FICO Blaze, etc.).

Do I have to pay ongoing license fees to run the modernized application?

No. The generated source code and all required support code is provided.

I don't see my legacy language listed. Can D*Code help me?

Yes. Currently, D*Code currently supports COBOL, Java and SQL as well as several deployment technologies, including CICS, DB2, UNIX/Linux, and various web and cloud frameworks. New input languages can be added by adapting the front-end parsers on the analysis tool.

If the new language being requested is in common use and already on the D*Code roadmap, there is no charge for adding this new language. For unusual languages such as 4GL code generators we will quote a one-time charge to modify our front end to accommodate that input language.

How much manual post processing do I need to do to get output code to work on my target environment?

D*Code can be customized to fully translate code to a new language and migrate it to the target environment.

Can my company use D*Code directly or do we need to hire UniqueSoft to do the work?

UniqueSoft's standard business model is to license the D*Code tool to a systems integrator. UniqueSoft will support the project from behind the scenes with tool customization or consulting as required. In some cases, the systems integrator can also hire UniqueSoft to operated the tool on their behalf. There is an upcharge on top of the tools license to provide this service. However, this type of engagement will require that the work can be done at UniqueSoft's facilities.