Classifications

• • G—PHYSICS
  • G06—COMPUTING OR CALCULATING; COUNTING
  • G06F—ELECTRIC DIGITAL DATA PROCESSING
  • G06F8/00—Arrangements for software engineering
  • G06F8/40—Transformation of program code
  • G06F8/41—Compilation
  • G06F8/45—Exploiting coarse grain parallelism in compilation, i.e. parallelism between groups of instructions
• • G—PHYSICS
  • G06—COMPUTING OR CALCULATING; COUNTING
  • G06F—ELECTRIC DIGITAL DATA PROCESSING
  • G06F9/00—Arrangements for program control, e.g. control units
  • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
  • G06F9/46—Multiprogramming arrangements
  • G06F9/465—Distributed object oriented systems

Definitions

• the present disclosure relates to transformation of computer programs. More specifically, the present disclosure relates to transformation of legacy software
• a software application is written is only one aspect of its makeup.
• a software application is a
• Code is a portion of a software application that is written in a programming
• a special software application called a "compiler” was developed for converting higher level language programs to machine language code which can be executed by the computer.
• Higher level languages allow code to be organized into blocks of code called routines or procedures, which can be used repeatedly, if necessary.
• Software applications also need to be able to manage information.
• Data structures allow data to be organized in an identifiable fashion so that the data can readily
• the code contains instructions for acting on the data
• routines structures and is grouped in segments called routines, hi early software development
• class is a template definition of the routines, called “methods”, and data structures belonging to a particular kind of object.
• the class defines the common properties of the member objects.
• OO programs may be
• inheritance allows users to create a new object first by specifying another
• a user interface is a portion of the application that allows an individual to interact with the software application. In many cases, the user interface is created using forms (fourth generation language - 4GL). A form specifies the appearance of the fields and
• trim that are presented to the user on a display. Fields are individual areas where a user
• Trim is fixed information such as labels, which instruct the user what to
• environment provides for the display of the forms when the application is executed.
• this user interface was restricted to displaying a form of 80
• GUI graphical user interface
• business logic The business logic
• a database management system is a collection of programs that can store, modify, and extract information from a database. Requests for information from a database are made in the form of a query, which is a stylized question. The set of rales for
• SQL query languages
• the information stored in a database can be presented in a variety of formats.
• DBMSs include a report writer program that enables data to be output in the form
• the report writer program also called a "report generator” is a part of a database management system that extracts information from one or more files and
• Data may be
• the format specifications may be saved in a file and reused for future presentations.
• Relational database management systems are a type of database
• DBMS database management system
• the same database may be viewed in many different ways.
• information is stored in the form of tables, for example, a spreadsheet, which refer to data arranged in rows and columns.
• tables for example, a spreadsheet, which refer to data arranged in rows and columns.
• architecture describes the basic infrastructure of the application. One aspect of architecture relates to the number of computers that are involved. A single-tier software
• application is one in which all of the applications and/or systems run on a single computer, including any external calls the software may make to other software
• a software application may call a database management system in order to retrieve or update data.
• a software application may call a database management system in order to retrieve or update data.
• both the software may call a database management system in order to retrieve or update data.
• dumb terminal which is a device capable only of
• a client/server application, or two-tiered software application is one in which the
• N-tiered model only part of the software application is run on the client workstation.
• the client locates an application server containing the business logic and the
• application server may, in turn, contact another computer, such as a database server, in order to complete the processing requested by this client.
• another computer such as a database server
• this chain of events can ultimately involve an unlimited number of computers, the model is called an "N-tiered" model.
• character interfaces are procedural in nature and are implemented in a single-tier model.
• method includes transforming a procedural program into intermediate client-server code, and partitioning the intermediate client-server code into an N-tier application program.
• FIG. 1 shows an example of a conventional computer system
• FIG. 2 shows a flow diagram for a method for transforming a procedural program having procedural language code into an object-oriented program, according to an
• FIG. 3 shows a grammar tree for a legacy language statement
• FIG. 4 shows an abstract syntax tree, according to an embodiment of the present
• FIG. 5 shows a flow chart of a process for converting legacy forms into object
• meta-components which can be used to create a graphical interface, according to an
• FIG. 6 shows a sample visualization of an abstract syntax tree expressed as an
• FIG. 7 shows a flow chart of a process, according to an embodiment of the present
• FIG. 8 shows a schematic representation of a host-based architecture and interface used by procedural, character-based applications
• FIG. 9 shows a schematic representation of an object-oriented, intermediate client-server architecture, to which legacy applications maybe transformed, according to an embodiment of the present disclosure
• FIG. 10 shows a schematic representation of a multi-tier, heterogeneous architecture, according to an embodiment of the present disclosure
• FIG. 11 shows a flow chart of a method for partitioning a transformed application
• FIGS. 12A and 12B show examples of separation of user interface from
• FIG. 13 shows a schematic representation of building client and server images out
• the tools may be embodied in one or more computer programs stored on a computer readable medium and/or transmitted via a
• FIG. 1 shows an example of a conventional computer system which can be
• the tools of the present disclosure may be implemented in the form of a software application running on a computer system (for
• a mainframe personal computer (PC), handheld computer, server, etc.
• PC personal computer
• server etc.
• the software application may be stored on a storage media locally accessible by the computer system, for example, floppy disk,
• compact disk, hard disk, etc. may be accessed remotely by the computer system, for example, via a wired or wireless network, such as a local area network, a wide area
• the computer system is referred to generally as system 100, and may include a
• CPU central processing unit
• memory 104 for example, Random Access Memory (RAM)
• printer interface 106 printer interface 106
• display unit 108 display unit 108
• LAN local area network data
• transmission controller 110 a LAN interface 112
• network controller 114 an internal
• bus 116 and one or more input devices 118, for example, a keyboard, mouse etc.
• input devices 118 for example, a keyboard, mouse etc.
• the system 100 may be connected to a data storage device, for example, a hard disk, 120, via a link 122.
• a data storage device for example, a hard disk, 120
• FIG. 7 includes transforming a procedural program into
• step S71 intermediate client-server code
• step S73 partitioning the intermediate client-server code into an N-tier application program
• the N-tier application program preferably includes a thin client and a plurality of
• the thin client may include user interface components, and the
• server-based components can include business logic components.
• the business logic can include business logic components.
• the components may include web services.
• the server-based components can include a DBMS server component.
• program can include separating user interface logic from application code logic, adding
• GUI graphical user interface
• the character based user interface of the legacy software application can be
• the process may include subprocesses for analyzing the legacy
• process may transfer the original code or may substitute new code.
• procedural language code as intermediate code, processing at least a segment of the procedural language code using the map, creating a first data structure using the
• the method may include suspending the processing of a segment of the procedural language code when a predetermined segment of the procedural language code is detected, and modifying an other intermediate code based on
• code into an object-oriented program may also include creating a second data structure based on the procedural language and the second data structure may be a
• the creation of a first data structure may include locating a node
• code into an object-oriented program can include scanning the procedural language code and creating a map based on the scanned
• the method may further include suspending the step of processing a segment of the procedural language code when a predetermined segment of the procedural language code is detected and modifying another abstract syntax tree based on the
• code into an obj ect-oriented program may also comprise creating a second abstract syntax
• the step of creating the first abstract syntax tree may include
• FIG. 2 shows a flow diagram for a method for transforming a procedural program
• the transformation begins with a mining process 140 which may include discovery 142,
• the meta-components may be operated upon by a transformation process 156 which can include transformation lsubprocess 158 through transformation 4 subprocess 164, where the meta-components may be processed, reorganized and enhanced. During this transformation process, the legacy meta- components are transformed into object meta-components. Finally, during a regeneration process 166, in an extension subprocess 168, libraries are built based on results from the mining process 140, and in a regeneration subprocess 170, the object meta-components are implemented as actual object classes in a specific, object-oriented language.
• a first feature is the creation of a "from anywhere/to anywhere"
• a mining process 140 capable of storing the legacy components as
• meta-components in the repository may be provided.
• a second feature is
• the transformation system is perfo ⁇ ned. Such customization steps can be used to add to,
• transformation system and method may be restarted from the step and component that was being processed when the power failure occurred. To achieve this feature it may be
• the repository selected be a persistent storage facility (e.g., a database
• the mining process 140 discovers resources for a transformation, stores them in
• the repository prepares them and any other meta-component for the transformation.
• the mining process 140 has the ability to report any deficiencies found in the legacy software application that may prevent a complete transformation.
• the mining process 140 may also provides for operator input which may be used when the mining process 140 encounters capabilities of the legacy development
• each transformation methodology can be provided with a set of configuration values which alter the output generated by the process. For instance, a
• Each configuration value may have a default setting which can be overridden by the operator.
• the discovery step 142 queries the legacy software development environment and
• step may scan appropriate logical memory, for example, physical memory blocks and virtual memory pages, according to the operating system present on the computer
• the components scanned may include, but are not limited to, the source code, form definition, application structure, the schema of any related database, forms, frames,
• components are preferably stored as meta-components in the repository, hi addition, for
• the source code may be tokenized or broken down into a stream
• This repository may be a memory cache, a file system, a database or any other suitable
• the analysis step 144 all of the information of a meta-component is analyzed and a map is created for each component.
• the map contains information on where each
• routine and section within a routine starts and stops within the token stream.
• metrics concerning each component may be used to create an Application Analysis Report 152.
• the information from the analysis step 144 is used to establish the initial configuration. This configuration is stored in the meta-
• This meta-component controls the transformation process 156. Some of these parameters may be modified during the
• the GUI Style Wizard 148 provides an operator with the ability to customize the
• Extension Wizard 150 provides the operator with an opportunity to direct the
• transformation process 156 to create a new foundation class library, business object library and front-end library for the application. These new object libraries are built on
• the application analysis report 152 is a comprehensive report on the entire legacy infrastructure, and includes a cross-reference of all resources and detailed information and metrics on each component. It may also provide a listing of problem areas as described above.
• the metrics include: the kind and total number of components
• the transformation process 156 provides a mechanism by which the legacy meta- components now stored in the repository are manipulated to create the object meta-
• the transformation process 156 performs a transformation in which the entire legacy application may be transformed in a multi-stage, parallel process.
• transformation process 156 any particular source statement (in the instance of code), or
• a frame for example, a frame
• process 156 may discover a parameter. That parameter becomes an attribute of the obj ect class being created to replace the frame. Processing of the frame is suspended, the object class is retrieved from the repository, the attribute is added to the object class, the object class is returned to the repository and processing of the source is resumed. Likewise, in
• meta-application can be provided.
• the meta-application is convenient because rather than being tied to a specific implementation of any particular software development environment, it contains constructs which are found in any of these environments.
• transformation process 156 including four transformation subprocesses will be described below.
• the transformation 1 engine 158 disassembles the legacy source code
• a property tree is a hierarchical structure that provides for the storage of an unlimited number of identifiers or properties at any node in the tree. This decomposition is accomplished through several steps. The first step is to develop a grammar representation of the legacy programming
• the legacy language supports is identified in the legacy language (e.g., FOR-ENDFOR, CALL, PROMPT, etc.).
• the statements are grouped into ahierarchy by grouping statements of a common type. For instance, FOR-ENDFOR and WHILE-
• END WHILE are considered loop controls.
• a single root node 200 is created for the property tree.
• properties are created in the tree which are common to all statements. For instance, Line Number may be a property common to all
• classification nodes 202 are created in the tree which
• Loop Counter might be a common attribute of all loop controls.
• statement nodes 204 are created in the appropriate classification node 202 that represent each specific
• At least one common property can be defined at each statement node 204 with a default value that is unique to the statement: the statement type.
• An abstract syntax tree is a specialized version of a hierarchical property tree designed to contain fully decomposed source code.
• An example of an abstract syntax tree is shown in FIG. 4 A root node 250 is created and
• Routine nodes 252 are created for each block of code that exists within the component.
• Classification nodes (not shown) which hold different types of code blocks can be created
• Each routine node 252 has defined parameters which identify the routine.
• Section nodes 254, 256, and 258 are created below the routine node 252 and identify the
• the transformation 1 158 also uses the map created during the analysis step 144
• the map contains information on where each routine and
• transformation 1 158 processes tokens until it
• transformation 1 158 identifies the statement type, it locates
• Transformation 1 158 then parses the statement and replaces the default values of each property with the exact values found in the statement.
• transformation 1 158 maintains relationships between statements.
• ENDFOR can be created as a child node of the FOR statement node. This nesting can continue as deep as needed. Nesting the code in this manner makes it easy to move entire code blocks later during the transformation. Once this process is completed, a complete, organized version of the legacy source code has been created and can now be acted upon.
• a sample visualization of an abstract syntax tree expressed as an XML document is
• the transformation 2 engine 160 is responsible for converting the legacy forms
• the Graphical Interface Form Template tree contains a representation of an empty
• the root node for this form contains a description of the basic
• the property tree can comprise three root nodes. The first
• root node can contain the properties which describes the window.
• a window is an area
• the second root node contains a placeholder for the menu bar.
• a menu bar is a special area usually placed at the top of a
• the third root node contains child nodes which describe the contents of the window itself.
• a default configuration for the window contents can be supplied in the property tree.
• the OO class hierarchy tree describes the class hierarchy of the target object oriented software development environment. This property tree is created
• This class hierarchy defines the foundation class objects which make up the development environment.
• OO class hierarchy tree is created by implementing a property tree which describes each attribute of each class in the hierarchy.
• transformation 2 160 retrieves a meta-component from the repository representing a legacy form (Step S350).
• a new property tree is created which
• Step S352 represents the graphical interface form replacement for the legacy form (Step S352). This is accomplished by first copying the Graphical hiterface Form Template. Transformation
• Step S354 scans the meta-component (Step S354) and, if the code scanned is not a named data
• transformation 2 160 decides what replacement object is to be placed on the
• Step S358 the process can look up the
• Step S362 properties are defined at that node with the default values replaced by those read from the legacy form.
• Step S356) processing of the form is suspended (Step S364) while the meta component for the object class which is to replace the source code associated with the form is suspended (Step S364) while the meta component for the object class which is to replace the source code associated with the form is suspended (Step S364) while the meta component for the object class which is to replace the source code associated with the form is suspended (Step S364) while the meta component for the object class which is to replace the source code associated with the form is
• Step S366 an attribute is added to the object which matches the definition of the field. This is done because in many legacy software development environments, fields on forms are implicitly declared variables in the form's source code. In the OO
• the process scans the abstract syntax tree created in transformation 1 158 for the form's source code. Specifically, the process looks for user commands found in the legacy source. If any are found, any one of several GUI controls (buttons, toolbar icons,
• the new GUI form controls with the method that was generated in the object class that is the transformed representation of the logic associated with the menu command in the
• the corresponding object meta component is retrieved from the repository.
• the corresponding object meta component is
• Transformation 3 162 first takes any parameters of the routine and declares them as parameters of the method.
• transformation 3 162 decides how to convert the statement
• the engine may decide to completely move an
• transformation 3 162 Another part of transformation 3 162 is transforming the procedural context of the
• legacy software application into an object context. This has two aspects. First, in a procedural environment, one component invokes another by calling it. In the OO model,
• Wlienever transformation 3 162 encounters some ldnd of legacy call
• the called object validates the parameters to the call. In some instances the object may require adjustments. Then, in the calling component, the call statement is replaced with
• the first statement is to an Object Request Broker (ORB).
• ORB Object Request Broker
• ORB is a special obj ect whose j ob is to manage the creation of other obj ects based on
• each token is checked to see if it is a reference to what has been transformed into an attribute of the
• Transformation 4 164 is the transformation in this exemplary embodiment. It
• the regeneration process 166 is the reverse of the mining process 140. During the
• the obj ect meta-components created during the transformation process 156 are used to create the actual object classes that are placed in the new software development environment.
• the new graphical interface forms and any other components that maybe needed are created and placed in the new software development
• the extension step 168 builds the new Foundation Class Library, Business Obj ect
• the tools of this application may be applied to transform a legacy, character-
• ABF applications include assorted frames, such as user-specified frames, report frames and Query By Form (QBF) frames.
• QBF Query By Form
• VIFRED is a visual forms editor facility for
• VIGRAPH is an INGRES facility for building graphical interfaces.
• the tools described herein allow a procedural application to be transformed into an obj ect-oriented infrastructure, which may use a client-server architecture as shown, for
• the N-tier application can include (i) a thin-client (containing just the user
• the application source code may automatically be partitioned into user interface
• server-side business logic thin client accessing centrally managed, server-side business logic.
• a process for partitioning a transformed application and deploying it as an N-tier application may include, according to an exemplary embodiment (FIG. 11), performing
• step SI 001 separation of user interface from application code logic
• step SI 003 application state management
• step SI 005 separation of interface logic from business (transactional) logic
• step SI 005 implementation of a browser-enabled, thin
• step SI 007 client interface
• step SI 009 exposure of business logic as server-side components, including web services
• the partitioning of a legacy application into an N-tier application includes separation of user interface from application code.
• FIGS. 12A and 12A example of frame transformation and conversion of code is shown in FIGS. 12A and
• State management is controlled using a new state management object, preprocessor directives, macrovariables, and include scripts.
• the application server can be molded into running as a multi-tier application. This methodology produces an efficient infrastructure for both developing and deploying applications.
• the runtime shifting can be a virtual shifting technique whereby
• RPC remote procedure call
• the client and application server are components deployed to the application server.
• the client and application server are components deployed to the application server.
• RME remote method execution
• Any method that contains SQL or any host based operation can be RME enabled.
• Cover classes for 3GL routines that are not delivered with the client application (or contain embedded SQL) can be RME enabled.
• RME is implemented using a series of preprocessor directives, macrovariables
• the following code block is an example of a build control script included in every application component.
• the script defines the macrovariables for controlling the remainder of the RME process :
• both the thin-client and application server components can be constructed.
• An example is shown schematically

Landscapes

• Engineering & Computer Science (AREA)
• Theoretical Computer Science (AREA)
• Software Systems (AREA)
• General Engineering & Computer Science (AREA)
• Physics & Mathematics (AREA)
• General Physics & Mathematics (AREA)
• Stored Programmes (AREA)

Applications Claiming Priority (2)

Publications (1)

Family

ID=34079271

Family Applications (1)

Country Status (2)

Families Citing this family (4)

• 2004
  • 2004-07-08 WO PCT/US2004/021773 patent/WO2005008488A2/en not_active Ceased
  • 2004-07-08 EP EP04756736A patent/EP1644830A2/de not_active Withdrawn

Non-Patent Citations (1)

Also Published As

Similar Documents

Legal Events