Skip to main content



Introduction to the 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.

At the moment, the Upcycler can only be applied by a Thinkwise representative.

Quick reference guide to the Upcycler​

The Upcycler derives as much metadata as possible from your legacy application. Deriving metadata in the beginning, saves a huge amount of time later on in your project. Since the metadata deriving process depends on the type of legacy technology that you are using, the Upcycler process contains technology-dependent and solution-dependent phases.

Phases in application development with the Upcycler:
1. Upcycler: Deriving tables and columns (technology-independent).
2. Upcycler: Deriving metadata (technology-dependent).
3. Upcycler: Deriving metadata (solution-dependent).
4. Upcycler: Cleaning up the unused parts of your legacy application.
5. UI Enricher: Adapting and enriching the user interface.
6. Registering all your requirements (optional).
7. Additional functionality (instantly available).
8. Finish your project by optimizing your UI, adding business rules, and adding tests.

1. Deriving tables and columns (technology independent)​

In the first phase, the Upcycler derives all the tables and columns from the legacy application. Most of the time, this is done by migrating the legacy database to an SQL server and then reading the metadata from the SQL server. This is also possible for DBF files. In some cases, the metadata are imported directly, as with Uniface (see: The Uniface Upcycler).


Some legacy technology uses naming conventions with a very limited number of characters, for instance, RPG with only 8 characters. This results in very technical names. We strongly advise you to rename all objects more descriptively because these will be used when you add your business rules later on.

After creating a new database, the data can be migrated. This is quite easy because the structure is the same as in the old database. When you further develop your new application and make changes to the data model, the Software Factory will take care of the data migration automatically.

The only constraint is to use a relational database or a relational driver for filing systems or hierarchical databases.

2. Deriving metadata (technology dependent)​

Based on the technology of your legacy application the Upcycler derives the following meta data:

1 - User defined datatypes (udd):

  • Since these are mandatory in the Software Factory, udd’s will be created if they are not available in your legacy application.

2 - Relations between tables:

  • If relations are declared in your legacy application, these are used.

  • If relations are programmed, the Upcycler derives them based on the existing naming conventions in your legacy application. Most of the time it is possible to derive more than 95% this way.

    • With the created relations the Software Factory is also able to check the integrity of the data coming from your filing system and show the corrupt data (if applicable).

Relations are not only important for data integrity but are also used in the UI model for:

  • Combo boxes and popup screens to select a foreign key value.
  • Defining a detail tab or detail tile.

3 - UI definitions:

  • If your legacy application has been built with a 4GL environment, it might be possible to derive:

    • Controls.
    • Grid and Form definitions.
      • Order of columns.
    • Screen structures.
  • In other environments at least controls from the data types can be derived.

4 - Source code:

  • The source code of the UI is ignored because the Thinkwise Platform uses its own UI technology which will take care of this functionality based on the UI model.

  • The source code of the business rules can sometimes be reused as specification for the new code. In that case the old code is placed as comment at the right place in the Software Factory. The developer can read the old code and convert it to SQL.

5 - Examples of technologies that have been upcycled by Thinkwise:

  • DBF files.

  • DB2/RPG.

  • Cobol.

  • Uniface.

  • Access.

  • Lotus Notes.

  • Excel.

  • SQL server.

  • Oracle.

  • DB2.

  • Etc.

3. Deriving metadata (solution dependent)​

Often, useful metadata is available in the solution itself, for example:

  1. Messages.
  2. Translations of all objects.
  3. Menus.

It is worth looking for additional metadata because it saves a lot of time later on in the development process.

4. Cleaning up the unused parts of your legacy application​

If the legacy software is a generic off-the-shelf application, probably only a fraction of it is used. In that case, it makes sense to remove all the unused parts, so the new application will become much easier to maintain.

Of course, all empty tables and empty columns can be deleted, but also columns with only one (default) value are often not useful anymore. Whether the same applies to tables with only a few records requires further investigation since it depends on the situation.

5. Adapting and enriching the user interface​

The Thinkwise Platform has an integrated UI Enricher. Based on your current model and data in the database, the UI Enricher can automatically generate or optimize certain UI definitions. For instance, you can choose the applicable screen type based on the number of columns and records in the main object on the screen.

For more information, see UI Enricher.

6. Registering all requirements (optional)​

All your requirements can be registered in the Thinkwise Platform. Sometimes these requirements are already part of your legacy application.

Therefore, the requirements may also be derived from other sources such as Visio diagrams, Word documents, or even other requirements tooling. In that case, you can import this data separately.

7. Additional functionality (instantly available)​

After your legacy application has been upcycled, the following functionality is instantly available without the need for any programming:

8. Finish your application​

To finalize your new solution, you need to:

  • Improve the user interface for the most used screens.
  • Add the more complex business rules and algorithms.
  • Add the unit and process tests.
  • Add other features necessary to your application.
  • Deploy and implement your application.
  • Educate your users on how to use the application.

The Upcycler will have saved 20% to 50% of your time but more importantly, your new application will never age again and is fully future proof.

The Uniface Upcycler​

The Uniface Upcycler imports more detailed information than the other 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).

See also: Replace Uniface applications with the Thinkwise Upcycler - YouTube

UI Enricher​

Introduction to the UI Enricher​

The Upcycler creates a lot of tables and columns, and sometimes relations (depending on the legacy platform). The Upcycler only imports the data model from the legacy application. Basic forms are created by the Software Factory. The fields are plain text fields, so no controls are distinguished. To improve this, Thinkwise uses the UI Enricher.

The UI Enricher contains ready-to-use scripts that adapt and enrich the user interface to provide it with a first, basic level of usability. The strength is that with one query an application is uniformly updated over its full width. It is especially suitable for large applications and results in high productivity and quality.


Note that the UI enricher can be used only once to smarten up the first results after using the Upcycler, or in a new construction after the data model has been set up. At a later stage in the development process it is only possible to use Dynamic modelling to, for example, adjust and expand the user interface on a continuous basis.

Available scripts for the UI Enricher​

The following scripts are available. At the moment, the UI Enricher and its scripts can only be applied by a Thinkwise representative.

Scripts for the UI Enricher
Determine the number of records per table
Adjust the field width to the length of the domain
Automatically resize the grid (meta level)
Datatype max (note fields) in a form
Form group 'General' at the start
Group fields in a form or list
Control based on the number of elements
Add a calculator to numerical fields
Web and email controls based on the available data
Foreign keys: always a popup, but a combo if less than x records
Determine lookup fields by name
Fix columns in a list up to the lookup field
Determine the screen type per table, based on the number of columns, records and resolution
Activate a combined filter (partly available)
Display the total number of records under the primary key
Hide identifiers without semantic value
Create a prefilter for every element in a domain that contains elements
Deduce currency control from name or data
Activate a sum total in a list, in case of a control currency or calculator
Add functions as a subroutine
Import Visio
Extra: convert Y/N fields to BIT/checkbox