Skip to main content

Upcycler

Introduction to the Thinkwise Upcycler

The goal of the Thinkwise Upcycler is to jump-start the modernization of your existing legacy application. Depending on your legacy technology, 20% to 50% of the development time will be saved by using the Upcycler.

The Upcycler completely replaces the legacy application and migrates its data automatically to the new RDBMS of your choice. The modernized application has a fully responsive web app user interface and an integrated service tier. After having upcycled your legacy application, you can further develop your new application.

caution

The Upcycler is for advanced users only. For a successful replacement of your legacy application, you will need a team with the expertise of your application, your legacy technology, and the Thinkwise Platform. Please contact Thinkwise or a Certified Partner for more information.

The Thinkwise Upcycler comes with Upcyclers for the relational databases Microsoft SQL Server, DB2, Progress OpenEdge, PostgreSQL, and the Uniface platform.

  • All Upcyclers can be tailored to suit your specific needs.
  • It is possible to develop and use your own Upcyclers for other technologies.

An overview of the Thinkwise Upcycler

  1. Metadata - The first step is to derive as much metadata as possible from your legacy application. Doing this right at the start of your upcycle project saves an enormous amount of time later. Thinkwise provides a separate utility program for this, the Thinkwise Extractor. It extracts the metadata from your legacy application and puts it into a file that can be read by the Thinkwise Upcycler. For some legacy technologies, you can use the export facilities of that technology instead.

  2. Conversion - The next step is to convert your source's metadata into metadata for the Thinkwise Software Factory with the help of an Upcycler. An Upcycler contains a series of steps at three levels, implemented in SQL. The levels inherit their steps from each other.

    • Generic level - This level consists of generic upcycle steps and generic data import steps that have been defined by Thinkwise and cannot be modified. It gives you an easy start in creating your own Upcycler if one is necessary.

      See Generic upcycler.

    • Technology level - The Thinkwise Upcycler comes with several ready-made technology-specific Upcyclers that cannot be modified. If no upcycler is available for your legacy application's technology, you can create your own Technology Upcycler. A Technology Upcycler consists of a technology definition, upcycle steps, and data import steps. The Technology level inherits its steps from the Generic level.

      See Available Technology Upcyclers and Create your own Technology Upcycler.

    • Application level - At this level, you can tailor your Technology Upcycler for upcycling a specific legacy application. It consists of an application definition, upcycle steps, and data import steps. The Application level inherits its steps from the Technology level.

      See Finetune an Upcycler for your application.

  3. Data import - The final step is the Data Importer. This process is structured in the same way as the Upcycler process.

Extract the metadata from your legacy application

To upcycle an application, you first need to extract the model and the data from your legacy application. Usually, the extraction is performed by either the Thinkwise Extractor or the export functionality of your legacy platform. For more information on the export functionality, see the Technology Upcyclers.

The Thinkwise Extractor is a command-line utility for extracting the model and data from legacy applications.

It consists of one executable and a folder containing some scripts. This makes it easy to use, even when no Thinkwise installation is available yet. Scripts for DB2 for iSeries (DB2), MS SQL Server (MSSQL), PostgreSQL (POSTGRESQL) and Progress OpenEdge (PROGRESS) are pre-delivered.

note

Use the 32-bit version of the Thinkwise Extractor if you have a 32-bit data source and the 64-bit version if you have a 64-bit data source.

To use the Thinkwise Extractor:

  1. Copy the executable and the scripts to a computer with access to the legacy database.
  2. Run twupcycle.exe from either the win-x86 or the win-x64 folder, using the appropriate command line parameters.
twupcycle.exe <COMMAND> <ACCESS METHOD> <OPTIONS>
COMMAND
schemaExtract the schema of a datasource.
dataExtract the data of a datasource.
ACCESS METHOD
odbcFor now: always odbc.
OPTIONS
-h, --hPrints help information.
--dsnThe DSN (Data Source Name) of the connection. Required, unless -c, --connection-string has been specified.
-c, --connection-stringThe string for connecting to the data source. Required, unless --dsn has been specified.
--uidOption to explicitly set the user name for the connection string.
--pwdOption to explicitly set the password on the connection string. If no --uid has been specified, this option is ignored.
-e, --extractorThis can be either a zip file or a directory containing script entries under a schema/odbc path relative to the root.
- If you enter a relative path, the Extractor will try to find a match in the current directory and the location of the program.
- The default extension of an archive is .extractor.
- A path with an extension will always try to look for a zip file with the specified extension instead of .extractor. For example, --extractor mssql will try to find an extractor archive in the following order:
-- <current working directory>/mssql.extractor
-- <current working directory>/mssql
-- <program location>/mssql.extractor
-- <program location>/mssql
If this option has not been specified and the input has not been redirected, the Extractor will show a list of .extractor files to choose from, if it detects any.
-o, --output-fileThe file path where the output file(s) should be written.
- For the schema command, you will be prompted for a path if this option has not been specified, unless the output has been redirected (e.g., due to a pipe).
- For the data command, by default, the files will be written to the current working directory.
- Relative paths will be considered relative to the current working directory.
- Output is always written using UTF-8 encoding with a byte order mark (BOM).

Examples

Here are some examples for extracting schema and data. You can adapt them to your own needs or write your own lines.

This example extracts the schema from an MS SQL Server database. Here, it contains --connection-string. This can be replaced by --dsn.

twupcycle.exe schema odbc --connection-string "Driver={ODBC Driver 17 for SQL Server};Server=MyServer\MyInstance;Database=AdventureWorks2019;Trusted_Connection=yes;" --extractor mssql --output-file schema.json

This example extracts the schema from an DB2 database. Note that the default folder for the extractor has been changed here. You can add a user name and password with --uid myuser and --pwd mypassword. If you only add a user name (--uid my user), the user will be prompted for the password.

twupcycle.exe schema odbc --dsn DB2Thinkwise --extractor .\Scripts\DB2 --output-file schemaDB2.json

This example extracts the data from a ProgressOpenEdge database:

twupcycle.exe data odbc --dsn ADTEST99ZZ --uid myuser --pwd mypassword --extractor .\Extractor\Scripts\PROGRESS --output-directory .\Data

This example extracts the data from a PostgreSQL database:

twupcycle64.exe data odbc --connection-string "Driver={PostgreSQL ODBC Driver(UNICODE)};Server=localhost;Port=5432;Database=dvdrental;" --uid myuser --pwd mypassword --extractor postgresql --output-directory .\data

Upcycle your application

1. Create an application in the Thinkwise Upcycler

After extracting the model and data from your legacy software, you need to add an application to the Thinkwise Upcycler:

menu Upcycle > Applications > tab List

  1. Click Add Add.

  2. In tab Form, enter the required information about the application, the source model, the source data, the target model, and the target application database:

    Application
    FieldDescription
    NameThe application's name in the Thinkwise Upcycler.
    TechnologyThe legacy technology in which the application was build.
    ActiveInactive applications will not be shown by the default prefilter.
    Source model
    FieldDescription
    Source modelPreview field for a part of the source model, once it has been imported.
    Model file typeType of data in the model file, gets a default value from the Technology level.
    Model file extensionFile extension of the model file, gets a default value from the Technology level.
    Model file encodingEncoding of the model file, gets a default value from the Technology level.
    Source data
    FieldDescription
    Data folderFolder where the extracted data files will be saved. This has to be a folder on the webserver where Indicium is installed.
    Data file typeType of data in the data files, gets a default value from the Technology level.
    Data file extensionFile extension of the data files, gets a default value from the Technology level.
    Data file encodingEncoding of the data files, gets a default value from the Technology level.
    Target model
    FieldDescription
    ProjectProject ID that will be created for the upcycled application.
    Project versionVersion ID that will be created for the upcycled application.
    Primary application languageThe language for which translations will be generated. For multi-language applications, this will be used as a fallback.
    Project folderProject folder that will be used for your project.
    SF database serverThe database server on which your Software Factory is located. By default, this is the database server of the Thinkwise Upcycler.
    SF database nameThe name of the Software Factory database.
    Target application database
    FieldDescription
    Application database serverThe database server on which your application database must be created.
    Application database nameThe name of the database that will be created. It will be used for importing your application data.

If necessary: add languages

Some technologies support multi-language applications. If the matching Technology Upcycler supports it, you need to add the application languages. This will translate the language codes of your legacy application to the language codes of the Thinkwise Platform.

  1. Add Add the languages in the form on the right.

New application Form for adding a new application with multiple languages to the Upcycler

2. Import the source model

  1. Execute the Import source model import task to load the source model into the application.

After importing the source model, a preview of the model becomes visible in the Source model field.

preview source model A preview of the model in the Source model field

Now all information that your Upcycler needs has been entered into the Thinkwise Upcycler.

3. Execute the upcycle run

menu Upcycle > Upcycle runs > tab Application > tab Upcycle run

  1. Select your application.

  2. Execute the Execute upcycle execute upcycle task.

    This will execute the upcycle steps as defined in your Technology Upcycler. Where needed, it is overruled by steps at the Application level.

    The monitor screen will open automatically.

    Upcycler monitor Follow the progress in the Upcycle monitor tab

4. Inspect the upcycle run

menu Upcycle > Upcycle runs

After the upcycle run has finished, carefully inspect all messages to see if it is necessary to adjust the upcycle steps.

When at least the PROJECT: Create project step was executed, a project has been added to your target Software Factory. If not all steps were successful, the project is incomplete. In that case, remove the project, make the necessary changes to the Upcycler, and execute the Upcycle run again.

  • A list of all messages is available in tab Application > tab Upcycle run > tab Report:

    report Messages in the Report tab

  • To inspect the results in more detail, consult tab Application > tab Executed upcycle steps > tab List:

    • info Information message.
    • error Error message.

    executed upcycle steps Inspect the results in more detail

  • To inspect what data was transferred to the Software Factory, look at tab Application > tab Executed upcycle steps > tab Data:

    data Transferred data in the Executed upcycle steps tab

5. Inspect your application in the Software Factory

After a successful upcycle run, your new project will be available in the Software Factory. Take your time to inspect the result.

caution

Do not make any changes yet, as you may want to finetune your Upcycler and run it again. Moreover, if you change the data model, you will not be able to import the data.

If you think the result is satisfactory, you can move on to the next step: Create your application.

6. Create your application in the Software Factory

In the Software Factory, create your application as usual, by running the Creation process.

  1. Run the Generate definition and Validate definition steps separately, so you can easily inspect the result.
  2. Check the messages carefully to see whether you can or need to finetune your Upcycler.
  3. If you think the result is satisfactory, you can run the Generate source code and Execute source code steps.
  4. If Execute source code is successful, you can start your application. At this stage, there is no data in your application yet.

7. Execute a data import run

menu Upcycler > Data import runs

  1. Select your application.

  2. Execute the Execute data import run task.

    This will execute the data import steps as defined in your Technology Upcycler, where necessary overruled by steps at the Application level.

8. Inspect the data import

menu Upcycler > Data import runs > tab Application > tab Executed data import steps

  1. After the data import run has finished, inspect the information and error messages carefully to see if it is necessary to adjust the data import steps.

    • An overview of all problems is available in tab List.

      executed data import If necessary, analyze the errors in the List tab

    • The full error message for a problem is available in tab Form.

      form The full error message is available in tab Form

    • The generated SQL for analysis of a failed data import is available in tab Transfer code. If the import was successful, the generated SQL was removed to avoid storage of a very large data volume in the Thinkwise Upcycler.

      transfer code The generated SQL for a failed data import

8. Inspect your application

  1. Start your application. It will now have data.
  2. Inspect your application to see if you still want to improve anything in the upcycle process.
  3. If the upcycle process has finished, make a plan for turning your upcycled application into a full-featured Thinkwise application.

Finetune an Upcycler for your application

If your upcycle run needs improvement, you can finetune the Technology Upcycler you are using for your legacy application.

tip

Even if you think that an improvement is valuable to all applications in this technology, it is best to try it on your specific application first.

menu Upcycle > Upcycle runs

  1. Select your application.

  2. Open tab Application upcycle steps.

  3. Add upcycle steps specifically for your application, modify generic steps, or deactivate steps.

    In tab List, you can check the status:

    StatusDescription
    Base statusThe status of the step at the Technology level.
    - Generic - the step has not been modified for this technology.
    - Modified - the generic step has been modified for this technology.
    - Specific - the step is specific for this technology and has no underlying generic step.
    Current statusThe status of the step at the Application level.
    - Inherited - the step has not been modified for this application.
    - Modified - the step has been modified for this application.
    - Specific - the step has been specifically added for this application.

    In tab Form, the following settings are available:

    SettingDescription
    NameThe name of the step.
    ActiveOnly active steps will be executed and shown by the default prefilters.
    Order noThe order in which the steps will be executed.
    DescriptionThe purpose of step's functionality.
    Step codeThe SQL code that is executed for this step.
tip

If you have made a change and wish to revert it to the original technology upcycle step, use the Revert to Technology upcycle step revert task.

application upcycle steps Finetune the Application upcycle steps

Re-run the upcycle

After finetuning the steps, you can rerun the Upcycler.

  1. In the Software Factory, delete the project that the Thinkwise Upcycler has created earlier for this application.
  2. Open the Thinkwise Upcycler (menu Upcycle > Upcycle runs).
  3. Select your application.
  4. Execute the Execute upcycle run task.

Finetune the data import

menu Upcycle > Data import runs

  1. Select your application.

  2. Open tab Application data import steps.

  3. Add data import steps specific for your application, modify generic steps, or deactivate steps.

    In tab List, you can check the status:

    StatusDescription
    Base statusThe status of the step at the Technology level.
    - Generic - the step has not been modified for this technology.
    - Modified - the generic step has been modified for this technology.
    - Specific - the step is specific for this technology and has no underlying generic step.
    Current statusThe status of the step at the Application level.
    - Inherited - the step has not been modified for this application.
    - Modified - the step has been modified for this application.
    - Specific - the step has been specifically added for this application.

    In tab Form, the following settings are available:

    SettingDescription
    NameThe name of the step.
    ActiveOnly active steps will be executed and shown by the default prefilters.
    Order noThe order in which the steps will be executed.
    DescriptionThe purpose of step's functionality.
    Step codeThe SQL code that is executed for this step.
tip

If you have made a change and wish to revert it to the original technology data import step, execute the Revert to Technology data import step revert task.

application data import steps Finetune the data import steps

Re-run the data import

  1. For re-running the data import, you need a generated database with empty tables. This can be achieved in two ways:

    • With your database management tool, delete all records from all tables in your application database. This can be complicated because of the referential integrity constraints between tables.
    • With your database management tool, drop the application database.
  2. Create a fresh database in the Software Factory.

  3. Open the Thinkwise Upcycler (menu Upcycle > Data import runs).

  4. Select your application.

  5. Execute the Execute data import run task.

Create your own Upcycler

The Thinkwise Upcycler comes with Upcyclers for a number of technologies. If no Upcycler is available for the technology you need, you can add your own.

caution

Only create your own Upcycler if you have sufficient knowledge of the technology, the legacy application, and the Thinkwise platform. Contact Thinkwise or one of our Certified Partners for advice on creating a new Upcycler.

1. Extract the model and data

When you are building your own Technology Upcycler, it might be necessary to create scripts for the Thinkwise Extractor as well. However, not all Technology Upcyclers use the files the Thinkwise Extractor produces, and for Platform Upcyclers, it can be more convenient to use the platform's export facilities.

Therefore, you first need to decide how to extract the model and the data from your legacy application.

  • The legacy technology that needs to be upcycled is a database - The easiest way is to use the Thinkwise Extractor. If the database system supports the Information Schema, it is the recommended way since it will result in maximum reuse of generic steps in the Upcycler. If not, use the proprietary catalog tables of the database system.

    • There needs to be one script per table in the catalog or Information Schema. You can use the scripts delivered with the Thinkwise Extractor as examples.

    • Each technology needs a script for extracting the data. You can use the pre-delivered scripts for DB2 for iSeries (DB2), MS SQL Server (MSSQL), PostgreSQL (POSTGRESQL), and Progress OpenEdge (PROGRESS) as examples.

      The default structure of the folders is:

      extractor folder structure The Extractor's folder structure

  • The legacy technology that needs to be upcycled is a platform - Investigate whether your platform has an export functionality for the model information and if you comprehend its resulting file(s). The alternative is to use the Thinkwise Extractor to extract the tables in which the application is defined.

2. Create a new technology in the Upcycler

If the technology you need is not available by default in the Thinkwise Upcycler, you can add one.

menu Definition > Technology upcyclers

  1. Add Add a new Upcycler.

    FieldDescription
    NameName of the technology.
    DescriptionA short description of the technology, for example, for which versions of the technology you are creating this Upcycler.
    LogoThe technology's logo.
    ActiveOnly active technologies will be shown by the default prefilter.
    Default model file typeType of data in the model file, provides a default for the application.
    Default model file extensionExtension of the model file, provides a default for the application.
    Default model file encodingEncoding of the model file, provides a default for the application.
    Default data file typeType of data in the model file, provides a default for the application.
    Default data file extensionExtension of the data files, provides a default for the application.
    Default data file encodingEncoding of the data files, provides a default for the application.

    add a technology upcycler Add a new Technology Upcycler

3. Add the Upcycle steps

menu Definition > Technology upcyclers > tab Technology upcycle steps

On opening, tab List shows the steps that have been inherited from the Generic level.

  1. In tab Form, Add Add new steps specific to your technology or modify generic steps to make them work for your technology. You can also disable steps. Use the Upcyclers delivered by Thinkwise as examples. The modified fields turn yellow.

    FieldDescription
    NameThe name of the step.
    ActiveOnly active steps will be executed and shown by the default prefilters.
    StatusThe status of the step at this Technology level.
    - Generic - the step has not been modified for this technology.
    - Modified - the generic step has been modified for this technology.
    - Specific - the step this specific for the technology and has no underlying generic step.
    TechnologyThe technology to which this step belongs.
    Order noThe order in which the steps will be executed.
    DescriptionThe purpose of step's functionality.
    Step codeThe SQL code that is executed for this step.
tip

If you have made a change and wish to revert it to the generic upcycle step, execute the Revert to generic upcycle step revert task.

add upcycle steps Add upcycle steps to your Upcycler

4. Test your Upcycler

Before continuing to data migration, test your Upcycler thoroughly.

tip

Before testing it with your full legacy application, find or create a small demo application.

5. Create custom data import steps

menu Definition > Technology upcyclers > tab Technology data import steps

On opening, tab List shows the steps that have been inherited from the Generic level.

  1. In tab Form, Add Add new steps that are specific to your technology or modify generic steps to make them work for your technology. You can also disable steps. Use the Upcyclers delivered by Thinkwise as examples.

    • For a Technology Upcycler based on the Information Schema, you only need minimal changes on top of the generic steps. Ideally, only the translation of data types needs to be customized.

    • For a Technology Upcycler for a platform, it may be necessary to put more effort into the data import steps, although it will be less than for the upcycle steps.

      The modified fields turn yellow.

      FieldDescription
      NameThe name of the step.
      ActiveOnly active steps will be executed and shown by the default prefilters.
      StatusThe status of the step at the Technology level.
      - Generic - the step has not been modified for this technology.
      - Modified - the generic step has been modified for this technology.
      - Specific - the step is specific for this technology and has no underlying generic step.
      TechnologyThe technology to which this step belongs.
      Order noThe order in which the steps will be executed.
      DescriptionThe purpose of step's functionality.
      Step codeThe SQL code that is executed for this step.
tip

If you have made a change and wish to revert it to the generic upcycle step, execute the Revert to generic upcycle step revert task.

technology data import steps Create data import steps

6. Test your custom data import steps

Test your customized data import steps thoroughly.

tip

Before processing a full production database, test a smaller set first.

Available Technology Upcyclers

The Thinkwise Upcycler comes with Technology Upcyclers for:

  • MS SQL Server
  • DB2 for iSeries
  • Progress OpenEdge
  • PostgreSQL
  • Uniface 9.5/9.7

These are all based on the Generic Upcycler.

Generic Upcycler

The Generic Upcycler is the upcycler from which all Technology Upcyclers inherit their functionality. It cannot be executed.

menu Definition > Generic upcycler

  • Model extraction - The Generic Upcycler is based on the Information Schema. This is an ISO standard (ISO/IEC 9075-11:2016)for views on the proprietary system catalog tables. It is implemented in multiple database management systems, with some variations. Using the Information Schema increases the reuse of generic functionality. Use the Thinkwise Extractor to create a JSON file with the model definitions.
  • Data extraction - The Generic Upcycler uses the JSON data files produced by the Thinkwise Extractor as input.
  • Upcycle steps:
    • 1000 range – General preparations.
    • 2000 range – Load the source model into tables representing the Information Schema.
    • 3000 range – Cleanup. Remove incorrect, duplicate, and invalid items.
    • 4000 range – Pre-processor. Do partial transformations that are helpful to multiple transformation steps.
    • 5000 range – Transform the information to tables representing the Software Factory model.
    • 6000 range – Prepare the data for transfer to a Software Factory. The result is an insert statement for every step in this range. Every statement does an insert from compressed data that can contain many records.
    • 7000 range – Updates that are performed on the Software Factory after it has been populated.

MS SQL Server Upcycler

  • Model extraction - This Technology Upcycler is based on the Information Model. Using the Information Model schema provides more reuse of generic functionality than the proprietary system catalog tables. Use the Thinkwise Extractor to create a JSON file with the model definitions.
  • Data extraction - This Technology Upcycler uses the JSON data files as produced by the Thinkwise Extractor as input.
  • Deviations from the Generic Upcycler - This Technology Upcycler stays close to the Generic Upcycler, only a few upcycle steps have been modified:
    • All Data import steps are generic.
    • 3400 Cleaner: Object identifiers - SQL Server stores the parameter names (for functions and procedures) including an @. Most databases only store the basic parameter name.
    • 5050 Transform Domains - Handling specific datatypes.
    • 5130 Transform View templates - SQL Server stores the view definition as a full create view statement whereas most databases only store the body of the view definition.
    • 5150 Transform Procedure templates - SQL Server stores the procedure definition as a full create procedure statement whereas most databases only store the body of the procedure definition.
    • 5180 Transform Function templates - SQL Server stores the function definition as a full create function statement whereas most databases only store the body of the function definition.
    • 5230 Transform Trigger templates - SQL Server stores the trigger definition as a full create trigger statement whereas most databases only store the body of the trigger definition.

DB2 for iSeries Upcycler

  • Model extraction - This Technology Upcycler is based on the Information Model. Using the Information Model schema provides more reuse of generic functionality than using the proprietary system catalog tables. Use the Thinkwise Extractor to create a JSON file with the model definitions.
  • Data extraction - This Technology Upcycler uses the JSON data files produced by the Thinkwise Extractor as input.
  • Deviations from the Generic Upcycler - This Upcycler stays close to the generic functionality, only a few upcycle steps have been modified:
    • All Data import steps are generic.
    • 5030 Transform Columns - Column defaults are handled differently.
    • 5050 Transform Domains - Translation of DB2 datatypes.
    • 5110 Transform Check constraints - Code is stored slightly different.
    • 5260 Fix: Code for changed table names - Disabled due to syntax differences.

Progress OpenEdge Upcycler

  • Model extraction - Since Progress OpenEdge does not support the Information Model, this Technology Upcycler is based on the proprietary system catalog tables. Use the Thinkwise Extractor to create a JSON file with the model definitions.
  • Data extraction - This Technology Upcycler uses the JSON data files produced by the Thinkwise Extractor as input.
  • Deviations from the Generic Upcycler
    • This Technology Upcycler is not based on the Information Model. Therefore, most steps are modified.

PostgreSQL Upcycler

  • Model extraction - This Technology Upcycler is based on the Information Model. Using the Information Model schema provides more reuse of generic functionality than using the proprietary system catalog tables. Use the Thinkwise Extractor to create a JSON file with the model definitions.
  • Data extraction - This Technology Upcycler uses the JSON data files produced by the Thinkwise Extractor as input.
  • Deviations from the Generic Upcycler - This Technology Upcycler stays close to the Generic Upcycler. Only a few upcycle steps have been modified:
    • All Data import steps are generic.
    • 4200 Pre-processor: Collect constraints for domain content - Syntax and functionality differences make a deviation from the Generic Upcycler necessary.
    • 4510 Pre-processor: Unsupported data types - This additional step has been added because PostgreSQL has many data types that are not supported by the Software Factory. These data types are not used often.
    • 5030 Transform Columns - Column defaults are handled differently.
    • 5050 Transform Domains - Translation of database-specific data types.
    • 5110 Transform Check constraints - Due to SQL syntax differences, check constraints have been added as comments.
    • 5030 Transform Subroutine parameters - PostgreSQL supports output parameters on functions, as most databases and the Software Factory do not.

Uniface 9.5/9.7 Upcycler

The Uniface Technology Upcycler imports more detailed information than the other Technology Upcycler scripts:

  • Data model: tables, columns, domains, relations.
  • GUI model: controls, prefilters (code inactive), expression fields (code inactive), variants.
  • Functionality: code organized per code group (code inactive), defaults (code organized per column).

Compared to the Generic Upcycler:

  • Model extraction - This Technology Upcycler is based on the Uniface Dictionary. Use the Export form in the Uniface IDE to make a full export of your application. Click Select All > Exclude Uniface defaults > Export to create an XML file with the model definitions.
  • Data extraction - This Technology Upcycler uses the XML data files as produced by the Uniface Convert Data form as input.
  • Deviations from the Generic Upcycler - This Technology Upcycler does not inherit much from the Generic Upcycler. It does follow the same high-level architecture.